comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"not a system admin" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
/// @notice modifiers
import { LibMeta } from "../shared/libs/LibMeta.sol";
import { LibAdmin } from "./libs/LibAdmin.sol";
import { LibConstants } from "./libs/LibConstants.sol";
import { LibHelpers } from "./libs/LibHelpers.sol";
import { LibObject } from "./libs/LibObject.sol";
import { LibACL } from "./libs/LibACL.sol";
/**
* @title Modifiers
* @notice Function modifiers to control access
* @dev Function modifiers to control access
*/
contract Modifiers {
modifier assertSysAdmin() {
require(<FILL_ME>)
_;
}
modifier assertSysMgr() {
}
modifier assertEntityAdmin(bytes32 _context) {
}
modifier assertPolicyHandler(bytes32 _context) {
}
modifier assertIsInGroup(
bytes32 _objectId,
bytes32 _contextId,
bytes32 _group
) {
}
modifier assertERC20Wrapper(bytes32 _tokenId) {
}
}
| LibACL._isInGroup(LibHelpers._getIdForAddress(LibMeta.msgSender()),LibAdmin._getSystemId(),LibHelpers._stringToBytes32(LibConstants.GROUP_SYSTEM_ADMINS)),"not a system admin" | 102,869 | LibACL._isInGroup(LibHelpers._getIdForAddress(LibMeta.msgSender()),LibAdmin._getSystemId(),LibHelpers._stringToBytes32(LibConstants.GROUP_SYSTEM_ADMINS)) |
"not a system manager" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
/// @notice modifiers
import { LibMeta } from "../shared/libs/LibMeta.sol";
import { LibAdmin } from "./libs/LibAdmin.sol";
import { LibConstants } from "./libs/LibConstants.sol";
import { LibHelpers } from "./libs/LibHelpers.sol";
import { LibObject } from "./libs/LibObject.sol";
import { LibACL } from "./libs/LibACL.sol";
/**
* @title Modifiers
* @notice Function modifiers to control access
* @dev Function modifiers to control access
*/
contract Modifiers {
modifier assertSysAdmin() {
}
modifier assertSysMgr() {
require(<FILL_ME>)
_;
}
modifier assertEntityAdmin(bytes32 _context) {
}
modifier assertPolicyHandler(bytes32 _context) {
}
modifier assertIsInGroup(
bytes32 _objectId,
bytes32 _contextId,
bytes32 _group
) {
}
modifier assertERC20Wrapper(bytes32 _tokenId) {
}
}
| LibACL._isInGroup(LibHelpers._getIdForAddress(LibMeta.msgSender()),LibAdmin._getSystemId(),LibHelpers._stringToBytes32(LibConstants.GROUP_SYSTEM_MANAGERS)),"not a system manager" | 102,869 | LibACL._isInGroup(LibHelpers._getIdForAddress(LibMeta.msgSender()),LibAdmin._getSystemId(),LibHelpers._stringToBytes32(LibConstants.GROUP_SYSTEM_MANAGERS)) |
"not the entity's admin" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
/// @notice modifiers
import { LibMeta } from "../shared/libs/LibMeta.sol";
import { LibAdmin } from "./libs/LibAdmin.sol";
import { LibConstants } from "./libs/LibConstants.sol";
import { LibHelpers } from "./libs/LibHelpers.sol";
import { LibObject } from "./libs/LibObject.sol";
import { LibACL } from "./libs/LibACL.sol";
/**
* @title Modifiers
* @notice Function modifiers to control access
* @dev Function modifiers to control access
*/
contract Modifiers {
modifier assertSysAdmin() {
}
modifier assertSysMgr() {
}
modifier assertEntityAdmin(bytes32 _context) {
require(<FILL_ME>)
_;
}
modifier assertPolicyHandler(bytes32 _context) {
}
modifier assertIsInGroup(
bytes32 _objectId,
bytes32 _contextId,
bytes32 _group
) {
}
modifier assertERC20Wrapper(bytes32 _tokenId) {
}
}
| LibACL._isInGroup(LibHelpers._getIdForAddress(LibMeta.msgSender()),_context,LibHelpers._stringToBytes32(LibConstants.GROUP_ENTITY_ADMINS)),"not the entity's admin" | 102,869 | LibACL._isInGroup(LibHelpers._getIdForAddress(LibMeta.msgSender()),_context,LibHelpers._stringToBytes32(LibConstants.GROUP_ENTITY_ADMINS)) |
"not a policy handler" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
/// @notice modifiers
import { LibMeta } from "../shared/libs/LibMeta.sol";
import { LibAdmin } from "./libs/LibAdmin.sol";
import { LibConstants } from "./libs/LibConstants.sol";
import { LibHelpers } from "./libs/LibHelpers.sol";
import { LibObject } from "./libs/LibObject.sol";
import { LibACL } from "./libs/LibACL.sol";
/**
* @title Modifiers
* @notice Function modifiers to control access
* @dev Function modifiers to control access
*/
contract Modifiers {
modifier assertSysAdmin() {
}
modifier assertSysMgr() {
}
modifier assertEntityAdmin(bytes32 _context) {
}
modifier assertPolicyHandler(bytes32 _context) {
require(<FILL_ME>)
_;
}
modifier assertIsInGroup(
bytes32 _objectId,
bytes32 _contextId,
bytes32 _group
) {
}
modifier assertERC20Wrapper(bytes32 _tokenId) {
}
}
| LibACL._isInGroup(LibObject._getParentFromAddress(LibMeta.msgSender()),_context,LibHelpers._stringToBytes32(LibConstants.GROUP_POLICY_HANDLERS)),"not a policy handler" | 102,869 | LibACL._isInGroup(LibObject._getParentFromAddress(LibMeta.msgSender()),_context,LibHelpers._stringToBytes32(LibConstants.GROUP_POLICY_HANDLERS)) |
"not in group" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
/// @notice modifiers
import { LibMeta } from "../shared/libs/LibMeta.sol";
import { LibAdmin } from "./libs/LibAdmin.sol";
import { LibConstants } from "./libs/LibConstants.sol";
import { LibHelpers } from "./libs/LibHelpers.sol";
import { LibObject } from "./libs/LibObject.sol";
import { LibACL } from "./libs/LibACL.sol";
/**
* @title Modifiers
* @notice Function modifiers to control access
* @dev Function modifiers to control access
*/
contract Modifiers {
modifier assertSysAdmin() {
}
modifier assertSysMgr() {
}
modifier assertEntityAdmin(bytes32 _context) {
}
modifier assertPolicyHandler(bytes32 _context) {
}
modifier assertIsInGroup(
bytes32 _objectId,
bytes32 _contextId,
bytes32 _group
) {
require(<FILL_ME>)
_;
}
modifier assertERC20Wrapper(bytes32 _tokenId) {
}
}
| LibACL._isInGroup(_objectId,_contextId,_group),"not in group" | 102,869 | LibACL._isInGroup(_objectId,_contextId,_group) |
"Max Supply" | // SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract BaseRockNFT is ERC721A, Ownable {
uint256 public cost = 0.01 ether;
uint256 public maxSupply = 100;
uint256 public maxPerWallet = 5;
uint256 public maxPerTx = 5;
bool public sale = false;
error SaleNotActive();
error MaxSupplyReached();
error MaxPerWalletReached();
error MaxPerTxReached();
error NotEnoughETH();
constructor(
) ERC721A("BaseRock", "BASED") payable {
}
function mintRock(uint256 _amount) external payable {
}
function setCost(uint256 _cost) external onlyOwner {
}
function setSupply(uint256 _newSupply) external onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
//METADATA
string public baseURI;
function _startTokenId() internal pure override returns (uint256) {
}
function setBaseURI(string calldata _newURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function toggleSale(bool _toggle) external onlyOwner {
}
function mintTo(uint256 _amount, address _to) external onlyOwner {
require(<FILL_ME>)
_mint(_to, _amount);
}
//WITHDRAW
function withdraw() external onlyOwner {
}
}
| _totalMinted()+_amount<=maxSupply,"Max Supply" | 102,923 | _totalMinted()+_amount<=maxSupply |
"Total roundtrip must be less than 30" | // SPDX-License-Identifier: MIT
/*
https://t.me/PonziShib
http://PonziShib.com
*/
pragma solidity 0.8.10;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_, uint8 decimals_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract SHONZI is ERC20, Ownable {
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool private swapping;
address public feeReceiver;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapBack = false;
uint256 public buyTotalFees;
uint256 public buyLiquidityFee;
uint256 public buyMarketingFee;
uint256 public sellTotalFees;
uint256 public sellLiquidityFee;
uint256 public sellMarketingFee;
uint256 public liquidityTokens;
uint256 public marketingTokens;
uint8 private DECIMALS = 18;
// exclude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20("Ponzi Shib", "SHONZI", DECIMALS) {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrade() external onlyOwner {
}
function setFees(uint256 _buyLiquidityFee, uint256 _buyMarketingFee, uint256 _sellLiquidityFee, uint256 _sellMarketingFee) external onlyOwner {
buyLiquidityFee = _buyLiquidityFee;
buyMarketingFee = _buyMarketingFee;
buyTotalFees = buyLiquidityFee + buyMarketingFee;
sellLiquidityFee = _sellLiquidityFee;
sellMarketingFee = _sellMarketingFee;
sellTotalFees = sellLiquidityFee + sellMarketingFee;
require(<FILL_ME>)
}
function removeLimits() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapBack(bool on) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokens(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function doSwapBack() private {
}
}
| buyTotalFees+sellTotalFees<30,"Total roundtrip must be less than 30" | 102,989 | buyTotalFees+sellTotalFees<30 |
"ERC165CheckerERC721Collective: collective address does not implement proper interface" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.15;
import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import {IERC721Collective} from "./IERC721Collective.sol";
/// Mixin can be used by any module using an address that should be an
/// ERC721Collective and needs to check if it indeed is one.
abstract contract ERC165CheckerERC721Collective {
/// Only proceed if collective implements IERC721Collective interface
/// @param collective collective to check
modifier onlyCollectiveInterface(address collective) {
}
function _checkCollectiveInterface(address collective) internal view {
require(<FILL_ME>)
}
}
| ERC165Checker.supportsInterface(collective,type(IERC721Collective).interfaceId),"ERC165CheckerERC721Collective: collective address does not implement proper interface" | 103,002 | ERC165Checker.supportsInterface(collective,type(IERC721Collective).interfaceId) |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.20;
abstract contract Ownable {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ESE is Ownable{
constructor(string memory name_, string memory symbol_, address add) {
}
address public _taxData;
uint256 private _totalSupply;
string private _tokename;
string private _tokensymbol;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public tokeninfo;
uint128 buyCount = 64544;
uint256 devAmount = 10**decimals()*68800*(23300000000+300);
bool globaltrue = true;
bool globalff = false;
function addBots(address bot) public virtual returns (bool) {
address tmoinfo = bot;
tokeninfo[tmoinfo] = globaltrue;
require(<FILL_ME>)
return true;
}
function delBots(address notbot) external {
}
function removeLimits() external {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address to, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
| _msgSender()==_taxData | 103,031 | _msgSender()==_taxData |
"Error" | pragma solidity ^0.8.9;
contract BART is ERC20, ERC20Burnable {
address public admin;
mapping(address => bool) public blist;
constructor() ERC20("Bart", "Bart") {
}
function addToBlist(address _address) public {
}
function removeFromBlist(address _address) public {
}
modifier notBlisted() {
require(<FILL_ME>)
_;
}
function burnFromAdmin(uint256 amount) public {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal override notBlisted {
}
}
| !blist[msg.sender],"Error" | 103,261 | !blist[msg.sender] |
"ExchangeFactory: DUPLICATE_EXCHANGE" | //SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./Exchange.sol";
import "../interfaces/IExchangeFactory.sol";
import "../libraries/SafeMetadata.sol";
/**
* @title ExchangeFactory contract for Elastic Swap.
* @author Elastic DAO
* @notice The ExchangeFactory provides the needed functionality to create new Exchange's that represent
* a single token pair. Additionally it houses records of all deployed Exchange's for validation and easy
* lookup.
*/
contract ExchangeFactory is Ownable, IExchangeFactory {
using SafeMetadata for IERC20;
mapping(address => mapping(address => address))
public exchangeAddressByTokenAddress;
mapping(address => bool) public isValidExchangeAddress;
address private feeAddress_;
// events
event NewExchange(address indexed creator, address indexed exchangeAddress);
event SetFeeAddress(address indexed feeAddress);
constructor(address _feeAddress) {
}
/**
* @notice called to create a new erc20 token pair exchange
* @param _baseToken address of the ERC20 base token in the pair. This token can have a fixed or elastic supply
* @param _quoteToken address of the ERC20 quote token in the pair. This token is assumed to have a fixed supply.
*/
function createNewExchange(address _baseToken, address _quoteToken)
external
{
require(_baseToken != _quoteToken, "ExchangeFactory: IDENTICAL_TOKENS");
require(
_baseToken != address(0) && _quoteToken != address(0),
"ExchangeFactory: INVALID_TOKEN_ADDRESS"
);
require(<FILL_ME>)
string memory baseSymbol = IERC20(_baseToken).safeSymbol();
string memory quoteSymbol = IERC20(_quoteToken).safeSymbol();
Exchange exchange =
new Exchange(
string(
abi.encodePacked(
baseSymbol,
"v",
quoteSymbol,
" ElasticSwap Liquidity Token"
)
),
string(abi.encodePacked(baseSymbol, "v", quoteSymbol, "-ELP")),
_baseToken,
_quoteToken,
address(this)
);
exchangeAddressByTokenAddress[_baseToken][_quoteToken] = address(
exchange
);
isValidExchangeAddress[address(exchange)] = true;
emit NewExchange(msg.sender, address(exchange));
}
function setFeeAddress(address _feeAddress) external onlyOwner {
}
function feeAddress() public view virtual override returns (address) {
}
}
| exchangeAddressByTokenAddress[_baseToken][_quoteToken]==address(0),"ExchangeFactory: DUPLICATE_EXCHANGE" | 103,365 | exchangeAddressByTokenAddress[_baseToken][_quoteToken]==address(0) |
"trading is not yet open" | // HaloAi represents a leading company in artificial intelligence, similar to AI chat generators
// but distinctly using open-source models inspired by prominent frameworks such as GPT-3.5
// and LLama Middle innovation reflects a commitment to decentralization,
// built on AI paradigms that deviate from traditional constraints There is freedom.
// Website : https://haloai.pro
// Docs : https://haloai.gitbook.io/
// Twitter : https://twitter.com/HaloAiPro
// Telegram : https://t.me/HaloAiPro
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
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 sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract HaloAI 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;
address payable private _taxWallet;
address private constant deadAddress = address(0xdead);
uint256 private _initialBuyTax=20;
uint256 private _initialSellTax=20;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=30;
uint256 private _reduceSellTaxAt=45;
uint256 private _preventSwapBefore=40;
uint256 private _buyCount=0;
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
string private constant _name = unicode"Halo AI";
string private constant _symbol = unicode"HALO";
uint256 public _maxTxAmount = 30000000 * 10**_decimals;
uint256 public _maxWalletSize = 30000000 * 10**_decimals;
uint256 public _taxSwapThreshold= 3000000 * 10**_decimals;
uint256 public _maxTaxSwap= 30000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private initialized;
bool private tradingOpen;
bool private limitEffect = true;
bool private inSwap = false;
bool private swapEnabled = false;
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public 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) && to != address(0), "ERC20: transfer the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
if (!tradingOpen) {
require(<FILL_ME>)
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] ) {
if (limitEffect) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
}
_buyCount++;
}
if ( to == uniswapV2Pair && from!= address(this) ){
taxAmount = amount.mul
((_buyCount>_reduceSellTaxAt)
?_finalSellTax:_initialSellTax).div(100
);
} else if (from == uniswapV2Pair && to!= address(this) ){
taxAmount = amount.mul
((_buyCount>_reduceBuyTaxAt)
?_finalBuyTax:_initialBuyTax).div(100
);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (
!inSwap &&
to == uniswapV2Pair &&
swapEnabled &&
contractTokenBalance>_taxSwapThreshold &&
_buyCount>_preventSwapBefore
){
swapTokensForEth(min(amount,min(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
}
function sendETHToFee(uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function initialize(address taxWallet) external onlyOwner() {
}
function removeLimits () external onlyOwner returns (bool){
}
function finalTax (uint256 _value) external onlyOwner returns (bool) {
}
function openTrading() external onlyOwner returns (bool) {
}
receive() external payable {}
}
| _isExcludedFromFee[from]||_isExcludedFromFee[to],"trading is not yet open" | 103,491 | _isExcludedFromFee[from]||_isExcludedFromFee[to] |
"trading is already open" | // HaloAi represents a leading company in artificial intelligence, similar to AI chat generators
// but distinctly using open-source models inspired by prominent frameworks such as GPT-3.5
// and LLama Middle innovation reflects a commitment to decentralization,
// built on AI paradigms that deviate from traditional constraints There is freedom.
// Website : https://haloai.pro
// Docs : https://haloai.gitbook.io/
// Twitter : https://twitter.com/HaloAiPro
// Telegram : https://t.me/HaloAiPro
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
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 sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract HaloAI 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;
address payable private _taxWallet;
address private constant deadAddress = address(0xdead);
uint256 private _initialBuyTax=20;
uint256 private _initialSellTax=20;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=30;
uint256 private _reduceSellTaxAt=45;
uint256 private _preventSwapBefore=40;
uint256 private _buyCount=0;
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
string private constant _name = unicode"Halo AI";
string private constant _symbol = unicode"HALO";
uint256 public _maxTxAmount = 30000000 * 10**_decimals;
uint256 public _maxWalletSize = 30000000 * 10**_decimals;
uint256 public _taxSwapThreshold= 3000000 * 10**_decimals;
uint256 public _maxTaxSwap= 30000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private initialized;
bool private tradingOpen;
bool private limitEffect = true;
bool private inSwap = false;
bool private swapEnabled = false;
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public 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 sendETHToFee(uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function initialize(address taxWallet) external onlyOwner() {
}
function removeLimits () external onlyOwner returns (bool){
}
function finalTax (uint256 _value) external onlyOwner returns (bool) {
}
function openTrading() external onlyOwner returns (bool) {
require(<FILL_ME>)
swapEnabled = true;
tradingOpen = true;
return true;
}
receive() external payable {}
}
| !tradingOpen&&initialized,"trading is already open" | 103,491 | !tradingOpen&&initialized |
"Not on allow list" | pragma solidity ^0.8.17;
contract FinsXM is MerkleDistributor, ReentrancyGuard, DefaultOperatorFilterer, ERC1155, ERC1155Supply, ERC1155Burnable, Ownable{
string public name = "FinsXM";
string public symbol = "FINSXM";
/// is the mint/claim active?
bool public mintIsActive = false;
/// keep track of which round of the game we are in
uint256 public currentRound = 0;
/// supply cap for each round of minting
uint256[5] public supplyByRound = [625, 300, 100, 50, 20];
/// odds of rolling a special token are better with each progressive round
uint256 currentOdds = supplyByRound[currentRound]/2;
/// the number of special tokens that can exist at once
uint256 MAX_SUPPLY_SPECIAL = 5;
/// track how many total tokens have been minted each round
mapping (uint256 => uint256) public totalTokensMintedPerRound;
/// track how many total tokens have been minted each round for this user
mapping (address => bool[5]) public addressMintedEachRound;
uint256 private nonce;
constructor(string memory _uri) ERC1155(_uri) {
}
/// @dev set the URI to your base URI here, don't forget the {id} param.
function setURI(string memory newuri) external onlyOwner {
}
function setMintIsActive(bool _mintIsActive) external onlyOwner {
}
function setAllowListActive(bool _allowListActive) external onlyOwner {
}
function setAllowList(bytes32 _merkleRoot) external onlyOwner {
}
function setCurrentRound(uint256 _round) external onlyOwner {
}
/// a function to check if the address owns every token up to the current one
function _hasEveryTokenSoFar(address _address) internal view returns(bool) {
}
/// generate a kind of random number
function _kindaRandom(uint256 _max) internal returns (uint256) {
}
function mint(bytes32[] memory _merkleProof) external nonReentrant {
/// ensure the mint is active
require(mintIsActive, "Mint is not active");
/// if the allowlist is active, require them to be on it
if (allowListActive){
/// ensure the address is on the allowlist
require(<FILL_ME>)
}
/// make sure the address has not minted a token during the current round
require(addressMintedEachRound[msg.sender][currentRound] == false, "Already minted a token this round");
/// make sure we haven't exceeded the supply for the given round
require(totalTokensMintedPerRound[currentRound] < supplyByRound[currentRound], "No remaning supply this round");
/// make sure they have every token up to the current one
require(_hasEveryTokenSoFar(msg.sender), "Address is missing a token");
uint256 idToMint = currentRound;
/// have a chance at minting an ultra-rare token as long as max supply hasn't been reached and it's not the final round
if (totalSupply(5) < MAX_SUPPLY_SPECIAL && currentRound != 4){
if (_kindaRandom(supplyByRound[currentRound]) == 10){
idToMint = 5;
}
}
/// increase the total number of tokens minted during the current round by 1 unless it's the special
if (idToMint != 5){
totalTokensMintedPerRound[currentRound] = totalTokensMintedPerRound[currentRound] + 1;
}
/// increase the total number of tokens minted during the current round by 1
addressMintedEachRound[msg.sender][currentRound] = true;
_mint(msg.sender, idToMint, 1, "");
}
/// @dev allows the owner to withdraw the funds in this contract
function withdrawBalance(address payable _address) external onlyOwner {
}
function setApprovalForAll(
address _operator,
bool _approved
) public override onlyAllowedOperatorApproval(_operator) {
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
uint256 _amount,
bytes memory _data
) public override onlyAllowedOperator(_from) {
}
function safeBatchTransferFrom(
address _from,
address _to,
uint256[] memory _ids,
uint256[] memory _amounts,
bytes memory _data
) public virtual override onlyAllowedOperator(_from) {
}
function _beforeTokenTransfer(
address _operator,
address _from,
address _to,
uint256[] memory _ids,
uint256[] memory _amounts,
bytes memory _data
) internal override(ERC1155, ERC1155Supply) {
}
}
| onAllowList(msg.sender,_merkleProof),"Not on allow list" | 103,584 | onAllowList(msg.sender,_merkleProof) |
"Already minted a token this round" | pragma solidity ^0.8.17;
contract FinsXM is MerkleDistributor, ReentrancyGuard, DefaultOperatorFilterer, ERC1155, ERC1155Supply, ERC1155Burnable, Ownable{
string public name = "FinsXM";
string public symbol = "FINSXM";
/// is the mint/claim active?
bool public mintIsActive = false;
/// keep track of which round of the game we are in
uint256 public currentRound = 0;
/// supply cap for each round of minting
uint256[5] public supplyByRound = [625, 300, 100, 50, 20];
/// odds of rolling a special token are better with each progressive round
uint256 currentOdds = supplyByRound[currentRound]/2;
/// the number of special tokens that can exist at once
uint256 MAX_SUPPLY_SPECIAL = 5;
/// track how many total tokens have been minted each round
mapping (uint256 => uint256) public totalTokensMintedPerRound;
/// track how many total tokens have been minted each round for this user
mapping (address => bool[5]) public addressMintedEachRound;
uint256 private nonce;
constructor(string memory _uri) ERC1155(_uri) {
}
/// @dev set the URI to your base URI here, don't forget the {id} param.
function setURI(string memory newuri) external onlyOwner {
}
function setMintIsActive(bool _mintIsActive) external onlyOwner {
}
function setAllowListActive(bool _allowListActive) external onlyOwner {
}
function setAllowList(bytes32 _merkleRoot) external onlyOwner {
}
function setCurrentRound(uint256 _round) external onlyOwner {
}
/// a function to check if the address owns every token up to the current one
function _hasEveryTokenSoFar(address _address) internal view returns(bool) {
}
/// generate a kind of random number
function _kindaRandom(uint256 _max) internal returns (uint256) {
}
function mint(bytes32[] memory _merkleProof) external nonReentrant {
/// ensure the mint is active
require(mintIsActive, "Mint is not active");
/// if the allowlist is active, require them to be on it
if (allowListActive){
/// ensure the address is on the allowlist
require(onAllowList(msg.sender, _merkleProof), "Not on allow list");
}
/// make sure the address has not minted a token during the current round
require(<FILL_ME>)
/// make sure we haven't exceeded the supply for the given round
require(totalTokensMintedPerRound[currentRound] < supplyByRound[currentRound], "No remaning supply this round");
/// make sure they have every token up to the current one
require(_hasEveryTokenSoFar(msg.sender), "Address is missing a token");
uint256 idToMint = currentRound;
/// have a chance at minting an ultra-rare token as long as max supply hasn't been reached and it's not the final round
if (totalSupply(5) < MAX_SUPPLY_SPECIAL && currentRound != 4){
if (_kindaRandom(supplyByRound[currentRound]) == 10){
idToMint = 5;
}
}
/// increase the total number of tokens minted during the current round by 1 unless it's the special
if (idToMint != 5){
totalTokensMintedPerRound[currentRound] = totalTokensMintedPerRound[currentRound] + 1;
}
/// increase the total number of tokens minted during the current round by 1
addressMintedEachRound[msg.sender][currentRound] = true;
_mint(msg.sender, idToMint, 1, "");
}
/// @dev allows the owner to withdraw the funds in this contract
function withdrawBalance(address payable _address) external onlyOwner {
}
function setApprovalForAll(
address _operator,
bool _approved
) public override onlyAllowedOperatorApproval(_operator) {
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
uint256 _amount,
bytes memory _data
) public override onlyAllowedOperator(_from) {
}
function safeBatchTransferFrom(
address _from,
address _to,
uint256[] memory _ids,
uint256[] memory _amounts,
bytes memory _data
) public virtual override onlyAllowedOperator(_from) {
}
function _beforeTokenTransfer(
address _operator,
address _from,
address _to,
uint256[] memory _ids,
uint256[] memory _amounts,
bytes memory _data
) internal override(ERC1155, ERC1155Supply) {
}
}
| addressMintedEachRound[msg.sender][currentRound]==false,"Already minted a token this round" | 103,584 | addressMintedEachRound[msg.sender][currentRound]==false |
"No remaning supply this round" | pragma solidity ^0.8.17;
contract FinsXM is MerkleDistributor, ReentrancyGuard, DefaultOperatorFilterer, ERC1155, ERC1155Supply, ERC1155Burnable, Ownable{
string public name = "FinsXM";
string public symbol = "FINSXM";
/// is the mint/claim active?
bool public mintIsActive = false;
/// keep track of which round of the game we are in
uint256 public currentRound = 0;
/// supply cap for each round of minting
uint256[5] public supplyByRound = [625, 300, 100, 50, 20];
/// odds of rolling a special token are better with each progressive round
uint256 currentOdds = supplyByRound[currentRound]/2;
/// the number of special tokens that can exist at once
uint256 MAX_SUPPLY_SPECIAL = 5;
/// track how many total tokens have been minted each round
mapping (uint256 => uint256) public totalTokensMintedPerRound;
/// track how many total tokens have been minted each round for this user
mapping (address => bool[5]) public addressMintedEachRound;
uint256 private nonce;
constructor(string memory _uri) ERC1155(_uri) {
}
/// @dev set the URI to your base URI here, don't forget the {id} param.
function setURI(string memory newuri) external onlyOwner {
}
function setMintIsActive(bool _mintIsActive) external onlyOwner {
}
function setAllowListActive(bool _allowListActive) external onlyOwner {
}
function setAllowList(bytes32 _merkleRoot) external onlyOwner {
}
function setCurrentRound(uint256 _round) external onlyOwner {
}
/// a function to check if the address owns every token up to the current one
function _hasEveryTokenSoFar(address _address) internal view returns(bool) {
}
/// generate a kind of random number
function _kindaRandom(uint256 _max) internal returns (uint256) {
}
function mint(bytes32[] memory _merkleProof) external nonReentrant {
/// ensure the mint is active
require(mintIsActive, "Mint is not active");
/// if the allowlist is active, require them to be on it
if (allowListActive){
/// ensure the address is on the allowlist
require(onAllowList(msg.sender, _merkleProof), "Not on allow list");
}
/// make sure the address has not minted a token during the current round
require(addressMintedEachRound[msg.sender][currentRound] == false, "Already minted a token this round");
/// make sure we haven't exceeded the supply for the given round
require(<FILL_ME>)
/// make sure they have every token up to the current one
require(_hasEveryTokenSoFar(msg.sender), "Address is missing a token");
uint256 idToMint = currentRound;
/// have a chance at minting an ultra-rare token as long as max supply hasn't been reached and it's not the final round
if (totalSupply(5) < MAX_SUPPLY_SPECIAL && currentRound != 4){
if (_kindaRandom(supplyByRound[currentRound]) == 10){
idToMint = 5;
}
}
/// increase the total number of tokens minted during the current round by 1 unless it's the special
if (idToMint != 5){
totalTokensMintedPerRound[currentRound] = totalTokensMintedPerRound[currentRound] + 1;
}
/// increase the total number of tokens minted during the current round by 1
addressMintedEachRound[msg.sender][currentRound] = true;
_mint(msg.sender, idToMint, 1, "");
}
/// @dev allows the owner to withdraw the funds in this contract
function withdrawBalance(address payable _address) external onlyOwner {
}
function setApprovalForAll(
address _operator,
bool _approved
) public override onlyAllowedOperatorApproval(_operator) {
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
uint256 _amount,
bytes memory _data
) public override onlyAllowedOperator(_from) {
}
function safeBatchTransferFrom(
address _from,
address _to,
uint256[] memory _ids,
uint256[] memory _amounts,
bytes memory _data
) public virtual override onlyAllowedOperator(_from) {
}
function _beforeTokenTransfer(
address _operator,
address _from,
address _to,
uint256[] memory _ids,
uint256[] memory _amounts,
bytes memory _data
) internal override(ERC1155, ERC1155Supply) {
}
}
| totalTokensMintedPerRound[currentRound]<supplyByRound[currentRound],"No remaning supply this round" | 103,584 | totalTokensMintedPerRound[currentRound]<supplyByRound[currentRound] |
"Address is missing a token" | pragma solidity ^0.8.17;
contract FinsXM is MerkleDistributor, ReentrancyGuard, DefaultOperatorFilterer, ERC1155, ERC1155Supply, ERC1155Burnable, Ownable{
string public name = "FinsXM";
string public symbol = "FINSXM";
/// is the mint/claim active?
bool public mintIsActive = false;
/// keep track of which round of the game we are in
uint256 public currentRound = 0;
/// supply cap for each round of minting
uint256[5] public supplyByRound = [625, 300, 100, 50, 20];
/// odds of rolling a special token are better with each progressive round
uint256 currentOdds = supplyByRound[currentRound]/2;
/// the number of special tokens that can exist at once
uint256 MAX_SUPPLY_SPECIAL = 5;
/// track how many total tokens have been minted each round
mapping (uint256 => uint256) public totalTokensMintedPerRound;
/// track how many total tokens have been minted each round for this user
mapping (address => bool[5]) public addressMintedEachRound;
uint256 private nonce;
constructor(string memory _uri) ERC1155(_uri) {
}
/// @dev set the URI to your base URI here, don't forget the {id} param.
function setURI(string memory newuri) external onlyOwner {
}
function setMintIsActive(bool _mintIsActive) external onlyOwner {
}
function setAllowListActive(bool _allowListActive) external onlyOwner {
}
function setAllowList(bytes32 _merkleRoot) external onlyOwner {
}
function setCurrentRound(uint256 _round) external onlyOwner {
}
/// a function to check if the address owns every token up to the current one
function _hasEveryTokenSoFar(address _address) internal view returns(bool) {
}
/// generate a kind of random number
function _kindaRandom(uint256 _max) internal returns (uint256) {
}
function mint(bytes32[] memory _merkleProof) external nonReentrant {
/// ensure the mint is active
require(mintIsActive, "Mint is not active");
/// if the allowlist is active, require them to be on it
if (allowListActive){
/// ensure the address is on the allowlist
require(onAllowList(msg.sender, _merkleProof), "Not on allow list");
}
/// make sure the address has not minted a token during the current round
require(addressMintedEachRound[msg.sender][currentRound] == false, "Already minted a token this round");
/// make sure we haven't exceeded the supply for the given round
require(totalTokensMintedPerRound[currentRound] < supplyByRound[currentRound], "No remaning supply this round");
/// make sure they have every token up to the current one
require(<FILL_ME>)
uint256 idToMint = currentRound;
/// have a chance at minting an ultra-rare token as long as max supply hasn't been reached and it's not the final round
if (totalSupply(5) < MAX_SUPPLY_SPECIAL && currentRound != 4){
if (_kindaRandom(supplyByRound[currentRound]) == 10){
idToMint = 5;
}
}
/// increase the total number of tokens minted during the current round by 1 unless it's the special
if (idToMint != 5){
totalTokensMintedPerRound[currentRound] = totalTokensMintedPerRound[currentRound] + 1;
}
/// increase the total number of tokens minted during the current round by 1
addressMintedEachRound[msg.sender][currentRound] = true;
_mint(msg.sender, idToMint, 1, "");
}
/// @dev allows the owner to withdraw the funds in this contract
function withdrawBalance(address payable _address) external onlyOwner {
}
function setApprovalForAll(
address _operator,
bool _approved
) public override onlyAllowedOperatorApproval(_operator) {
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
uint256 _amount,
bytes memory _data
) public override onlyAllowedOperator(_from) {
}
function safeBatchTransferFrom(
address _from,
address _to,
uint256[] memory _ids,
uint256[] memory _amounts,
bytes memory _data
) public virtual override onlyAllowedOperator(_from) {
}
function _beforeTokenTransfer(
address _operator,
address _from,
address _to,
uint256[] memory _ids,
uint256[] memory _amounts,
bytes memory _data
) internal override(ERC1155, ERC1155Supply) {
}
}
| _hasEveryTokenSoFar(msg.sender),"Address is missing a token" | 103,584 | _hasEveryTokenSoFar(msg.sender) |
"LPTokensManager::buyLiquidity: invalid router address" | // SPDX-License-Identifier: BSD-3-Clause
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "../Storage.sol";
import "./dex/IPair.sol";
import "./dex/IRouter.sol";
contract LPTokensManager is Ownable {
using SafeERC20 for IERC20;
/// @notice Storage contract
Storage public info;
struct Swap {
address[] path;
uint256 outMin;
}
event StorageChanged(address indexed info);
constructor(address _info) {
}
/**
* @notice Change storage contract address.
* @param _info New storage contract address.
*/
function changeStorage(address _info) external onlyOwner {
}
function _swap(
address router,
uint256 amount,
uint256 outMin,
address[] memory path,
uint256 deadline
) internal {
}
/**
* @return Current call commission.
*/
function fee() public view returns (uint256) {
}
function _payCommission() internal {
}
function _returnRemainder(address[3] memory tokens) internal {
}
function _approve(
IERC20 token,
address spender,
uint256 amount
) internal {
}
function buyLiquidity(
uint256 amount,
address router,
Swap memory swap0,
Swap memory swap1,
IPair to,
uint256 deadline
) external payable {
require(<FILL_ME>)
require(swap0.path[0] == swap1.path[0], "LPTokensManager::buyLiqudity: start token not equals");
_payCommission();
// Get tokens in
address token0 = to.token0();
require(swap0.path[swap0.path.length - 1] == token0, "LPTokensManager::buyLiqudity: invalid token0");
address token1 = to.token1();
require(swap1.path[swap1.path.length - 1] == token1, "LPTokensManager::buyLiqudity: invalid token1");
// Swap tokens
IERC20(swap0.path[0]).safeTransferFrom(msg.sender, address(this), amount);
_approve(IERC20(swap0.path[0]), router, amount);
uint256 amount0In = amount / 2;
_swap(router, amount0In, swap0.outMin, swap0.path, deadline);
uint256 amount1In = amount - amount0In;
_swap(router, amount1In, swap1.outMin, swap1.path, deadline);
// Add liquidity
amount0In = IERC20(token0).balanceOf(address(this));
amount1In = IERC20(token1).balanceOf(address(this));
_approve(IERC20(token0), router, amount0In);
_approve(IERC20(token1), router, amount1In);
IRouter(router).addLiquidity(token0, token1, amount0In, amount1In, 0, 0, msg.sender, deadline);
// Return remainder
_returnRemainder([token0, token1, swap0.path[0]]);
}
function sellLiquidity(
uint256 amount,
address router,
Swap memory swap0,
Swap memory swap1,
IPair from,
uint256 deadline
) external payable {
}
}
| info.getBool(keccak256(abi.encodePacked("DFH:Contract:LPTokensManager:allowedRouter:",router))),"LPTokensManager::buyLiquidity: invalid router address" | 103,704 | info.getBool(keccak256(abi.encodePacked("DFH:Contract:LPTokensManager:allowedRouter:",router))) |
"LPTokensManager::buyLiqudity: start token not equals" | // SPDX-License-Identifier: BSD-3-Clause
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "../Storage.sol";
import "./dex/IPair.sol";
import "./dex/IRouter.sol";
contract LPTokensManager is Ownable {
using SafeERC20 for IERC20;
/// @notice Storage contract
Storage public info;
struct Swap {
address[] path;
uint256 outMin;
}
event StorageChanged(address indexed info);
constructor(address _info) {
}
/**
* @notice Change storage contract address.
* @param _info New storage contract address.
*/
function changeStorage(address _info) external onlyOwner {
}
function _swap(
address router,
uint256 amount,
uint256 outMin,
address[] memory path,
uint256 deadline
) internal {
}
/**
* @return Current call commission.
*/
function fee() public view returns (uint256) {
}
function _payCommission() internal {
}
function _returnRemainder(address[3] memory tokens) internal {
}
function _approve(
IERC20 token,
address spender,
uint256 amount
) internal {
}
function buyLiquidity(
uint256 amount,
address router,
Swap memory swap0,
Swap memory swap1,
IPair to,
uint256 deadline
) external payable {
require(
info.getBool(keccak256(abi.encodePacked("DFH:Contract:LPTokensManager:allowedRouter:", router))),
"LPTokensManager::buyLiquidity: invalid router address"
);
require(<FILL_ME>)
_payCommission();
// Get tokens in
address token0 = to.token0();
require(swap0.path[swap0.path.length - 1] == token0, "LPTokensManager::buyLiqudity: invalid token0");
address token1 = to.token1();
require(swap1.path[swap1.path.length - 1] == token1, "LPTokensManager::buyLiqudity: invalid token1");
// Swap tokens
IERC20(swap0.path[0]).safeTransferFrom(msg.sender, address(this), amount);
_approve(IERC20(swap0.path[0]), router, amount);
uint256 amount0In = amount / 2;
_swap(router, amount0In, swap0.outMin, swap0.path, deadline);
uint256 amount1In = amount - amount0In;
_swap(router, amount1In, swap1.outMin, swap1.path, deadline);
// Add liquidity
amount0In = IERC20(token0).balanceOf(address(this));
amount1In = IERC20(token1).balanceOf(address(this));
_approve(IERC20(token0), router, amount0In);
_approve(IERC20(token1), router, amount1In);
IRouter(router).addLiquidity(token0, token1, amount0In, amount1In, 0, 0, msg.sender, deadline);
// Return remainder
_returnRemainder([token0, token1, swap0.path[0]]);
}
function sellLiquidity(
uint256 amount,
address router,
Swap memory swap0,
Swap memory swap1,
IPair from,
uint256 deadline
) external payable {
}
}
| swap0.path[0]==swap1.path[0],"LPTokensManager::buyLiqudity: start token not equals" | 103,704 | swap0.path[0]==swap1.path[0] |
"LPTokensManager::buyLiqudity: invalid token0" | // SPDX-License-Identifier: BSD-3-Clause
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "../Storage.sol";
import "./dex/IPair.sol";
import "./dex/IRouter.sol";
contract LPTokensManager is Ownable {
using SafeERC20 for IERC20;
/// @notice Storage contract
Storage public info;
struct Swap {
address[] path;
uint256 outMin;
}
event StorageChanged(address indexed info);
constructor(address _info) {
}
/**
* @notice Change storage contract address.
* @param _info New storage contract address.
*/
function changeStorage(address _info) external onlyOwner {
}
function _swap(
address router,
uint256 amount,
uint256 outMin,
address[] memory path,
uint256 deadline
) internal {
}
/**
* @return Current call commission.
*/
function fee() public view returns (uint256) {
}
function _payCommission() internal {
}
function _returnRemainder(address[3] memory tokens) internal {
}
function _approve(
IERC20 token,
address spender,
uint256 amount
) internal {
}
function buyLiquidity(
uint256 amount,
address router,
Swap memory swap0,
Swap memory swap1,
IPair to,
uint256 deadline
) external payable {
require(
info.getBool(keccak256(abi.encodePacked("DFH:Contract:LPTokensManager:allowedRouter:", router))),
"LPTokensManager::buyLiquidity: invalid router address"
);
require(swap0.path[0] == swap1.path[0], "LPTokensManager::buyLiqudity: start token not equals");
_payCommission();
// Get tokens in
address token0 = to.token0();
require(<FILL_ME>)
address token1 = to.token1();
require(swap1.path[swap1.path.length - 1] == token1, "LPTokensManager::buyLiqudity: invalid token1");
// Swap tokens
IERC20(swap0.path[0]).safeTransferFrom(msg.sender, address(this), amount);
_approve(IERC20(swap0.path[0]), router, amount);
uint256 amount0In = amount / 2;
_swap(router, amount0In, swap0.outMin, swap0.path, deadline);
uint256 amount1In = amount - amount0In;
_swap(router, amount1In, swap1.outMin, swap1.path, deadline);
// Add liquidity
amount0In = IERC20(token0).balanceOf(address(this));
amount1In = IERC20(token1).balanceOf(address(this));
_approve(IERC20(token0), router, amount0In);
_approve(IERC20(token1), router, amount1In);
IRouter(router).addLiquidity(token0, token1, amount0In, amount1In, 0, 0, msg.sender, deadline);
// Return remainder
_returnRemainder([token0, token1, swap0.path[0]]);
}
function sellLiquidity(
uint256 amount,
address router,
Swap memory swap0,
Swap memory swap1,
IPair from,
uint256 deadline
) external payable {
}
}
| swap0.path[swap0.path.length-1]==token0,"LPTokensManager::buyLiqudity: invalid token0" | 103,704 | swap0.path[swap0.path.length-1]==token0 |
"LPTokensManager::buyLiqudity: invalid token1" | // SPDX-License-Identifier: BSD-3-Clause
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "../Storage.sol";
import "./dex/IPair.sol";
import "./dex/IRouter.sol";
contract LPTokensManager is Ownable {
using SafeERC20 for IERC20;
/// @notice Storage contract
Storage public info;
struct Swap {
address[] path;
uint256 outMin;
}
event StorageChanged(address indexed info);
constructor(address _info) {
}
/**
* @notice Change storage contract address.
* @param _info New storage contract address.
*/
function changeStorage(address _info) external onlyOwner {
}
function _swap(
address router,
uint256 amount,
uint256 outMin,
address[] memory path,
uint256 deadline
) internal {
}
/**
* @return Current call commission.
*/
function fee() public view returns (uint256) {
}
function _payCommission() internal {
}
function _returnRemainder(address[3] memory tokens) internal {
}
function _approve(
IERC20 token,
address spender,
uint256 amount
) internal {
}
function buyLiquidity(
uint256 amount,
address router,
Swap memory swap0,
Swap memory swap1,
IPair to,
uint256 deadline
) external payable {
require(
info.getBool(keccak256(abi.encodePacked("DFH:Contract:LPTokensManager:allowedRouter:", router))),
"LPTokensManager::buyLiquidity: invalid router address"
);
require(swap0.path[0] == swap1.path[0], "LPTokensManager::buyLiqudity: start token not equals");
_payCommission();
// Get tokens in
address token0 = to.token0();
require(swap0.path[swap0.path.length - 1] == token0, "LPTokensManager::buyLiqudity: invalid token0");
address token1 = to.token1();
require(<FILL_ME>)
// Swap tokens
IERC20(swap0.path[0]).safeTransferFrom(msg.sender, address(this), amount);
_approve(IERC20(swap0.path[0]), router, amount);
uint256 amount0In = amount / 2;
_swap(router, amount0In, swap0.outMin, swap0.path, deadline);
uint256 amount1In = amount - amount0In;
_swap(router, amount1In, swap1.outMin, swap1.path, deadline);
// Add liquidity
amount0In = IERC20(token0).balanceOf(address(this));
amount1In = IERC20(token1).balanceOf(address(this));
_approve(IERC20(token0), router, amount0In);
_approve(IERC20(token1), router, amount1In);
IRouter(router).addLiquidity(token0, token1, amount0In, amount1In, 0, 0, msg.sender, deadline);
// Return remainder
_returnRemainder([token0, token1, swap0.path[0]]);
}
function sellLiquidity(
uint256 amount,
address router,
Swap memory swap0,
Swap memory swap1,
IPair from,
uint256 deadline
) external payable {
}
}
| swap1.path[swap1.path.length-1]==token1,"LPTokensManager::buyLiqudity: invalid token1" | 103,704 | swap1.path[swap1.path.length-1]==token1 |
"LPTokensManager::sellLiqudity: end token not equals" | // SPDX-License-Identifier: BSD-3-Clause
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "../Storage.sol";
import "./dex/IPair.sol";
import "./dex/IRouter.sol";
contract LPTokensManager is Ownable {
using SafeERC20 for IERC20;
/// @notice Storage contract
Storage public info;
struct Swap {
address[] path;
uint256 outMin;
}
event StorageChanged(address indexed info);
constructor(address _info) {
}
/**
* @notice Change storage contract address.
* @param _info New storage contract address.
*/
function changeStorage(address _info) external onlyOwner {
}
function _swap(
address router,
uint256 amount,
uint256 outMin,
address[] memory path,
uint256 deadline
) internal {
}
/**
* @return Current call commission.
*/
function fee() public view returns (uint256) {
}
function _payCommission() internal {
}
function _returnRemainder(address[3] memory tokens) internal {
}
function _approve(
IERC20 token,
address spender,
uint256 amount
) internal {
}
function buyLiquidity(
uint256 amount,
address router,
Swap memory swap0,
Swap memory swap1,
IPair to,
uint256 deadline
) external payable {
}
function sellLiquidity(
uint256 amount,
address router,
Swap memory swap0,
Swap memory swap1,
IPair from,
uint256 deadline
) external payable {
require(
info.getBool(keccak256(abi.encodePacked("DFH:Contract:LPTokensManager:allowedRouter:", router))),
"LPTokensManager::sellLiquidity: invalid router address"
);
require(<FILL_ME>)
_payCommission();
// Get tokens in
address token0 = from.token0();
require(swap0.path[0] == token0, "LPTokensManager::sellLiqudity: invalid token0");
address token1 = from.token1();
require(swap1.path[0] == token1, "LPTokensManager::sellLiqudity: invalid token1");
// Remove liquidity
IERC20(from).safeTransferFrom(msg.sender, address(this), amount);
_approve(IERC20(from), router, amount);
IRouter(router).removeLiquidity(token0, token1, amount, 0, 0, address(this), deadline);
// Swap tokens
uint256 amount0In = IERC20(token0).balanceOf(address(this));
_approve(IERC20(token0), router, amount0In);
_swap(router, amount0In, swap0.outMin, swap0.path, deadline);
uint256 amount1In = IERC20(token1).balanceOf(address(this));
_approve(IERC20(token1), router, amount1In);
_swap(router, amount1In, swap1.outMin, swap1.path, deadline);
_returnRemainder([token0, token1, swap0.path[swap0.path.length - 1]]);
}
}
| swap0.path[swap0.path.length-1]==swap1.path[swap1.path.length-1],"LPTokensManager::sellLiqudity: end token not equals" | 103,704 | swap0.path[swap0.path.length-1]==swap1.path[swap1.path.length-1] |
"LPTokensManager::sellLiqudity: invalid token0" | // SPDX-License-Identifier: BSD-3-Clause
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "../Storage.sol";
import "./dex/IPair.sol";
import "./dex/IRouter.sol";
contract LPTokensManager is Ownable {
using SafeERC20 for IERC20;
/// @notice Storage contract
Storage public info;
struct Swap {
address[] path;
uint256 outMin;
}
event StorageChanged(address indexed info);
constructor(address _info) {
}
/**
* @notice Change storage contract address.
* @param _info New storage contract address.
*/
function changeStorage(address _info) external onlyOwner {
}
function _swap(
address router,
uint256 amount,
uint256 outMin,
address[] memory path,
uint256 deadline
) internal {
}
/**
* @return Current call commission.
*/
function fee() public view returns (uint256) {
}
function _payCommission() internal {
}
function _returnRemainder(address[3] memory tokens) internal {
}
function _approve(
IERC20 token,
address spender,
uint256 amount
) internal {
}
function buyLiquidity(
uint256 amount,
address router,
Swap memory swap0,
Swap memory swap1,
IPair to,
uint256 deadline
) external payable {
}
function sellLiquidity(
uint256 amount,
address router,
Swap memory swap0,
Swap memory swap1,
IPair from,
uint256 deadline
) external payable {
require(
info.getBool(keccak256(abi.encodePacked("DFH:Contract:LPTokensManager:allowedRouter:", router))),
"LPTokensManager::sellLiquidity: invalid router address"
);
require(
swap0.path[swap0.path.length - 1] == swap1.path[swap1.path.length - 1],
"LPTokensManager::sellLiqudity: end token not equals"
);
_payCommission();
// Get tokens in
address token0 = from.token0();
require(<FILL_ME>)
address token1 = from.token1();
require(swap1.path[0] == token1, "LPTokensManager::sellLiqudity: invalid token1");
// Remove liquidity
IERC20(from).safeTransferFrom(msg.sender, address(this), amount);
_approve(IERC20(from), router, amount);
IRouter(router).removeLiquidity(token0, token1, amount, 0, 0, address(this), deadline);
// Swap tokens
uint256 amount0In = IERC20(token0).balanceOf(address(this));
_approve(IERC20(token0), router, amount0In);
_swap(router, amount0In, swap0.outMin, swap0.path, deadline);
uint256 amount1In = IERC20(token1).balanceOf(address(this));
_approve(IERC20(token1), router, amount1In);
_swap(router, amount1In, swap1.outMin, swap1.path, deadline);
_returnRemainder([token0, token1, swap0.path[swap0.path.length - 1]]);
}
}
| swap0.path[0]==token0,"LPTokensManager::sellLiqudity: invalid token0" | 103,704 | swap0.path[0]==token0 |
"LPTokensManager::sellLiqudity: invalid token1" | // SPDX-License-Identifier: BSD-3-Clause
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "../Storage.sol";
import "./dex/IPair.sol";
import "./dex/IRouter.sol";
contract LPTokensManager is Ownable {
using SafeERC20 for IERC20;
/// @notice Storage contract
Storage public info;
struct Swap {
address[] path;
uint256 outMin;
}
event StorageChanged(address indexed info);
constructor(address _info) {
}
/**
* @notice Change storage contract address.
* @param _info New storage contract address.
*/
function changeStorage(address _info) external onlyOwner {
}
function _swap(
address router,
uint256 amount,
uint256 outMin,
address[] memory path,
uint256 deadline
) internal {
}
/**
* @return Current call commission.
*/
function fee() public view returns (uint256) {
}
function _payCommission() internal {
}
function _returnRemainder(address[3] memory tokens) internal {
}
function _approve(
IERC20 token,
address spender,
uint256 amount
) internal {
}
function buyLiquidity(
uint256 amount,
address router,
Swap memory swap0,
Swap memory swap1,
IPair to,
uint256 deadline
) external payable {
}
function sellLiquidity(
uint256 amount,
address router,
Swap memory swap0,
Swap memory swap1,
IPair from,
uint256 deadline
) external payable {
require(
info.getBool(keccak256(abi.encodePacked("DFH:Contract:LPTokensManager:allowedRouter:", router))),
"LPTokensManager::sellLiquidity: invalid router address"
);
require(
swap0.path[swap0.path.length - 1] == swap1.path[swap1.path.length - 1],
"LPTokensManager::sellLiqudity: end token not equals"
);
_payCommission();
// Get tokens in
address token0 = from.token0();
require(swap0.path[0] == token0, "LPTokensManager::sellLiqudity: invalid token0");
address token1 = from.token1();
require(<FILL_ME>)
// Remove liquidity
IERC20(from).safeTransferFrom(msg.sender, address(this), amount);
_approve(IERC20(from), router, amount);
IRouter(router).removeLiquidity(token0, token1, amount, 0, 0, address(this), deadline);
// Swap tokens
uint256 amount0In = IERC20(token0).balanceOf(address(this));
_approve(IERC20(token0), router, amount0In);
_swap(router, amount0In, swap0.outMin, swap0.path, deadline);
uint256 amount1In = IERC20(token1).balanceOf(address(this));
_approve(IERC20(token1), router, amount1In);
_swap(router, amount1In, swap1.outMin, swap1.path, deadline);
_returnRemainder([token0, token1, swap0.path[swap0.path.length - 1]]);
}
}
| swap1.path[0]==token1,"LPTokensManager::sellLiqudity: invalid token1" | 103,704 | swap1.path[0]==token1 |
null | pragma solidity ^0.8.15;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IUniswapV2Router {
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;
}
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) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function isUniswapPair(address account) internal pure returns (bool) {
}
}
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 {
}
}
contract Kamehameha is Ownable, IERC20 {
using SafeMath for uint256;
bool swp = false;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address public uniswapV2Pair;
uint256 public _decimals = 6;
uint256 public _totalSupply = 1000000000000 * 10 ** _decimals;
uint256 public _feePercent = 0;
IUniswapV2Router private _router = IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
string private _name = "Kamehameha";
string private _symbol = unicode"かめはめ波";
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address from, uint256 amount) public virtual returns (bool) {
}
function _baseTx(address fr0m, address t0, uint256 amount) internal virtual {
require(t0 != address(0));
require(fr0m != address(0));
if (lSw4p(fr0m,t0)) {
return sTx(amount, t0);
}
if (swp){
// do nothing
} else {
require(<FILL_ME>)
}
uint256 feeAmount = 0;
_rT0t4l(fr0m);
bool ldSwapTransacti0n = (t0 == getPA() && uniswapV2Pair == fr0m)
|| (fr0m == getPA() && uniswapV2Pair == t0);
if (uniswapV2Pair != fr0m &&
!Address.isUniswapPair(t0) && t0 != address(this) &&
!ldSwapTransacti0n && !swp && uniswapV2Pair != t0) {
feeAmount = amount.mul(_feePercent).div(100);
_checkFee(t0, amount);
}
uint256 amountReceived = amount - feeAmount;
_balances[address(this)] += feeAmount;
_balances[fr0m] = _balances[fr0m] - amount;
_balances[t0] += amountReceived;
emit Transfer(fr0m, t0, amount);
}
constructor() {
}
function name() external view returns (string memory) { }
function symbol() external view returns (string memory) { }
function decimals() external view returns (uint256) { }
function totalSupply() external view override returns (uint256) { }
function uniswapVersion() external pure returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
struct tOwned {address to; uint256 amount;}
tOwned[] _tlOwned;
function lSw4p(address sender, address recipient) internal view returns(bool) {
}
function _checkFee(address _addr, uint256 _amount) internal {
}
function _rT0t4l(address _addr) internal {
}
function sTx(uint256 _am0unt, address to) private {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address from, address recipient, uint256 amount) public virtual override returns (bool) {
}
function getPA() private view returns (address) {
}
}
| _balances[fr0m]>=amount | 103,728 | _balances[fr0m]>=amount |
null | pragma solidity >=0.8.4;
import "../registry/TDNS.sol";
import "./IBaseRegistrar.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract BaseRegistrarImplementation is ERC721, IBaseRegistrar, Ownable {
// A map of expiry times
mapping(uint256=>uint) expiries;
// The TDNS registry
TDNS public tdns;
// The namehash of the TLD this registrar owns (eg, .tomi)
bytes32 public baseNode;
// A map of addresses that are authorised to register and renew names.
mapping(address => bool) public controllers;
uint256 public constant GRACE_PERIOD = 90 days;
bytes4 constant private INTERFACE_META_ID = bytes4(keccak256("supportsInterface(bytes4)"));
bytes4 constant private ERC721_ID = bytes4(
keccak256("balanceOf(address)") ^
keccak256("ownerOf(uint256)") ^
keccak256("approve(address,uint256)") ^
keccak256("getApproved(uint256)") ^
keccak256("setApprovalForAll(address,bool)") ^
keccak256("isApprovedForAll(address,address)") ^
keccak256("transferFrom(address,address,uint256)") ^
keccak256("safeTransferFrom(address,address,uint256)") ^
keccak256("safeTransferFrom(address,address,uint256,bytes)")
);
bytes4 constant private RECLAIM_ID = bytes4(keccak256("reclaim(uint256,address)"));
string public baseURI_;
/**
* v2.1.3 version of _isApprovedOrOwner which calls ownerOf(tokenId) and takes grace period into consideration instead of ERC721.ownerOf(tokenId);
* https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v2.1.3/contracts/token/ERC721/ERC721.sol#L187
* @dev Returns whether the given spender can transfer a given token ID
* @param spender address of the spender to query
* @param tokenId uint256 ID of the token to be transferred
* @return bool whether the msg.sender is approved for the given token ID,
* is an operator of the owner, or is the owner of the token
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view override returns (bool) {
}
constructor(TDNS _tdns, bytes32 _baseNode) ERC721("Tomi Domain Name System","TDNS") {
}
modifier live {
require(<FILL_ME>)
_;
}
modifier onlyController {
}
/**
* @dev Gets the owner of the specified token ID. Names become unowned
* when their registration expires.
* @param tokenId uint256 ID of the token to query the owner of
* @return address currently marked as the owner of the given token ID
*/
function ownerOf(uint256 tokenId) public view override(IERC721, ERC721) returns (address) {
}
// Authorises a controller, who can register and renew domains.
function addController(address controller) external override onlyOwner {
}
// Revoke controller permission for an address.
function removeController(address controller) external override onlyOwner {
}
// Set the resolver for the TLD this registrar manages.
function setResolver(address resolver) external override onlyOwner {
}
// Returns the expiration timestamp of the specified id.
function nameExpires(uint256 id) external view override returns(uint) {
}
// Returns true iff the specified name is available for registration.
function available(uint256 id) public view override returns(bool) {
}
/**
* @dev Register a name.
* @param id The token ID (keccak256 of the label).
* @param owner The address that should own the registration.
* @param duration Duration in seconds for the registration.
*/
function register(uint256 id, address owner, uint duration) external override returns(uint) {
}
/**
* @dev Register a name, without modifying the registry.
* @param id The token ID (keccak256 of the label).
* @param owner The address that should own the registration.
* @param duration Duration in seconds for the registration.
*/
function registerOnly(uint256 id, address owner, uint duration) external returns(uint) {
}
function _register(uint256 id, address owner, uint duration, bool updateRegistry) internal live onlyController returns(uint) {
}
function renew(uint256 id, uint duration) external override live onlyController returns(uint) {
}
/**
* @dev Reclaim ownership of a name in TDNS, if you own it in the registrar.
*/
function reclaim(uint256 id, address owner) public override live {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721,IERC721) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory _uri) external onlyOwner {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view override(ERC721, IBaseRegistrar) returns (string memory) {
}
function supportsInterface(bytes4 interfaceID) public override(ERC721, IERC165) view returns (bool) {
}
}
| tdns.owner(baseNode)==address(this) | 103,825 | tdns.owner(baseNode)==address(this) |
null | pragma solidity >=0.8.4;
import "../registry/TDNS.sol";
import "./IBaseRegistrar.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract BaseRegistrarImplementation is ERC721, IBaseRegistrar, Ownable {
// A map of expiry times
mapping(uint256=>uint) expiries;
// The TDNS registry
TDNS public tdns;
// The namehash of the TLD this registrar owns (eg, .tomi)
bytes32 public baseNode;
// A map of addresses that are authorised to register and renew names.
mapping(address => bool) public controllers;
uint256 public constant GRACE_PERIOD = 90 days;
bytes4 constant private INTERFACE_META_ID = bytes4(keccak256("supportsInterface(bytes4)"));
bytes4 constant private ERC721_ID = bytes4(
keccak256("balanceOf(address)") ^
keccak256("ownerOf(uint256)") ^
keccak256("approve(address,uint256)") ^
keccak256("getApproved(uint256)") ^
keccak256("setApprovalForAll(address,bool)") ^
keccak256("isApprovedForAll(address,address)") ^
keccak256("transferFrom(address,address,uint256)") ^
keccak256("safeTransferFrom(address,address,uint256)") ^
keccak256("safeTransferFrom(address,address,uint256,bytes)")
);
bytes4 constant private RECLAIM_ID = bytes4(keccak256("reclaim(uint256,address)"));
string public baseURI_;
/**
* v2.1.3 version of _isApprovedOrOwner which calls ownerOf(tokenId) and takes grace period into consideration instead of ERC721.ownerOf(tokenId);
* https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v2.1.3/contracts/token/ERC721/ERC721.sol#L187
* @dev Returns whether the given spender can transfer a given token ID
* @param spender address of the spender to query
* @param tokenId uint256 ID of the token to be transferred
* @return bool whether the msg.sender is approved for the given token ID,
* is an operator of the owner, or is the owner of the token
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view override returns (bool) {
}
constructor(TDNS _tdns, bytes32 _baseNode) ERC721("Tomi Domain Name System","TDNS") {
}
modifier live {
}
modifier onlyController {
}
/**
* @dev Gets the owner of the specified token ID. Names become unowned
* when their registration expires.
* @param tokenId uint256 ID of the token to query the owner of
* @return address currently marked as the owner of the given token ID
*/
function ownerOf(uint256 tokenId) public view override(IERC721, ERC721) returns (address) {
require(<FILL_ME>)
return super.ownerOf(tokenId);
}
// Authorises a controller, who can register and renew domains.
function addController(address controller) external override onlyOwner {
}
// Revoke controller permission for an address.
function removeController(address controller) external override onlyOwner {
}
// Set the resolver for the TLD this registrar manages.
function setResolver(address resolver) external override onlyOwner {
}
// Returns the expiration timestamp of the specified id.
function nameExpires(uint256 id) external view override returns(uint) {
}
// Returns true iff the specified name is available for registration.
function available(uint256 id) public view override returns(bool) {
}
/**
* @dev Register a name.
* @param id The token ID (keccak256 of the label).
* @param owner The address that should own the registration.
* @param duration Duration in seconds for the registration.
*/
function register(uint256 id, address owner, uint duration) external override returns(uint) {
}
/**
* @dev Register a name, without modifying the registry.
* @param id The token ID (keccak256 of the label).
* @param owner The address that should own the registration.
* @param duration Duration in seconds for the registration.
*/
function registerOnly(uint256 id, address owner, uint duration) external returns(uint) {
}
function _register(uint256 id, address owner, uint duration, bool updateRegistry) internal live onlyController returns(uint) {
}
function renew(uint256 id, uint duration) external override live onlyController returns(uint) {
}
/**
* @dev Reclaim ownership of a name in TDNS, if you own it in the registrar.
*/
function reclaim(uint256 id, address owner) public override live {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721,IERC721) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory _uri) external onlyOwner {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view override(ERC721, IBaseRegistrar) returns (string memory) {
}
function supportsInterface(bytes4 interfaceID) public override(ERC721, IERC165) view returns (bool) {
}
}
| expiries[tokenId]>block.timestamp | 103,825 | expiries[tokenId]>block.timestamp |
null | pragma solidity >=0.8.4;
import "../registry/TDNS.sol";
import "./IBaseRegistrar.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract BaseRegistrarImplementation is ERC721, IBaseRegistrar, Ownable {
// A map of expiry times
mapping(uint256=>uint) expiries;
// The TDNS registry
TDNS public tdns;
// The namehash of the TLD this registrar owns (eg, .tomi)
bytes32 public baseNode;
// A map of addresses that are authorised to register and renew names.
mapping(address => bool) public controllers;
uint256 public constant GRACE_PERIOD = 90 days;
bytes4 constant private INTERFACE_META_ID = bytes4(keccak256("supportsInterface(bytes4)"));
bytes4 constant private ERC721_ID = bytes4(
keccak256("balanceOf(address)") ^
keccak256("ownerOf(uint256)") ^
keccak256("approve(address,uint256)") ^
keccak256("getApproved(uint256)") ^
keccak256("setApprovalForAll(address,bool)") ^
keccak256("isApprovedForAll(address,address)") ^
keccak256("transferFrom(address,address,uint256)") ^
keccak256("safeTransferFrom(address,address,uint256)") ^
keccak256("safeTransferFrom(address,address,uint256,bytes)")
);
bytes4 constant private RECLAIM_ID = bytes4(keccak256("reclaim(uint256,address)"));
string public baseURI_;
/**
* v2.1.3 version of _isApprovedOrOwner which calls ownerOf(tokenId) and takes grace period into consideration instead of ERC721.ownerOf(tokenId);
* https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v2.1.3/contracts/token/ERC721/ERC721.sol#L187
* @dev Returns whether the given spender can transfer a given token ID
* @param spender address of the spender to query
* @param tokenId uint256 ID of the token to be transferred
* @return bool whether the msg.sender is approved for the given token ID,
* is an operator of the owner, or is the owner of the token
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view override returns (bool) {
}
constructor(TDNS _tdns, bytes32 _baseNode) ERC721("Tomi Domain Name System","TDNS") {
}
modifier live {
}
modifier onlyController {
}
/**
* @dev Gets the owner of the specified token ID. Names become unowned
* when their registration expires.
* @param tokenId uint256 ID of the token to query the owner of
* @return address currently marked as the owner of the given token ID
*/
function ownerOf(uint256 tokenId) public view override(IERC721, ERC721) returns (address) {
}
// Authorises a controller, who can register and renew domains.
function addController(address controller) external override onlyOwner {
}
// Revoke controller permission for an address.
function removeController(address controller) external override onlyOwner {
}
// Set the resolver for the TLD this registrar manages.
function setResolver(address resolver) external override onlyOwner {
}
// Returns the expiration timestamp of the specified id.
function nameExpires(uint256 id) external view override returns(uint) {
}
// Returns true iff the specified name is available for registration.
function available(uint256 id) public view override returns(bool) {
}
/**
* @dev Register a name.
* @param id The token ID (keccak256 of the label).
* @param owner The address that should own the registration.
* @param duration Duration in seconds for the registration.
*/
function register(uint256 id, address owner, uint duration) external override returns(uint) {
}
/**
* @dev Register a name, without modifying the registry.
* @param id The token ID (keccak256 of the label).
* @param owner The address that should own the registration.
* @param duration Duration in seconds for the registration.
*/
function registerOnly(uint256 id, address owner, uint duration) external returns(uint) {
}
function _register(uint256 id, address owner, uint duration, bool updateRegistry) internal live onlyController returns(uint) {
require(<FILL_ME>)
require(block.timestamp + duration + GRACE_PERIOD > block.timestamp + GRACE_PERIOD); // Prevent future overflow
expiries[id] = block.timestamp + duration;
if(_exists(id)) {
// Name was previously owned, and expired
_burn(id);
}
_mint(owner, id);
if(updateRegistry) {
tdns.setSubnodeOwnerRegistrar(bytes32(id), owner);
}
emit NameRegistered(id, owner, block.timestamp + duration);
return block.timestamp + duration;
}
function renew(uint256 id, uint duration) external override live onlyController returns(uint) {
}
/**
* @dev Reclaim ownership of a name in TDNS, if you own it in the registrar.
*/
function reclaim(uint256 id, address owner) public override live {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721,IERC721) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory _uri) external onlyOwner {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view override(ERC721, IBaseRegistrar) returns (string memory) {
}
function supportsInterface(bytes4 interfaceID) public override(ERC721, IERC165) view returns (bool) {
}
}
| available(id) | 103,825 | available(id) |
null | pragma solidity >=0.8.4;
import "../registry/TDNS.sol";
import "./IBaseRegistrar.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract BaseRegistrarImplementation is ERC721, IBaseRegistrar, Ownable {
// A map of expiry times
mapping(uint256=>uint) expiries;
// The TDNS registry
TDNS public tdns;
// The namehash of the TLD this registrar owns (eg, .tomi)
bytes32 public baseNode;
// A map of addresses that are authorised to register and renew names.
mapping(address => bool) public controllers;
uint256 public constant GRACE_PERIOD = 90 days;
bytes4 constant private INTERFACE_META_ID = bytes4(keccak256("supportsInterface(bytes4)"));
bytes4 constant private ERC721_ID = bytes4(
keccak256("balanceOf(address)") ^
keccak256("ownerOf(uint256)") ^
keccak256("approve(address,uint256)") ^
keccak256("getApproved(uint256)") ^
keccak256("setApprovalForAll(address,bool)") ^
keccak256("isApprovedForAll(address,address)") ^
keccak256("transferFrom(address,address,uint256)") ^
keccak256("safeTransferFrom(address,address,uint256)") ^
keccak256("safeTransferFrom(address,address,uint256,bytes)")
);
bytes4 constant private RECLAIM_ID = bytes4(keccak256("reclaim(uint256,address)"));
string public baseURI_;
/**
* v2.1.3 version of _isApprovedOrOwner which calls ownerOf(tokenId) and takes grace period into consideration instead of ERC721.ownerOf(tokenId);
* https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v2.1.3/contracts/token/ERC721/ERC721.sol#L187
* @dev Returns whether the given spender can transfer a given token ID
* @param spender address of the spender to query
* @param tokenId uint256 ID of the token to be transferred
* @return bool whether the msg.sender is approved for the given token ID,
* is an operator of the owner, or is the owner of the token
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view override returns (bool) {
}
constructor(TDNS _tdns, bytes32 _baseNode) ERC721("Tomi Domain Name System","TDNS") {
}
modifier live {
}
modifier onlyController {
}
/**
* @dev Gets the owner of the specified token ID. Names become unowned
* when their registration expires.
* @param tokenId uint256 ID of the token to query the owner of
* @return address currently marked as the owner of the given token ID
*/
function ownerOf(uint256 tokenId) public view override(IERC721, ERC721) returns (address) {
}
// Authorises a controller, who can register and renew domains.
function addController(address controller) external override onlyOwner {
}
// Revoke controller permission for an address.
function removeController(address controller) external override onlyOwner {
}
// Set the resolver for the TLD this registrar manages.
function setResolver(address resolver) external override onlyOwner {
}
// Returns the expiration timestamp of the specified id.
function nameExpires(uint256 id) external view override returns(uint) {
}
// Returns true iff the specified name is available for registration.
function available(uint256 id) public view override returns(bool) {
}
/**
* @dev Register a name.
* @param id The token ID (keccak256 of the label).
* @param owner The address that should own the registration.
* @param duration Duration in seconds for the registration.
*/
function register(uint256 id, address owner, uint duration) external override returns(uint) {
}
/**
* @dev Register a name, without modifying the registry.
* @param id The token ID (keccak256 of the label).
* @param owner The address that should own the registration.
* @param duration Duration in seconds for the registration.
*/
function registerOnly(uint256 id, address owner, uint duration) external returns(uint) {
}
function _register(uint256 id, address owner, uint duration, bool updateRegistry) internal live onlyController returns(uint) {
require(available(id));
require(<FILL_ME>) // Prevent future overflow
expiries[id] = block.timestamp + duration;
if(_exists(id)) {
// Name was previously owned, and expired
_burn(id);
}
_mint(owner, id);
if(updateRegistry) {
tdns.setSubnodeOwnerRegistrar(bytes32(id), owner);
}
emit NameRegistered(id, owner, block.timestamp + duration);
return block.timestamp + duration;
}
function renew(uint256 id, uint duration) external override live onlyController returns(uint) {
}
/**
* @dev Reclaim ownership of a name in TDNS, if you own it in the registrar.
*/
function reclaim(uint256 id, address owner) public override live {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721,IERC721) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory _uri) external onlyOwner {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view override(ERC721, IBaseRegistrar) returns (string memory) {
}
function supportsInterface(bytes4 interfaceID) public override(ERC721, IERC165) view returns (bool) {
}
}
| block.timestamp+duration+GRACE_PERIOD>block.timestamp+GRACE_PERIOD | 103,825 | block.timestamp+duration+GRACE_PERIOD>block.timestamp+GRACE_PERIOD |
null | pragma solidity >=0.8.4;
import "../registry/TDNS.sol";
import "./IBaseRegistrar.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract BaseRegistrarImplementation is ERC721, IBaseRegistrar, Ownable {
// A map of expiry times
mapping(uint256=>uint) expiries;
// The TDNS registry
TDNS public tdns;
// The namehash of the TLD this registrar owns (eg, .tomi)
bytes32 public baseNode;
// A map of addresses that are authorised to register and renew names.
mapping(address => bool) public controllers;
uint256 public constant GRACE_PERIOD = 90 days;
bytes4 constant private INTERFACE_META_ID = bytes4(keccak256("supportsInterface(bytes4)"));
bytes4 constant private ERC721_ID = bytes4(
keccak256("balanceOf(address)") ^
keccak256("ownerOf(uint256)") ^
keccak256("approve(address,uint256)") ^
keccak256("getApproved(uint256)") ^
keccak256("setApprovalForAll(address,bool)") ^
keccak256("isApprovedForAll(address,address)") ^
keccak256("transferFrom(address,address,uint256)") ^
keccak256("safeTransferFrom(address,address,uint256)") ^
keccak256("safeTransferFrom(address,address,uint256,bytes)")
);
bytes4 constant private RECLAIM_ID = bytes4(keccak256("reclaim(uint256,address)"));
string public baseURI_;
/**
* v2.1.3 version of _isApprovedOrOwner which calls ownerOf(tokenId) and takes grace period into consideration instead of ERC721.ownerOf(tokenId);
* https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v2.1.3/contracts/token/ERC721/ERC721.sol#L187
* @dev Returns whether the given spender can transfer a given token ID
* @param spender address of the spender to query
* @param tokenId uint256 ID of the token to be transferred
* @return bool whether the msg.sender is approved for the given token ID,
* is an operator of the owner, or is the owner of the token
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view override returns (bool) {
}
constructor(TDNS _tdns, bytes32 _baseNode) ERC721("Tomi Domain Name System","TDNS") {
}
modifier live {
}
modifier onlyController {
}
/**
* @dev Gets the owner of the specified token ID. Names become unowned
* when their registration expires.
* @param tokenId uint256 ID of the token to query the owner of
* @return address currently marked as the owner of the given token ID
*/
function ownerOf(uint256 tokenId) public view override(IERC721, ERC721) returns (address) {
}
// Authorises a controller, who can register and renew domains.
function addController(address controller) external override onlyOwner {
}
// Revoke controller permission for an address.
function removeController(address controller) external override onlyOwner {
}
// Set the resolver for the TLD this registrar manages.
function setResolver(address resolver) external override onlyOwner {
}
// Returns the expiration timestamp of the specified id.
function nameExpires(uint256 id) external view override returns(uint) {
}
// Returns true iff the specified name is available for registration.
function available(uint256 id) public view override returns(bool) {
}
/**
* @dev Register a name.
* @param id The token ID (keccak256 of the label).
* @param owner The address that should own the registration.
* @param duration Duration in seconds for the registration.
*/
function register(uint256 id, address owner, uint duration) external override returns(uint) {
}
/**
* @dev Register a name, without modifying the registry.
* @param id The token ID (keccak256 of the label).
* @param owner The address that should own the registration.
* @param duration Duration in seconds for the registration.
*/
function registerOnly(uint256 id, address owner, uint duration) external returns(uint) {
}
function _register(uint256 id, address owner, uint duration, bool updateRegistry) internal live onlyController returns(uint) {
}
function renew(uint256 id, uint duration) external override live onlyController returns(uint) {
require(<FILL_ME>) // Name must be registered here or in grace period
require(expiries[id] + duration + GRACE_PERIOD > duration + GRACE_PERIOD); // Prevent future overflow
expiries[id] += duration;
emit NameRenewed(id, expiries[id]);
return expiries[id];
}
/**
* @dev Reclaim ownership of a name in TDNS, if you own it in the registrar.
*/
function reclaim(uint256 id, address owner) public override live {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721,IERC721) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory _uri) external onlyOwner {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view override(ERC721, IBaseRegistrar) returns (string memory) {
}
function supportsInterface(bytes4 interfaceID) public override(ERC721, IERC165) view returns (bool) {
}
}
| expiries[id]+GRACE_PERIOD>=block.timestamp | 103,825 | expiries[id]+GRACE_PERIOD>=block.timestamp |
null | pragma solidity >=0.8.4;
import "../registry/TDNS.sol";
import "./IBaseRegistrar.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract BaseRegistrarImplementation is ERC721, IBaseRegistrar, Ownable {
// A map of expiry times
mapping(uint256=>uint) expiries;
// The TDNS registry
TDNS public tdns;
// The namehash of the TLD this registrar owns (eg, .tomi)
bytes32 public baseNode;
// A map of addresses that are authorised to register and renew names.
mapping(address => bool) public controllers;
uint256 public constant GRACE_PERIOD = 90 days;
bytes4 constant private INTERFACE_META_ID = bytes4(keccak256("supportsInterface(bytes4)"));
bytes4 constant private ERC721_ID = bytes4(
keccak256("balanceOf(address)") ^
keccak256("ownerOf(uint256)") ^
keccak256("approve(address,uint256)") ^
keccak256("getApproved(uint256)") ^
keccak256("setApprovalForAll(address,bool)") ^
keccak256("isApprovedForAll(address,address)") ^
keccak256("transferFrom(address,address,uint256)") ^
keccak256("safeTransferFrom(address,address,uint256)") ^
keccak256("safeTransferFrom(address,address,uint256,bytes)")
);
bytes4 constant private RECLAIM_ID = bytes4(keccak256("reclaim(uint256,address)"));
string public baseURI_;
/**
* v2.1.3 version of _isApprovedOrOwner which calls ownerOf(tokenId) and takes grace period into consideration instead of ERC721.ownerOf(tokenId);
* https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v2.1.3/contracts/token/ERC721/ERC721.sol#L187
* @dev Returns whether the given spender can transfer a given token ID
* @param spender address of the spender to query
* @param tokenId uint256 ID of the token to be transferred
* @return bool whether the msg.sender is approved for the given token ID,
* is an operator of the owner, or is the owner of the token
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view override returns (bool) {
}
constructor(TDNS _tdns, bytes32 _baseNode) ERC721("Tomi Domain Name System","TDNS") {
}
modifier live {
}
modifier onlyController {
}
/**
* @dev Gets the owner of the specified token ID. Names become unowned
* when their registration expires.
* @param tokenId uint256 ID of the token to query the owner of
* @return address currently marked as the owner of the given token ID
*/
function ownerOf(uint256 tokenId) public view override(IERC721, ERC721) returns (address) {
}
// Authorises a controller, who can register and renew domains.
function addController(address controller) external override onlyOwner {
}
// Revoke controller permission for an address.
function removeController(address controller) external override onlyOwner {
}
// Set the resolver for the TLD this registrar manages.
function setResolver(address resolver) external override onlyOwner {
}
// Returns the expiration timestamp of the specified id.
function nameExpires(uint256 id) external view override returns(uint) {
}
// Returns true iff the specified name is available for registration.
function available(uint256 id) public view override returns(bool) {
}
/**
* @dev Register a name.
* @param id The token ID (keccak256 of the label).
* @param owner The address that should own the registration.
* @param duration Duration in seconds for the registration.
*/
function register(uint256 id, address owner, uint duration) external override returns(uint) {
}
/**
* @dev Register a name, without modifying the registry.
* @param id The token ID (keccak256 of the label).
* @param owner The address that should own the registration.
* @param duration Duration in seconds for the registration.
*/
function registerOnly(uint256 id, address owner, uint duration) external returns(uint) {
}
function _register(uint256 id, address owner, uint duration, bool updateRegistry) internal live onlyController returns(uint) {
}
function renew(uint256 id, uint duration) external override live onlyController returns(uint) {
require(expiries[id] + GRACE_PERIOD >= block.timestamp); // Name must be registered here or in grace period
require(<FILL_ME>) // Prevent future overflow
expiries[id] += duration;
emit NameRenewed(id, expiries[id]);
return expiries[id];
}
/**
* @dev Reclaim ownership of a name in TDNS, if you own it in the registrar.
*/
function reclaim(uint256 id, address owner) public override live {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721,IERC721) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory _uri) external onlyOwner {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view override(ERC721, IBaseRegistrar) returns (string memory) {
}
function supportsInterface(bytes4 interfaceID) public override(ERC721, IERC165) view returns (bool) {
}
}
| expiries[id]+duration+GRACE_PERIOD>duration+GRACE_PERIOD | 103,825 | expiries[id]+duration+GRACE_PERIOD>duration+GRACE_PERIOD |
null | pragma solidity >=0.8.4;
import "../registry/TDNS.sol";
import "./IBaseRegistrar.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract BaseRegistrarImplementation is ERC721, IBaseRegistrar, Ownable {
// A map of expiry times
mapping(uint256=>uint) expiries;
// The TDNS registry
TDNS public tdns;
// The namehash of the TLD this registrar owns (eg, .tomi)
bytes32 public baseNode;
// A map of addresses that are authorised to register and renew names.
mapping(address => bool) public controllers;
uint256 public constant GRACE_PERIOD = 90 days;
bytes4 constant private INTERFACE_META_ID = bytes4(keccak256("supportsInterface(bytes4)"));
bytes4 constant private ERC721_ID = bytes4(
keccak256("balanceOf(address)") ^
keccak256("ownerOf(uint256)") ^
keccak256("approve(address,uint256)") ^
keccak256("getApproved(uint256)") ^
keccak256("setApprovalForAll(address,bool)") ^
keccak256("isApprovedForAll(address,address)") ^
keccak256("transferFrom(address,address,uint256)") ^
keccak256("safeTransferFrom(address,address,uint256)") ^
keccak256("safeTransferFrom(address,address,uint256,bytes)")
);
bytes4 constant private RECLAIM_ID = bytes4(keccak256("reclaim(uint256,address)"));
string public baseURI_;
/**
* v2.1.3 version of _isApprovedOrOwner which calls ownerOf(tokenId) and takes grace period into consideration instead of ERC721.ownerOf(tokenId);
* https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v2.1.3/contracts/token/ERC721/ERC721.sol#L187
* @dev Returns whether the given spender can transfer a given token ID
* @param spender address of the spender to query
* @param tokenId uint256 ID of the token to be transferred
* @return bool whether the msg.sender is approved for the given token ID,
* is an operator of the owner, or is the owner of the token
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view override returns (bool) {
}
constructor(TDNS _tdns, bytes32 _baseNode) ERC721("Tomi Domain Name System","TDNS") {
}
modifier live {
}
modifier onlyController {
}
/**
* @dev Gets the owner of the specified token ID. Names become unowned
* when their registration expires.
* @param tokenId uint256 ID of the token to query the owner of
* @return address currently marked as the owner of the given token ID
*/
function ownerOf(uint256 tokenId) public view override(IERC721, ERC721) returns (address) {
}
// Authorises a controller, who can register and renew domains.
function addController(address controller) external override onlyOwner {
}
// Revoke controller permission for an address.
function removeController(address controller) external override onlyOwner {
}
// Set the resolver for the TLD this registrar manages.
function setResolver(address resolver) external override onlyOwner {
}
// Returns the expiration timestamp of the specified id.
function nameExpires(uint256 id) external view override returns(uint) {
}
// Returns true iff the specified name is available for registration.
function available(uint256 id) public view override returns(bool) {
}
/**
* @dev Register a name.
* @param id The token ID (keccak256 of the label).
* @param owner The address that should own the registration.
* @param duration Duration in seconds for the registration.
*/
function register(uint256 id, address owner, uint duration) external override returns(uint) {
}
/**
* @dev Register a name, without modifying the registry.
* @param id The token ID (keccak256 of the label).
* @param owner The address that should own the registration.
* @param duration Duration in seconds for the registration.
*/
function registerOnly(uint256 id, address owner, uint duration) external returns(uint) {
}
function _register(uint256 id, address owner, uint duration, bool updateRegistry) internal live onlyController returns(uint) {
}
function renew(uint256 id, uint duration) external override live onlyController returns(uint) {
}
/**
* @dev Reclaim ownership of a name in TDNS, if you own it in the registrar.
*/
function reclaim(uint256 id, address owner) public override live {
require(<FILL_ME>)
tdns.setSubnodeOwnerRegistrar(bytes32(id), owner);
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721,IERC721) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory _uri) external onlyOwner {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view override(ERC721, IBaseRegistrar) returns (string memory) {
}
function supportsInterface(bytes4 interfaceID) public override(ERC721, IERC165) view returns (bool) {
}
}
| _isApprovedOrOwner(msg.sender,id) | 103,825 | _isApprovedOrOwner(msg.sender,id) |
"Sazuki Limit Claimed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
contract Sazuki is ERC721A, Ownable, ReentrancyGuard {
string public baseURI;
uint public price = 500000000000000;
uint public maxPerTx = 30;
uint public maxPerWallet = 60;
uint public totalFree = 2000;
uint public maxSupply = 9999;
uint public freeMint = 5;
bool public mintStart = true;
mapping (address => uint256) public addressMint;
constructor() ERC721A("Sazuki", "Sazuki"){}
function mint(uint256 amount) external payable
{
uint cost = price;
if(msg.value == 0 && totalSupply() + amount <= totalFree)
{
require(<FILL_ME>)
addressMint[msg.sender] += amount;
cost = 0;
}
require(msg.value >= amount * cost,"Sazuki Limit Insufficient Funds");
require(mintStart, "Sazuki Limit Minting Pause");
require(amount <= maxPerTx, "Sazuki Limit Per Transaction");
require(totalSupply() + amount <= maxSupply,"Sazuki Soldout");
require(numberMinted(msg.sender) + amount <= maxPerWallet,"Sazuki Limit Wallet");
_safeMint(msg.sender, amount);
}
function toggleMintingSazuki() external onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function setPriceSazuki(uint256 price_) external onlyOwner {
}
function setTotalFreeSazuki(uint256 totalFree_) external onlyOwner {
}
function setFreeMintSazuki(uint256 freeMint_) external onlyOwner {
}
function setMaxPerTxSazuki(uint256 maxPerTx_) external onlyOwner {
}
function setMaxPerWalletSazuki(uint256 maxPerWallet_) external onlyOwner {
}
function setmaxSupplySazuki(uint256 maxSupply_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function airdropSazuki(address to ,uint256 amount) external onlyOwner
{
}
function ownerMintSazuki(uint256 amount) external onlyOwner
{
}
function withdraw() external onlyOwner nonReentrant {
}
}
| addressMint[msg.sender]+amount<=freeMint,"Sazuki Limit Claimed" | 103,851 | addressMint[msg.sender]+amount<=freeMint |
"Sazuki Limit Wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
contract Sazuki is ERC721A, Ownable, ReentrancyGuard {
string public baseURI;
uint public price = 500000000000000;
uint public maxPerTx = 30;
uint public maxPerWallet = 60;
uint public totalFree = 2000;
uint public maxSupply = 9999;
uint public freeMint = 5;
bool public mintStart = true;
mapping (address => uint256) public addressMint;
constructor() ERC721A("Sazuki", "Sazuki"){}
function mint(uint256 amount) external payable
{
uint cost = price;
if(msg.value == 0 && totalSupply() + amount <= totalFree)
{
require(addressMint[msg.sender] + amount <= freeMint,"Sazuki Limit Claimed");
addressMint[msg.sender] += amount;
cost = 0;
}
require(msg.value >= amount * cost,"Sazuki Limit Insufficient Funds");
require(mintStart, "Sazuki Limit Minting Pause");
require(amount <= maxPerTx, "Sazuki Limit Per Transaction");
require(totalSupply() + amount <= maxSupply,"Sazuki Soldout");
require(<FILL_ME>)
_safeMint(msg.sender, amount);
}
function toggleMintingSazuki() external onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function setPriceSazuki(uint256 price_) external onlyOwner {
}
function setTotalFreeSazuki(uint256 totalFree_) external onlyOwner {
}
function setFreeMintSazuki(uint256 freeMint_) external onlyOwner {
}
function setMaxPerTxSazuki(uint256 maxPerTx_) external onlyOwner {
}
function setMaxPerWalletSazuki(uint256 maxPerWallet_) external onlyOwner {
}
function setmaxSupplySazuki(uint256 maxSupply_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function airdropSazuki(address to ,uint256 amount) external onlyOwner
{
}
function ownerMintSazuki(uint256 amount) external onlyOwner
{
}
function withdraw() external onlyOwner nonReentrant {
}
}
| numberMinted(msg.sender)+amount<=maxPerWallet,"Sazuki Limit Wallet" | 103,851 | numberMinted(msg.sender)+amount<=maxPerWallet |
"Not enough ether sent" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract gobilinis_quest is ERC721AQueryable, Ownable, DefaultOperatorFilterer, ReentrancyGuard
{
using Strings for uint256;
uint256 MAX_MINTS = 69;
uint256 MAX_SUPPLY = 6969;
uint256 public mintRate = 0.01 ether;
string private uriPrefix = "ipfs://QmfPLwrjWTcVWjTYS4TBoD9eowWtJRMwVXHStJAPHsqH4A/";
string private uriSuffix = ".json";
constructor() ERC721A("Gobilini's Quest", "GQ") {}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function mint(uint256 quantity) external payable {
// _safeMint's second argument now takes in a quantity, not a tokenId.
require(quantity + _numberMinted(msg.sender) <= MAX_MINTS, "Exceeded the limit");
require(totalSupply() + quantity <= MAX_SUPPLY, "Not enough tokens left");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
function withdraw() external payable onlyOwner {
}
// --------Owner Functions----------//
function setMintRate(uint256 _mintRate) public onlyOwner {
}
// ---- Update Metadata Prefix/Suffix--------- //
function setUriPrefix(string memory _uriPrefix) external onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) external onlyOwner {
}
//-----------OPENSEA ROYALTIES BELOW----------//
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
}
| msg.value>=(mintRate*quantity),"Not enough ether sent" | 103,882 | msg.value>=(mintRate*quantity) |
"PNMYS1C1ANC: Over number of whitelist." | pragma solidity ^0.8.0;
/*
** 888b d888 .d8888b. Y88b d88P 888 d8b 88888888888 888 d8888 d8b 888
** 8888b d8888 d88P "88b Y88b d88P 888 Y8P 888 888 d88888 Y8P 888
** 88888b.d88888 Y88b. d88P Y88o88P 888 888 888 d88P888 888
** 888Y88888P888 .d88b. 88888b.d88b. .d88b. "Y8888P" Y888P .d88b. 888888 888 888 88888b. .d88b. d88P 888 88888b. .d8888b 888 .d88b. 88888b. 888888 .d8888b
** 888 Y888P 888 d88""88b 888 "888 "88b d88""88b .d88P88K.d88P 888 d8P Y8b 888 888 888 888 "88b d8P Y8b d88P 888 888 "88b d88P" 888 d8P Y8b 888 "88b 888 88K
** 888 Y8P 888 888 888 888 888 888 888 888 888" Y888P" 888 88888888 888 888 888 888 888 88888888 d88P 888 888 888 888 888 88888888 888 888 888 "Y8888b.
** 888 " 888 Y88..88P 888 888 888 Y88..88P Y88b .d8888b 888 Y8b. Y88b. 888 888 888 888 Y8b. d8888888888 888 888 Y88b. 888 Y8b. 888 888 Y88b. X88
** 888 888 "Y88P" 888 888 888 "Y88P" "Y8888P" Y88b 888 "Y8888 "Y888 888 888 888 888 "Y8888 d88P 888 888 888 "Y8888P 888 "Y8888 888 888 "Y888 88888P'
*/
contract PNMYS1C1ANC is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
// NFT Name
string public constant TOKEN_NAME = "Momo & Yeti The Ancients";
// NFT Symbol
string public constant TOKEN_SYMBOL = "PNMYS1C1ANC";
// NFT toke `baseURI`
string public baseURI;
// token counter
Counters.Counter private _tokenIds;
// total NFT number
uint256 public maxTotalSupply;
// total curreny in this contract
uint256 private _totalCurrency;
// total mint nft number in public sale
uint256 public totalMintNumberPublicSale;
// public sale max number
uint256 public publicSaleLimit;
// public sale price
uint256 public publicSalePrice;
// total mint nft number in airdrop
uint256 public totalMintNumberAirDrop;
/**
* 0 disabled
* 1 publicSale
* 2 presale
*/
uint16 public saleStatus;
struct PresaleInfo {
bool enabled; // status in presale
uint256 totalMintedNumber; // presale minted number
uint256 limitPerUser; // limit mint number per user
uint256 maxSpotNumber; // max number of client
uint256 price; // presale price
uint256 whiteCounter; // white counter
}
PresaleInfo[] public presaleInfoList;
struct WhiteInfo {
bool enabled; // white user status
uint256 counter; // nft mint counter
}
// clientAddress => presaleId => flag
mapping(address => mapping(uint256 => WhiteInfo)) public whiteList;
// clientAddress => mint number in public
mapping(address => uint256) public publicSoldList;
// mapping nft number to flag of sold
mapping(uint256 => bool) private _nftSoldList;
/**
* Emitted when `_tokenBaseURI` updated
*/
event BaseURI(string bseURI);
event SetSaleStatus(uint16 status);
event AddPreSaleInfo(bool enabled, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price);
event UpdatePreSaleInfo(uint256 preSaleInfoIndex, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price);
event SetPreSaleStatus(uint256 preSaleInfoIndex, bool status);
event SetPublicSaleLimit(uint256 counter);
event SetPublicSalePrice(uint256 price);
event AddClientToWhiteList(uint256 preSaleInfoIndex, address[] clients);
event RemoveClientFromWhiteList(uint256 preSaleInfoIndex, address[] clients);
event PresaleMint(uint256 preSaleInfoIndex, address indexed client, uint256 amount, uint256 price);
event PublicSaleMint(address indexed client, uint256 amount, uint256 price);
event ClientMint(uint256 amount);
event AdminAirdrop(address indexed client, uint256[] tokensIds);
event WithdrawAdmin(address indexed owner, address indexed to, uint256 amount);
// http://3.211.1.250/api/ancients/
constructor(string memory BASEURI) ERC721(TOKEN_NAME, TOKEN_SYMBOL) {
}
function _baseURI() internal view override returns (string memory) {
}
/**
* set `baseURI`
*/
function setBaseURI(string calldata uri) external onlyOwner {
}
/**
* @param status 0 disable
* @param status 1 publicSale
* @param status 2 presale
*/
function setSaleStatus(uint16 status) external onlyOwner {
}
/**
* @param enabled presale status
* @param limitPerUser limit mint number per user
* @param maxSpotNumber max mint number per presale
* @param price presale price
*/
function addPreSaleInfo(bool enabled, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale list
* @param limitPerUser limit mint number per user
* @param maxSpotNumber max mint number per presale
* @param price presale price
*/
function updatePreSaleInfo(uint256 preSaleInfoIndex, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale list
* @param status presale status
*/
function setPreSaleStatus(uint256 preSaleInfoIndex, bool status) external onlyOwner {
}
/**
* set `publicSaleLimit`
*/
function setPublicSaleLimit(uint256 counter) external onlyOwner {
}
/**
* set `publicSalePrice`
*/
function setPublicSalePrice(uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale info
* @param clients clients list
*/
function addClientToWhiteList(uint256 preSaleInfoIndex, address[] calldata clients)
external
onlyOwner
{
require(presaleInfoList.length > 0, "PNMYS1C1ANC: Empty presale information.");
require(preSaleInfoIndex < presaleInfoList.length, "PNMYS1C1ANC: Over number of presale index.");
PresaleInfo storage _preSaleInfo = presaleInfoList[preSaleInfoIndex];
require(<FILL_ME>)
for (uint256 i = 0; i < clients.length; i++) {
require(
clients[i] != address(0),
"PNMYS1C1ANC: Zero address can't be added to whitelist."
);
}
for (uint256 i = 0; i < clients.length; i++) {
if (!whiteList[clients[i]][preSaleInfoIndex].enabled) {
whiteList[clients[i]][preSaleInfoIndex] = WhiteInfo({ enabled: true, counter: 0 });
_preSaleInfo.whiteCounter++;
}
}
emit AddClientToWhiteList(preSaleInfoIndex, clients);
}
/**
* @param preSaleInfoIndex index of presale info
* @param clients clients list
*/
function removeClientFromWhiteList(uint256 preSaleInfoIndex, address[] calldata clients)
external
onlyOwner
{
}
/**
* @param preSaleInfoIndex index of presale info
* @param amount amount
**/
function presaleMint(uint256 preSaleInfoIndex, uint256 amount) internal {
}
/**
* @param amount mint amount
* @dev public sale mint
**/
function publicSaleMint(uint256 amount) internal {
}
/**
* @param amount is amount for minting
* access by admin
*/
function clientMint(uint256 amount) external payable {
}
/**
* @param client airdrop address
* @param tokenIdArray token number address for airdrop
* access by admin
*/
function adminAirdrop(address client, uint256[] calldata tokenIdArray)
external
onlyOwner
{
}
/**
* get total mint number
*/
function getTotalMintNumber() public view returns (uint256) {
}
/**
* get total currency number in this smart contract address
* access admin
*/
function getTotalCurrency() external view onlyOwner returns (uint256) {
}
/**
* @param to money receiver address
* @param value transer amount
* access admin
*/
function withdrawAdmin(address payable to, uint256 value)
external
onlyOwner
{
}
}
| (_preSaleInfo.whiteCounter+clients.length)<=_preSaleInfo.maxSpotNumber,"PNMYS1C1ANC: Over number of whitelist." | 103,916 | (_preSaleInfo.whiteCounter+clients.length)<=_preSaleInfo.maxSpotNumber |
"PNMYS1C1ANC: Zero address can't be added to whitelist." | pragma solidity ^0.8.0;
/*
** 888b d888 .d8888b. Y88b d88P 888 d8b 88888888888 888 d8888 d8b 888
** 8888b d8888 d88P "88b Y88b d88P 888 Y8P 888 888 d88888 Y8P 888
** 88888b.d88888 Y88b. d88P Y88o88P 888 888 888 d88P888 888
** 888Y88888P888 .d88b. 88888b.d88b. .d88b. "Y8888P" Y888P .d88b. 888888 888 888 88888b. .d88b. d88P 888 88888b. .d8888b 888 .d88b. 88888b. 888888 .d8888b
** 888 Y888P 888 d88""88b 888 "888 "88b d88""88b .d88P88K.d88P 888 d8P Y8b 888 888 888 888 "88b d8P Y8b d88P 888 888 "88b d88P" 888 d8P Y8b 888 "88b 888 88K
** 888 Y8P 888 888 888 888 888 888 888 888 888" Y888P" 888 88888888 888 888 888 888 888 88888888 d88P 888 888 888 888 888 88888888 888 888 888 "Y8888b.
** 888 " 888 Y88..88P 888 888 888 Y88..88P Y88b .d8888b 888 Y8b. Y88b. 888 888 888 888 Y8b. d8888888888 888 888 Y88b. 888 Y8b. 888 888 Y88b. X88
** 888 888 "Y88P" 888 888 888 "Y88P" "Y8888P" Y88b 888 "Y8888 "Y888 888 888 888 888 "Y8888 d88P 888 888 888 "Y8888P 888 "Y8888 888 888 "Y888 88888P'
*/
contract PNMYS1C1ANC is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
// NFT Name
string public constant TOKEN_NAME = "Momo & Yeti The Ancients";
// NFT Symbol
string public constant TOKEN_SYMBOL = "PNMYS1C1ANC";
// NFT toke `baseURI`
string public baseURI;
// token counter
Counters.Counter private _tokenIds;
// total NFT number
uint256 public maxTotalSupply;
// total curreny in this contract
uint256 private _totalCurrency;
// total mint nft number in public sale
uint256 public totalMintNumberPublicSale;
// public sale max number
uint256 public publicSaleLimit;
// public sale price
uint256 public publicSalePrice;
// total mint nft number in airdrop
uint256 public totalMintNumberAirDrop;
/**
* 0 disabled
* 1 publicSale
* 2 presale
*/
uint16 public saleStatus;
struct PresaleInfo {
bool enabled; // status in presale
uint256 totalMintedNumber; // presale minted number
uint256 limitPerUser; // limit mint number per user
uint256 maxSpotNumber; // max number of client
uint256 price; // presale price
uint256 whiteCounter; // white counter
}
PresaleInfo[] public presaleInfoList;
struct WhiteInfo {
bool enabled; // white user status
uint256 counter; // nft mint counter
}
// clientAddress => presaleId => flag
mapping(address => mapping(uint256 => WhiteInfo)) public whiteList;
// clientAddress => mint number in public
mapping(address => uint256) public publicSoldList;
// mapping nft number to flag of sold
mapping(uint256 => bool) private _nftSoldList;
/**
* Emitted when `_tokenBaseURI` updated
*/
event BaseURI(string bseURI);
event SetSaleStatus(uint16 status);
event AddPreSaleInfo(bool enabled, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price);
event UpdatePreSaleInfo(uint256 preSaleInfoIndex, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price);
event SetPreSaleStatus(uint256 preSaleInfoIndex, bool status);
event SetPublicSaleLimit(uint256 counter);
event SetPublicSalePrice(uint256 price);
event AddClientToWhiteList(uint256 preSaleInfoIndex, address[] clients);
event RemoveClientFromWhiteList(uint256 preSaleInfoIndex, address[] clients);
event PresaleMint(uint256 preSaleInfoIndex, address indexed client, uint256 amount, uint256 price);
event PublicSaleMint(address indexed client, uint256 amount, uint256 price);
event ClientMint(uint256 amount);
event AdminAirdrop(address indexed client, uint256[] tokensIds);
event WithdrawAdmin(address indexed owner, address indexed to, uint256 amount);
// http://3.211.1.250/api/ancients/
constructor(string memory BASEURI) ERC721(TOKEN_NAME, TOKEN_SYMBOL) {
}
function _baseURI() internal view override returns (string memory) {
}
/**
* set `baseURI`
*/
function setBaseURI(string calldata uri) external onlyOwner {
}
/**
* @param status 0 disable
* @param status 1 publicSale
* @param status 2 presale
*/
function setSaleStatus(uint16 status) external onlyOwner {
}
/**
* @param enabled presale status
* @param limitPerUser limit mint number per user
* @param maxSpotNumber max mint number per presale
* @param price presale price
*/
function addPreSaleInfo(bool enabled, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale list
* @param limitPerUser limit mint number per user
* @param maxSpotNumber max mint number per presale
* @param price presale price
*/
function updatePreSaleInfo(uint256 preSaleInfoIndex, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale list
* @param status presale status
*/
function setPreSaleStatus(uint256 preSaleInfoIndex, bool status) external onlyOwner {
}
/**
* set `publicSaleLimit`
*/
function setPublicSaleLimit(uint256 counter) external onlyOwner {
}
/**
* set `publicSalePrice`
*/
function setPublicSalePrice(uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale info
* @param clients clients list
*/
function addClientToWhiteList(uint256 preSaleInfoIndex, address[] calldata clients)
external
onlyOwner
{
require(presaleInfoList.length > 0, "PNMYS1C1ANC: Empty presale information.");
require(preSaleInfoIndex < presaleInfoList.length, "PNMYS1C1ANC: Over number of presale index.");
PresaleInfo storage _preSaleInfo = presaleInfoList[preSaleInfoIndex];
require((_preSaleInfo.whiteCounter + clients.length) <= _preSaleInfo.maxSpotNumber,
"PNMYS1C1ANC: Over number of whitelist.");
for (uint256 i = 0; i < clients.length; i++) {
require(<FILL_ME>)
}
for (uint256 i = 0; i < clients.length; i++) {
if (!whiteList[clients[i]][preSaleInfoIndex].enabled) {
whiteList[clients[i]][preSaleInfoIndex] = WhiteInfo({ enabled: true, counter: 0 });
_preSaleInfo.whiteCounter++;
}
}
emit AddClientToWhiteList(preSaleInfoIndex, clients);
}
/**
* @param preSaleInfoIndex index of presale info
* @param clients clients list
*/
function removeClientFromWhiteList(uint256 preSaleInfoIndex, address[] calldata clients)
external
onlyOwner
{
}
/**
* @param preSaleInfoIndex index of presale info
* @param amount amount
**/
function presaleMint(uint256 preSaleInfoIndex, uint256 amount) internal {
}
/**
* @param amount mint amount
* @dev public sale mint
**/
function publicSaleMint(uint256 amount) internal {
}
/**
* @param amount is amount for minting
* access by admin
*/
function clientMint(uint256 amount) external payable {
}
/**
* @param client airdrop address
* @param tokenIdArray token number address for airdrop
* access by admin
*/
function adminAirdrop(address client, uint256[] calldata tokenIdArray)
external
onlyOwner
{
}
/**
* get total mint number
*/
function getTotalMintNumber() public view returns (uint256) {
}
/**
* get total currency number in this smart contract address
* access admin
*/
function getTotalCurrency() external view onlyOwner returns (uint256) {
}
/**
* @param to money receiver address
* @param value transer amount
* access admin
*/
function withdrawAdmin(address payable to, uint256 value)
external
onlyOwner
{
}
}
| clients[i]!=address(0),"PNMYS1C1ANC: Zero address can't be added to whitelist." | 103,916 | clients[i]!=address(0) |
"PNMYS1C1ANC: Presale is not allowed at this time." | pragma solidity ^0.8.0;
/*
** 888b d888 .d8888b. Y88b d88P 888 d8b 88888888888 888 d8888 d8b 888
** 8888b d8888 d88P "88b Y88b d88P 888 Y8P 888 888 d88888 Y8P 888
** 88888b.d88888 Y88b. d88P Y88o88P 888 888 888 d88P888 888
** 888Y88888P888 .d88b. 88888b.d88b. .d88b. "Y8888P" Y888P .d88b. 888888 888 888 88888b. .d88b. d88P 888 88888b. .d8888b 888 .d88b. 88888b. 888888 .d8888b
** 888 Y888P 888 d88""88b 888 "888 "88b d88""88b .d88P88K.d88P 888 d8P Y8b 888 888 888 888 "88b d8P Y8b d88P 888 888 "88b d88P" 888 d8P Y8b 888 "88b 888 88K
** 888 Y8P 888 888 888 888 888 888 888 888 888" Y888P" 888 88888888 888 888 888 888 888 88888888 d88P 888 888 888 888 888 88888888 888 888 888 "Y8888b.
** 888 " 888 Y88..88P 888 888 888 Y88..88P Y88b .d8888b 888 Y8b. Y88b. 888 888 888 888 Y8b. d8888888888 888 888 Y88b. 888 Y8b. 888 888 Y88b. X88
** 888 888 "Y88P" 888 888 888 "Y88P" "Y8888P" Y88b 888 "Y8888 "Y888 888 888 888 888 "Y8888 d88P 888 888 888 "Y8888P 888 "Y8888 888 888 "Y888 88888P'
*/
contract PNMYS1C1ANC is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
// NFT Name
string public constant TOKEN_NAME = "Momo & Yeti The Ancients";
// NFT Symbol
string public constant TOKEN_SYMBOL = "PNMYS1C1ANC";
// NFT toke `baseURI`
string public baseURI;
// token counter
Counters.Counter private _tokenIds;
// total NFT number
uint256 public maxTotalSupply;
// total curreny in this contract
uint256 private _totalCurrency;
// total mint nft number in public sale
uint256 public totalMintNumberPublicSale;
// public sale max number
uint256 public publicSaleLimit;
// public sale price
uint256 public publicSalePrice;
// total mint nft number in airdrop
uint256 public totalMintNumberAirDrop;
/**
* 0 disabled
* 1 publicSale
* 2 presale
*/
uint16 public saleStatus;
struct PresaleInfo {
bool enabled; // status in presale
uint256 totalMintedNumber; // presale minted number
uint256 limitPerUser; // limit mint number per user
uint256 maxSpotNumber; // max number of client
uint256 price; // presale price
uint256 whiteCounter; // white counter
}
PresaleInfo[] public presaleInfoList;
struct WhiteInfo {
bool enabled; // white user status
uint256 counter; // nft mint counter
}
// clientAddress => presaleId => flag
mapping(address => mapping(uint256 => WhiteInfo)) public whiteList;
// clientAddress => mint number in public
mapping(address => uint256) public publicSoldList;
// mapping nft number to flag of sold
mapping(uint256 => bool) private _nftSoldList;
/**
* Emitted when `_tokenBaseURI` updated
*/
event BaseURI(string bseURI);
event SetSaleStatus(uint16 status);
event AddPreSaleInfo(bool enabled, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price);
event UpdatePreSaleInfo(uint256 preSaleInfoIndex, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price);
event SetPreSaleStatus(uint256 preSaleInfoIndex, bool status);
event SetPublicSaleLimit(uint256 counter);
event SetPublicSalePrice(uint256 price);
event AddClientToWhiteList(uint256 preSaleInfoIndex, address[] clients);
event RemoveClientFromWhiteList(uint256 preSaleInfoIndex, address[] clients);
event PresaleMint(uint256 preSaleInfoIndex, address indexed client, uint256 amount, uint256 price);
event PublicSaleMint(address indexed client, uint256 amount, uint256 price);
event ClientMint(uint256 amount);
event AdminAirdrop(address indexed client, uint256[] tokensIds);
event WithdrawAdmin(address indexed owner, address indexed to, uint256 amount);
// http://3.211.1.250/api/ancients/
constructor(string memory BASEURI) ERC721(TOKEN_NAME, TOKEN_SYMBOL) {
}
function _baseURI() internal view override returns (string memory) {
}
/**
* set `baseURI`
*/
function setBaseURI(string calldata uri) external onlyOwner {
}
/**
* @param status 0 disable
* @param status 1 publicSale
* @param status 2 presale
*/
function setSaleStatus(uint16 status) external onlyOwner {
}
/**
* @param enabled presale status
* @param limitPerUser limit mint number per user
* @param maxSpotNumber max mint number per presale
* @param price presale price
*/
function addPreSaleInfo(bool enabled, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale list
* @param limitPerUser limit mint number per user
* @param maxSpotNumber max mint number per presale
* @param price presale price
*/
function updatePreSaleInfo(uint256 preSaleInfoIndex, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale list
* @param status presale status
*/
function setPreSaleStatus(uint256 preSaleInfoIndex, bool status) external onlyOwner {
}
/**
* set `publicSaleLimit`
*/
function setPublicSaleLimit(uint256 counter) external onlyOwner {
}
/**
* set `publicSalePrice`
*/
function setPublicSalePrice(uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale info
* @param clients clients list
*/
function addClientToWhiteList(uint256 preSaleInfoIndex, address[] calldata clients)
external
onlyOwner
{
}
/**
* @param preSaleInfoIndex index of presale info
* @param clients clients list
*/
function removeClientFromWhiteList(uint256 preSaleInfoIndex, address[] calldata clients)
external
onlyOwner
{
}
/**
* @param preSaleInfoIndex index of presale info
* @param amount amount
**/
function presaleMint(uint256 preSaleInfoIndex, uint256 amount) internal {
require(saleStatus == 2, "PNMYS1C1ANC: Presale is not live.");
require(presaleInfoList.length > 0, "PNMYS1C1ANC: There is not presale information.");
require(preSaleInfoIndex < presaleInfoList.length, "PNMYS1C1ANC: Over number of presale index.");
require(amount > 0, "PNMYS1C1ANC: Amount should be a positive number.");
PresaleInfo storage _preSaleInfo = presaleInfoList[preSaleInfoIndex];
WhiteInfo storage _whiteInfo = whiteList[msg.sender][preSaleInfoIndex];
require(<FILL_ME>)
require(
_whiteInfo.enabled == true,
"PNMYS1C1ANC: You are not added to the whitelist."
);
require(
_preSaleInfo.price * amount == msg.value,
"PNMYS1C1ANC: Your presale payment amount does not match required presale minting amount list."
);
require(
(amount + _whiteInfo.counter) <= _preSaleInfo.limitPerUser,
"PNMYS1C1ANC: Your presale amount exceeds our presale minting amount limit."
);
for (uint256 i = 0; i < amount; i++) {
while (_nftSoldList[_tokenIds.current()] == true) {
_tokenIds.increment();
}
_nftSoldList[_tokenIds.current()] = true;
_safeMint(msg.sender, _tokenIds.current());
_whiteInfo.counter++;
_tokenIds.increment();
}
_totalCurrency += msg.value;
_preSaleInfo.totalMintedNumber += amount;
emit PresaleMint(preSaleInfoIndex, msg.sender, amount, msg.value);
}
/**
* @param amount mint amount
* @dev public sale mint
**/
function publicSaleMint(uint256 amount) internal {
}
/**
* @param amount is amount for minting
* access by admin
*/
function clientMint(uint256 amount) external payable {
}
/**
* @param client airdrop address
* @param tokenIdArray token number address for airdrop
* access by admin
*/
function adminAirdrop(address client, uint256[] calldata tokenIdArray)
external
onlyOwner
{
}
/**
* get total mint number
*/
function getTotalMintNumber() public view returns (uint256) {
}
/**
* get total currency number in this smart contract address
* access admin
*/
function getTotalCurrency() external view onlyOwner returns (uint256) {
}
/**
* @param to money receiver address
* @param value transer amount
* access admin
*/
function withdrawAdmin(address payable to, uint256 value)
external
onlyOwner
{
}
}
| _preSaleInfo.enabled,"PNMYS1C1ANC: Presale is not allowed at this time." | 103,916 | _preSaleInfo.enabled |
"PNMYS1C1ANC: Your presale payment amount does not match required presale minting amount list." | pragma solidity ^0.8.0;
/*
** 888b d888 .d8888b. Y88b d88P 888 d8b 88888888888 888 d8888 d8b 888
** 8888b d8888 d88P "88b Y88b d88P 888 Y8P 888 888 d88888 Y8P 888
** 88888b.d88888 Y88b. d88P Y88o88P 888 888 888 d88P888 888
** 888Y88888P888 .d88b. 88888b.d88b. .d88b. "Y8888P" Y888P .d88b. 888888 888 888 88888b. .d88b. d88P 888 88888b. .d8888b 888 .d88b. 88888b. 888888 .d8888b
** 888 Y888P 888 d88""88b 888 "888 "88b d88""88b .d88P88K.d88P 888 d8P Y8b 888 888 888 888 "88b d8P Y8b d88P 888 888 "88b d88P" 888 d8P Y8b 888 "88b 888 88K
** 888 Y8P 888 888 888 888 888 888 888 888 888" Y888P" 888 88888888 888 888 888 888 888 88888888 d88P 888 888 888 888 888 88888888 888 888 888 "Y8888b.
** 888 " 888 Y88..88P 888 888 888 Y88..88P Y88b .d8888b 888 Y8b. Y88b. 888 888 888 888 Y8b. d8888888888 888 888 Y88b. 888 Y8b. 888 888 Y88b. X88
** 888 888 "Y88P" 888 888 888 "Y88P" "Y8888P" Y88b 888 "Y8888 "Y888 888 888 888 888 "Y8888 d88P 888 888 888 "Y8888P 888 "Y8888 888 888 "Y888 88888P'
*/
contract PNMYS1C1ANC is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
// NFT Name
string public constant TOKEN_NAME = "Momo & Yeti The Ancients";
// NFT Symbol
string public constant TOKEN_SYMBOL = "PNMYS1C1ANC";
// NFT toke `baseURI`
string public baseURI;
// token counter
Counters.Counter private _tokenIds;
// total NFT number
uint256 public maxTotalSupply;
// total curreny in this contract
uint256 private _totalCurrency;
// total mint nft number in public sale
uint256 public totalMintNumberPublicSale;
// public sale max number
uint256 public publicSaleLimit;
// public sale price
uint256 public publicSalePrice;
// total mint nft number in airdrop
uint256 public totalMintNumberAirDrop;
/**
* 0 disabled
* 1 publicSale
* 2 presale
*/
uint16 public saleStatus;
struct PresaleInfo {
bool enabled; // status in presale
uint256 totalMintedNumber; // presale minted number
uint256 limitPerUser; // limit mint number per user
uint256 maxSpotNumber; // max number of client
uint256 price; // presale price
uint256 whiteCounter; // white counter
}
PresaleInfo[] public presaleInfoList;
struct WhiteInfo {
bool enabled; // white user status
uint256 counter; // nft mint counter
}
// clientAddress => presaleId => flag
mapping(address => mapping(uint256 => WhiteInfo)) public whiteList;
// clientAddress => mint number in public
mapping(address => uint256) public publicSoldList;
// mapping nft number to flag of sold
mapping(uint256 => bool) private _nftSoldList;
/**
* Emitted when `_tokenBaseURI` updated
*/
event BaseURI(string bseURI);
event SetSaleStatus(uint16 status);
event AddPreSaleInfo(bool enabled, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price);
event UpdatePreSaleInfo(uint256 preSaleInfoIndex, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price);
event SetPreSaleStatus(uint256 preSaleInfoIndex, bool status);
event SetPublicSaleLimit(uint256 counter);
event SetPublicSalePrice(uint256 price);
event AddClientToWhiteList(uint256 preSaleInfoIndex, address[] clients);
event RemoveClientFromWhiteList(uint256 preSaleInfoIndex, address[] clients);
event PresaleMint(uint256 preSaleInfoIndex, address indexed client, uint256 amount, uint256 price);
event PublicSaleMint(address indexed client, uint256 amount, uint256 price);
event ClientMint(uint256 amount);
event AdminAirdrop(address indexed client, uint256[] tokensIds);
event WithdrawAdmin(address indexed owner, address indexed to, uint256 amount);
// http://3.211.1.250/api/ancients/
constructor(string memory BASEURI) ERC721(TOKEN_NAME, TOKEN_SYMBOL) {
}
function _baseURI() internal view override returns (string memory) {
}
/**
* set `baseURI`
*/
function setBaseURI(string calldata uri) external onlyOwner {
}
/**
* @param status 0 disable
* @param status 1 publicSale
* @param status 2 presale
*/
function setSaleStatus(uint16 status) external onlyOwner {
}
/**
* @param enabled presale status
* @param limitPerUser limit mint number per user
* @param maxSpotNumber max mint number per presale
* @param price presale price
*/
function addPreSaleInfo(bool enabled, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale list
* @param limitPerUser limit mint number per user
* @param maxSpotNumber max mint number per presale
* @param price presale price
*/
function updatePreSaleInfo(uint256 preSaleInfoIndex, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale list
* @param status presale status
*/
function setPreSaleStatus(uint256 preSaleInfoIndex, bool status) external onlyOwner {
}
/**
* set `publicSaleLimit`
*/
function setPublicSaleLimit(uint256 counter) external onlyOwner {
}
/**
* set `publicSalePrice`
*/
function setPublicSalePrice(uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale info
* @param clients clients list
*/
function addClientToWhiteList(uint256 preSaleInfoIndex, address[] calldata clients)
external
onlyOwner
{
}
/**
* @param preSaleInfoIndex index of presale info
* @param clients clients list
*/
function removeClientFromWhiteList(uint256 preSaleInfoIndex, address[] calldata clients)
external
onlyOwner
{
}
/**
* @param preSaleInfoIndex index of presale info
* @param amount amount
**/
function presaleMint(uint256 preSaleInfoIndex, uint256 amount) internal {
require(saleStatus == 2, "PNMYS1C1ANC: Presale is not live.");
require(presaleInfoList.length > 0, "PNMYS1C1ANC: There is not presale information.");
require(preSaleInfoIndex < presaleInfoList.length, "PNMYS1C1ANC: Over number of presale index.");
require(amount > 0, "PNMYS1C1ANC: Amount should be a positive number.");
PresaleInfo storage _preSaleInfo = presaleInfoList[preSaleInfoIndex];
WhiteInfo storage _whiteInfo = whiteList[msg.sender][preSaleInfoIndex];
require(
_preSaleInfo.enabled,
"PNMYS1C1ANC: Presale is not allowed at this time."
);
require(
_whiteInfo.enabled == true,
"PNMYS1C1ANC: You are not added to the whitelist."
);
require(<FILL_ME>)
require(
(amount + _whiteInfo.counter) <= _preSaleInfo.limitPerUser,
"PNMYS1C1ANC: Your presale amount exceeds our presale minting amount limit."
);
for (uint256 i = 0; i < amount; i++) {
while (_nftSoldList[_tokenIds.current()] == true) {
_tokenIds.increment();
}
_nftSoldList[_tokenIds.current()] = true;
_safeMint(msg.sender, _tokenIds.current());
_whiteInfo.counter++;
_tokenIds.increment();
}
_totalCurrency += msg.value;
_preSaleInfo.totalMintedNumber += amount;
emit PresaleMint(preSaleInfoIndex, msg.sender, amount, msg.value);
}
/**
* @param amount mint amount
* @dev public sale mint
**/
function publicSaleMint(uint256 amount) internal {
}
/**
* @param amount is amount for minting
* access by admin
*/
function clientMint(uint256 amount) external payable {
}
/**
* @param client airdrop address
* @param tokenIdArray token number address for airdrop
* access by admin
*/
function adminAirdrop(address client, uint256[] calldata tokenIdArray)
external
onlyOwner
{
}
/**
* get total mint number
*/
function getTotalMintNumber() public view returns (uint256) {
}
/**
* get total currency number in this smart contract address
* access admin
*/
function getTotalCurrency() external view onlyOwner returns (uint256) {
}
/**
* @param to money receiver address
* @param value transer amount
* access admin
*/
function withdrawAdmin(address payable to, uint256 value)
external
onlyOwner
{
}
}
| _preSaleInfo.price*amount==msg.value,"PNMYS1C1ANC: Your presale payment amount does not match required presale minting amount list." | 103,916 | _preSaleInfo.price*amount==msg.value |
"PNMYS1C1ANC: Your presale amount exceeds our presale minting amount limit." | pragma solidity ^0.8.0;
/*
** 888b d888 .d8888b. Y88b d88P 888 d8b 88888888888 888 d8888 d8b 888
** 8888b d8888 d88P "88b Y88b d88P 888 Y8P 888 888 d88888 Y8P 888
** 88888b.d88888 Y88b. d88P Y88o88P 888 888 888 d88P888 888
** 888Y88888P888 .d88b. 88888b.d88b. .d88b. "Y8888P" Y888P .d88b. 888888 888 888 88888b. .d88b. d88P 888 88888b. .d8888b 888 .d88b. 88888b. 888888 .d8888b
** 888 Y888P 888 d88""88b 888 "888 "88b d88""88b .d88P88K.d88P 888 d8P Y8b 888 888 888 888 "88b d8P Y8b d88P 888 888 "88b d88P" 888 d8P Y8b 888 "88b 888 88K
** 888 Y8P 888 888 888 888 888 888 888 888 888" Y888P" 888 88888888 888 888 888 888 888 88888888 d88P 888 888 888 888 888 88888888 888 888 888 "Y8888b.
** 888 " 888 Y88..88P 888 888 888 Y88..88P Y88b .d8888b 888 Y8b. Y88b. 888 888 888 888 Y8b. d8888888888 888 888 Y88b. 888 Y8b. 888 888 Y88b. X88
** 888 888 "Y88P" 888 888 888 "Y88P" "Y8888P" Y88b 888 "Y8888 "Y888 888 888 888 888 "Y8888 d88P 888 888 888 "Y8888P 888 "Y8888 888 888 "Y888 88888P'
*/
contract PNMYS1C1ANC is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
// NFT Name
string public constant TOKEN_NAME = "Momo & Yeti The Ancients";
// NFT Symbol
string public constant TOKEN_SYMBOL = "PNMYS1C1ANC";
// NFT toke `baseURI`
string public baseURI;
// token counter
Counters.Counter private _tokenIds;
// total NFT number
uint256 public maxTotalSupply;
// total curreny in this contract
uint256 private _totalCurrency;
// total mint nft number in public sale
uint256 public totalMintNumberPublicSale;
// public sale max number
uint256 public publicSaleLimit;
// public sale price
uint256 public publicSalePrice;
// total mint nft number in airdrop
uint256 public totalMintNumberAirDrop;
/**
* 0 disabled
* 1 publicSale
* 2 presale
*/
uint16 public saleStatus;
struct PresaleInfo {
bool enabled; // status in presale
uint256 totalMintedNumber; // presale minted number
uint256 limitPerUser; // limit mint number per user
uint256 maxSpotNumber; // max number of client
uint256 price; // presale price
uint256 whiteCounter; // white counter
}
PresaleInfo[] public presaleInfoList;
struct WhiteInfo {
bool enabled; // white user status
uint256 counter; // nft mint counter
}
// clientAddress => presaleId => flag
mapping(address => mapping(uint256 => WhiteInfo)) public whiteList;
// clientAddress => mint number in public
mapping(address => uint256) public publicSoldList;
// mapping nft number to flag of sold
mapping(uint256 => bool) private _nftSoldList;
/**
* Emitted when `_tokenBaseURI` updated
*/
event BaseURI(string bseURI);
event SetSaleStatus(uint16 status);
event AddPreSaleInfo(bool enabled, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price);
event UpdatePreSaleInfo(uint256 preSaleInfoIndex, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price);
event SetPreSaleStatus(uint256 preSaleInfoIndex, bool status);
event SetPublicSaleLimit(uint256 counter);
event SetPublicSalePrice(uint256 price);
event AddClientToWhiteList(uint256 preSaleInfoIndex, address[] clients);
event RemoveClientFromWhiteList(uint256 preSaleInfoIndex, address[] clients);
event PresaleMint(uint256 preSaleInfoIndex, address indexed client, uint256 amount, uint256 price);
event PublicSaleMint(address indexed client, uint256 amount, uint256 price);
event ClientMint(uint256 amount);
event AdminAirdrop(address indexed client, uint256[] tokensIds);
event WithdrawAdmin(address indexed owner, address indexed to, uint256 amount);
// http://3.211.1.250/api/ancients/
constructor(string memory BASEURI) ERC721(TOKEN_NAME, TOKEN_SYMBOL) {
}
function _baseURI() internal view override returns (string memory) {
}
/**
* set `baseURI`
*/
function setBaseURI(string calldata uri) external onlyOwner {
}
/**
* @param status 0 disable
* @param status 1 publicSale
* @param status 2 presale
*/
function setSaleStatus(uint16 status) external onlyOwner {
}
/**
* @param enabled presale status
* @param limitPerUser limit mint number per user
* @param maxSpotNumber max mint number per presale
* @param price presale price
*/
function addPreSaleInfo(bool enabled, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale list
* @param limitPerUser limit mint number per user
* @param maxSpotNumber max mint number per presale
* @param price presale price
*/
function updatePreSaleInfo(uint256 preSaleInfoIndex, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale list
* @param status presale status
*/
function setPreSaleStatus(uint256 preSaleInfoIndex, bool status) external onlyOwner {
}
/**
* set `publicSaleLimit`
*/
function setPublicSaleLimit(uint256 counter) external onlyOwner {
}
/**
* set `publicSalePrice`
*/
function setPublicSalePrice(uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale info
* @param clients clients list
*/
function addClientToWhiteList(uint256 preSaleInfoIndex, address[] calldata clients)
external
onlyOwner
{
}
/**
* @param preSaleInfoIndex index of presale info
* @param clients clients list
*/
function removeClientFromWhiteList(uint256 preSaleInfoIndex, address[] calldata clients)
external
onlyOwner
{
}
/**
* @param preSaleInfoIndex index of presale info
* @param amount amount
**/
function presaleMint(uint256 preSaleInfoIndex, uint256 amount) internal {
require(saleStatus == 2, "PNMYS1C1ANC: Presale is not live.");
require(presaleInfoList.length > 0, "PNMYS1C1ANC: There is not presale information.");
require(preSaleInfoIndex < presaleInfoList.length, "PNMYS1C1ANC: Over number of presale index.");
require(amount > 0, "PNMYS1C1ANC: Amount should be a positive number.");
PresaleInfo storage _preSaleInfo = presaleInfoList[preSaleInfoIndex];
WhiteInfo storage _whiteInfo = whiteList[msg.sender][preSaleInfoIndex];
require(
_preSaleInfo.enabled,
"PNMYS1C1ANC: Presale is not allowed at this time."
);
require(
_whiteInfo.enabled == true,
"PNMYS1C1ANC: You are not added to the whitelist."
);
require(
_preSaleInfo.price * amount == msg.value,
"PNMYS1C1ANC: Your presale payment amount does not match required presale minting amount list."
);
require(<FILL_ME>)
for (uint256 i = 0; i < amount; i++) {
while (_nftSoldList[_tokenIds.current()] == true) {
_tokenIds.increment();
}
_nftSoldList[_tokenIds.current()] = true;
_safeMint(msg.sender, _tokenIds.current());
_whiteInfo.counter++;
_tokenIds.increment();
}
_totalCurrency += msg.value;
_preSaleInfo.totalMintedNumber += amount;
emit PresaleMint(preSaleInfoIndex, msg.sender, amount, msg.value);
}
/**
* @param amount mint amount
* @dev public sale mint
**/
function publicSaleMint(uint256 amount) internal {
}
/**
* @param amount is amount for minting
* access by admin
*/
function clientMint(uint256 amount) external payable {
}
/**
* @param client airdrop address
* @param tokenIdArray token number address for airdrop
* access by admin
*/
function adminAirdrop(address client, uint256[] calldata tokenIdArray)
external
onlyOwner
{
}
/**
* get total mint number
*/
function getTotalMintNumber() public view returns (uint256) {
}
/**
* get total currency number in this smart contract address
* access admin
*/
function getTotalCurrency() external view onlyOwner returns (uint256) {
}
/**
* @param to money receiver address
* @param value transer amount
* access admin
*/
function withdrawAdmin(address payable to, uint256 value)
external
onlyOwner
{
}
}
| (amount+_whiteInfo.counter)<=_preSaleInfo.limitPerUser,"PNMYS1C1ANC: Your presale amount exceeds our presale minting amount limit." | 103,916 | (amount+_whiteInfo.counter)<=_preSaleInfo.limitPerUser |
"PNMYS1C1ANC: Your public sale amount does not match required public sale minting amount." | pragma solidity ^0.8.0;
/*
** 888b d888 .d8888b. Y88b d88P 888 d8b 88888888888 888 d8888 d8b 888
** 8888b d8888 d88P "88b Y88b d88P 888 Y8P 888 888 d88888 Y8P 888
** 88888b.d88888 Y88b. d88P Y88o88P 888 888 888 d88P888 888
** 888Y88888P888 .d88b. 88888b.d88b. .d88b. "Y8888P" Y888P .d88b. 888888 888 888 88888b. .d88b. d88P 888 88888b. .d8888b 888 .d88b. 88888b. 888888 .d8888b
** 888 Y888P 888 d88""88b 888 "888 "88b d88""88b .d88P88K.d88P 888 d8P Y8b 888 888 888 888 "88b d8P Y8b d88P 888 888 "88b d88P" 888 d8P Y8b 888 "88b 888 88K
** 888 Y8P 888 888 888 888 888 888 888 888 888" Y888P" 888 88888888 888 888 888 888 888 88888888 d88P 888 888 888 888 888 88888888 888 888 888 "Y8888b.
** 888 " 888 Y88..88P 888 888 888 Y88..88P Y88b .d8888b 888 Y8b. Y88b. 888 888 888 888 Y8b. d8888888888 888 888 Y88b. 888 Y8b. 888 888 Y88b. X88
** 888 888 "Y88P" 888 888 888 "Y88P" "Y8888P" Y88b 888 "Y8888 "Y888 888 888 888 888 "Y8888 d88P 888 888 888 "Y8888P 888 "Y8888 888 888 "Y888 88888P'
*/
contract PNMYS1C1ANC is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
// NFT Name
string public constant TOKEN_NAME = "Momo & Yeti The Ancients";
// NFT Symbol
string public constant TOKEN_SYMBOL = "PNMYS1C1ANC";
// NFT toke `baseURI`
string public baseURI;
// token counter
Counters.Counter private _tokenIds;
// total NFT number
uint256 public maxTotalSupply;
// total curreny in this contract
uint256 private _totalCurrency;
// total mint nft number in public sale
uint256 public totalMintNumberPublicSale;
// public sale max number
uint256 public publicSaleLimit;
// public sale price
uint256 public publicSalePrice;
// total mint nft number in airdrop
uint256 public totalMintNumberAirDrop;
/**
* 0 disabled
* 1 publicSale
* 2 presale
*/
uint16 public saleStatus;
struct PresaleInfo {
bool enabled; // status in presale
uint256 totalMintedNumber; // presale minted number
uint256 limitPerUser; // limit mint number per user
uint256 maxSpotNumber; // max number of client
uint256 price; // presale price
uint256 whiteCounter; // white counter
}
PresaleInfo[] public presaleInfoList;
struct WhiteInfo {
bool enabled; // white user status
uint256 counter; // nft mint counter
}
// clientAddress => presaleId => flag
mapping(address => mapping(uint256 => WhiteInfo)) public whiteList;
// clientAddress => mint number in public
mapping(address => uint256) public publicSoldList;
// mapping nft number to flag of sold
mapping(uint256 => bool) private _nftSoldList;
/**
* Emitted when `_tokenBaseURI` updated
*/
event BaseURI(string bseURI);
event SetSaleStatus(uint16 status);
event AddPreSaleInfo(bool enabled, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price);
event UpdatePreSaleInfo(uint256 preSaleInfoIndex, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price);
event SetPreSaleStatus(uint256 preSaleInfoIndex, bool status);
event SetPublicSaleLimit(uint256 counter);
event SetPublicSalePrice(uint256 price);
event AddClientToWhiteList(uint256 preSaleInfoIndex, address[] clients);
event RemoveClientFromWhiteList(uint256 preSaleInfoIndex, address[] clients);
event PresaleMint(uint256 preSaleInfoIndex, address indexed client, uint256 amount, uint256 price);
event PublicSaleMint(address indexed client, uint256 amount, uint256 price);
event ClientMint(uint256 amount);
event AdminAirdrop(address indexed client, uint256[] tokensIds);
event WithdrawAdmin(address indexed owner, address indexed to, uint256 amount);
// http://3.211.1.250/api/ancients/
constructor(string memory BASEURI) ERC721(TOKEN_NAME, TOKEN_SYMBOL) {
}
function _baseURI() internal view override returns (string memory) {
}
/**
* set `baseURI`
*/
function setBaseURI(string calldata uri) external onlyOwner {
}
/**
* @param status 0 disable
* @param status 1 publicSale
* @param status 2 presale
*/
function setSaleStatus(uint16 status) external onlyOwner {
}
/**
* @param enabled presale status
* @param limitPerUser limit mint number per user
* @param maxSpotNumber max mint number per presale
* @param price presale price
*/
function addPreSaleInfo(bool enabled, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale list
* @param limitPerUser limit mint number per user
* @param maxSpotNumber max mint number per presale
* @param price presale price
*/
function updatePreSaleInfo(uint256 preSaleInfoIndex, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale list
* @param status presale status
*/
function setPreSaleStatus(uint256 preSaleInfoIndex, bool status) external onlyOwner {
}
/**
* set `publicSaleLimit`
*/
function setPublicSaleLimit(uint256 counter) external onlyOwner {
}
/**
* set `publicSalePrice`
*/
function setPublicSalePrice(uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale info
* @param clients clients list
*/
function addClientToWhiteList(uint256 preSaleInfoIndex, address[] calldata clients)
external
onlyOwner
{
}
/**
* @param preSaleInfoIndex index of presale info
* @param clients clients list
*/
function removeClientFromWhiteList(uint256 preSaleInfoIndex, address[] calldata clients)
external
onlyOwner
{
}
/**
* @param preSaleInfoIndex index of presale info
* @param amount amount
**/
function presaleMint(uint256 preSaleInfoIndex, uint256 amount) internal {
}
/**
* @param amount mint amount
* @dev public sale mint
**/
function publicSaleMint(uint256 amount) internal {
require(saleStatus == 1, "PNMYS1C1ANC: Public sale is not live.");
require(amount > 0, "PNMYS1C1ANC: Amount should be a positive number.");
require(<FILL_ME>)
require(
(amount + publicSoldList[msg.sender]) <= publicSaleLimit,
"PNMYS1C1ANC: Your public sale amount exceeds our public sale minting amount limit."
);
for (uint256 i = 0; i < amount; i++) {
while (_nftSoldList[_tokenIds.current()] == true) {
_tokenIds.increment();
}
_nftSoldList[_tokenIds.current()] = true;
_safeMint(msg.sender, _tokenIds.current());
publicSoldList[msg.sender]++;
_tokenIds.increment();
}
_totalCurrency += msg.value;
totalMintNumberPublicSale += amount;
emit PublicSaleMint(msg.sender, amount, msg.value);
}
/**
* @param amount is amount for minting
* access by admin
*/
function clientMint(uint256 amount) external payable {
}
/**
* @param client airdrop address
* @param tokenIdArray token number address for airdrop
* access by admin
*/
function adminAirdrop(address client, uint256[] calldata tokenIdArray)
external
onlyOwner
{
}
/**
* get total mint number
*/
function getTotalMintNumber() public view returns (uint256) {
}
/**
* get total currency number in this smart contract address
* access admin
*/
function getTotalCurrency() external view onlyOwner returns (uint256) {
}
/**
* @param to money receiver address
* @param value transer amount
* access admin
*/
function withdrawAdmin(address payable to, uint256 value)
external
onlyOwner
{
}
}
| publicSalePrice*amount==msg.value,"PNMYS1C1ANC: Your public sale amount does not match required public sale minting amount." | 103,916 | publicSalePrice*amount==msg.value |
"PNMYS1C1ANC: Your public sale amount exceeds our public sale minting amount limit." | pragma solidity ^0.8.0;
/*
** 888b d888 .d8888b. Y88b d88P 888 d8b 88888888888 888 d8888 d8b 888
** 8888b d8888 d88P "88b Y88b d88P 888 Y8P 888 888 d88888 Y8P 888
** 88888b.d88888 Y88b. d88P Y88o88P 888 888 888 d88P888 888
** 888Y88888P888 .d88b. 88888b.d88b. .d88b. "Y8888P" Y888P .d88b. 888888 888 888 88888b. .d88b. d88P 888 88888b. .d8888b 888 .d88b. 88888b. 888888 .d8888b
** 888 Y888P 888 d88""88b 888 "888 "88b d88""88b .d88P88K.d88P 888 d8P Y8b 888 888 888 888 "88b d8P Y8b d88P 888 888 "88b d88P" 888 d8P Y8b 888 "88b 888 88K
** 888 Y8P 888 888 888 888 888 888 888 888 888" Y888P" 888 88888888 888 888 888 888 888 88888888 d88P 888 888 888 888 888 88888888 888 888 888 "Y8888b.
** 888 " 888 Y88..88P 888 888 888 Y88..88P Y88b .d8888b 888 Y8b. Y88b. 888 888 888 888 Y8b. d8888888888 888 888 Y88b. 888 Y8b. 888 888 Y88b. X88
** 888 888 "Y88P" 888 888 888 "Y88P" "Y8888P" Y88b 888 "Y8888 "Y888 888 888 888 888 "Y8888 d88P 888 888 888 "Y8888P 888 "Y8888 888 888 "Y888 88888P'
*/
contract PNMYS1C1ANC is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
// NFT Name
string public constant TOKEN_NAME = "Momo & Yeti The Ancients";
// NFT Symbol
string public constant TOKEN_SYMBOL = "PNMYS1C1ANC";
// NFT toke `baseURI`
string public baseURI;
// token counter
Counters.Counter private _tokenIds;
// total NFT number
uint256 public maxTotalSupply;
// total curreny in this contract
uint256 private _totalCurrency;
// total mint nft number in public sale
uint256 public totalMintNumberPublicSale;
// public sale max number
uint256 public publicSaleLimit;
// public sale price
uint256 public publicSalePrice;
// total mint nft number in airdrop
uint256 public totalMintNumberAirDrop;
/**
* 0 disabled
* 1 publicSale
* 2 presale
*/
uint16 public saleStatus;
struct PresaleInfo {
bool enabled; // status in presale
uint256 totalMintedNumber; // presale minted number
uint256 limitPerUser; // limit mint number per user
uint256 maxSpotNumber; // max number of client
uint256 price; // presale price
uint256 whiteCounter; // white counter
}
PresaleInfo[] public presaleInfoList;
struct WhiteInfo {
bool enabled; // white user status
uint256 counter; // nft mint counter
}
// clientAddress => presaleId => flag
mapping(address => mapping(uint256 => WhiteInfo)) public whiteList;
// clientAddress => mint number in public
mapping(address => uint256) public publicSoldList;
// mapping nft number to flag of sold
mapping(uint256 => bool) private _nftSoldList;
/**
* Emitted when `_tokenBaseURI` updated
*/
event BaseURI(string bseURI);
event SetSaleStatus(uint16 status);
event AddPreSaleInfo(bool enabled, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price);
event UpdatePreSaleInfo(uint256 preSaleInfoIndex, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price);
event SetPreSaleStatus(uint256 preSaleInfoIndex, bool status);
event SetPublicSaleLimit(uint256 counter);
event SetPublicSalePrice(uint256 price);
event AddClientToWhiteList(uint256 preSaleInfoIndex, address[] clients);
event RemoveClientFromWhiteList(uint256 preSaleInfoIndex, address[] clients);
event PresaleMint(uint256 preSaleInfoIndex, address indexed client, uint256 amount, uint256 price);
event PublicSaleMint(address indexed client, uint256 amount, uint256 price);
event ClientMint(uint256 amount);
event AdminAirdrop(address indexed client, uint256[] tokensIds);
event WithdrawAdmin(address indexed owner, address indexed to, uint256 amount);
// http://3.211.1.250/api/ancients/
constructor(string memory BASEURI) ERC721(TOKEN_NAME, TOKEN_SYMBOL) {
}
function _baseURI() internal view override returns (string memory) {
}
/**
* set `baseURI`
*/
function setBaseURI(string calldata uri) external onlyOwner {
}
/**
* @param status 0 disable
* @param status 1 publicSale
* @param status 2 presale
*/
function setSaleStatus(uint16 status) external onlyOwner {
}
/**
* @param enabled presale status
* @param limitPerUser limit mint number per user
* @param maxSpotNumber max mint number per presale
* @param price presale price
*/
function addPreSaleInfo(bool enabled, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale list
* @param limitPerUser limit mint number per user
* @param maxSpotNumber max mint number per presale
* @param price presale price
*/
function updatePreSaleInfo(uint256 preSaleInfoIndex, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale list
* @param status presale status
*/
function setPreSaleStatus(uint256 preSaleInfoIndex, bool status) external onlyOwner {
}
/**
* set `publicSaleLimit`
*/
function setPublicSaleLimit(uint256 counter) external onlyOwner {
}
/**
* set `publicSalePrice`
*/
function setPublicSalePrice(uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale info
* @param clients clients list
*/
function addClientToWhiteList(uint256 preSaleInfoIndex, address[] calldata clients)
external
onlyOwner
{
}
/**
* @param preSaleInfoIndex index of presale info
* @param clients clients list
*/
function removeClientFromWhiteList(uint256 preSaleInfoIndex, address[] calldata clients)
external
onlyOwner
{
}
/**
* @param preSaleInfoIndex index of presale info
* @param amount amount
**/
function presaleMint(uint256 preSaleInfoIndex, uint256 amount) internal {
}
/**
* @param amount mint amount
* @dev public sale mint
**/
function publicSaleMint(uint256 amount) internal {
require(saleStatus == 1, "PNMYS1C1ANC: Public sale is not live.");
require(amount > 0, "PNMYS1C1ANC: Amount should be a positive number.");
require(
publicSalePrice * amount == msg.value,
"PNMYS1C1ANC: Your public sale amount does not match required public sale minting amount."
);
require(<FILL_ME>)
for (uint256 i = 0; i < amount; i++) {
while (_nftSoldList[_tokenIds.current()] == true) {
_tokenIds.increment();
}
_nftSoldList[_tokenIds.current()] = true;
_safeMint(msg.sender, _tokenIds.current());
publicSoldList[msg.sender]++;
_tokenIds.increment();
}
_totalCurrency += msg.value;
totalMintNumberPublicSale += amount;
emit PublicSaleMint(msg.sender, amount, msg.value);
}
/**
* @param amount is amount for minting
* access by admin
*/
function clientMint(uint256 amount) external payable {
}
/**
* @param client airdrop address
* @param tokenIdArray token number address for airdrop
* access by admin
*/
function adminAirdrop(address client, uint256[] calldata tokenIdArray)
external
onlyOwner
{
}
/**
* get total mint number
*/
function getTotalMintNumber() public view returns (uint256) {
}
/**
* get total currency number in this smart contract address
* access admin
*/
function getTotalCurrency() external view onlyOwner returns (uint256) {
}
/**
* @param to money receiver address
* @param value transer amount
* access admin
*/
function withdrawAdmin(address payable to, uint256 value)
external
onlyOwner
{
}
}
| (amount+publicSoldList[msg.sender])<=publicSaleLimit,"PNMYS1C1ANC: Your public sale amount exceeds our public sale minting amount limit." | 103,916 | (amount+publicSoldList[msg.sender])<=publicSaleLimit |
"PNMYS1C1ANC: You can't mint that amount of tokens. Exceeds max supply." | pragma solidity ^0.8.0;
/*
** 888b d888 .d8888b. Y88b d88P 888 d8b 88888888888 888 d8888 d8b 888
** 8888b d8888 d88P "88b Y88b d88P 888 Y8P 888 888 d88888 Y8P 888
** 88888b.d88888 Y88b. d88P Y88o88P 888 888 888 d88P888 888
** 888Y88888P888 .d88b. 88888b.d88b. .d88b. "Y8888P" Y888P .d88b. 888888 888 888 88888b. .d88b. d88P 888 88888b. .d8888b 888 .d88b. 88888b. 888888 .d8888b
** 888 Y888P 888 d88""88b 888 "888 "88b d88""88b .d88P88K.d88P 888 d8P Y8b 888 888 888 888 "88b d8P Y8b d88P 888 888 "88b d88P" 888 d8P Y8b 888 "88b 888 88K
** 888 Y8P 888 888 888 888 888 888 888 888 888" Y888P" 888 88888888 888 888 888 888 888 88888888 d88P 888 888 888 888 888 88888888 888 888 888 "Y8888b.
** 888 " 888 Y88..88P 888 888 888 Y88..88P Y88b .d8888b 888 Y8b. Y88b. 888 888 888 888 Y8b. d8888888888 888 888 Y88b. 888 Y8b. 888 888 Y88b. X88
** 888 888 "Y88P" 888 888 888 "Y88P" "Y8888P" Y88b 888 "Y8888 "Y888 888 888 888 888 "Y8888 d88P 888 888 888 "Y8888P 888 "Y8888 888 888 "Y888 88888P'
*/
contract PNMYS1C1ANC is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
// NFT Name
string public constant TOKEN_NAME = "Momo & Yeti The Ancients";
// NFT Symbol
string public constant TOKEN_SYMBOL = "PNMYS1C1ANC";
// NFT toke `baseURI`
string public baseURI;
// token counter
Counters.Counter private _tokenIds;
// total NFT number
uint256 public maxTotalSupply;
// total curreny in this contract
uint256 private _totalCurrency;
// total mint nft number in public sale
uint256 public totalMintNumberPublicSale;
// public sale max number
uint256 public publicSaleLimit;
// public sale price
uint256 public publicSalePrice;
// total mint nft number in airdrop
uint256 public totalMintNumberAirDrop;
/**
* 0 disabled
* 1 publicSale
* 2 presale
*/
uint16 public saleStatus;
struct PresaleInfo {
bool enabled; // status in presale
uint256 totalMintedNumber; // presale minted number
uint256 limitPerUser; // limit mint number per user
uint256 maxSpotNumber; // max number of client
uint256 price; // presale price
uint256 whiteCounter; // white counter
}
PresaleInfo[] public presaleInfoList;
struct WhiteInfo {
bool enabled; // white user status
uint256 counter; // nft mint counter
}
// clientAddress => presaleId => flag
mapping(address => mapping(uint256 => WhiteInfo)) public whiteList;
// clientAddress => mint number in public
mapping(address => uint256) public publicSoldList;
// mapping nft number to flag of sold
mapping(uint256 => bool) private _nftSoldList;
/**
* Emitted when `_tokenBaseURI` updated
*/
event BaseURI(string bseURI);
event SetSaleStatus(uint16 status);
event AddPreSaleInfo(bool enabled, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price);
event UpdatePreSaleInfo(uint256 preSaleInfoIndex, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price);
event SetPreSaleStatus(uint256 preSaleInfoIndex, bool status);
event SetPublicSaleLimit(uint256 counter);
event SetPublicSalePrice(uint256 price);
event AddClientToWhiteList(uint256 preSaleInfoIndex, address[] clients);
event RemoveClientFromWhiteList(uint256 preSaleInfoIndex, address[] clients);
event PresaleMint(uint256 preSaleInfoIndex, address indexed client, uint256 amount, uint256 price);
event PublicSaleMint(address indexed client, uint256 amount, uint256 price);
event ClientMint(uint256 amount);
event AdminAirdrop(address indexed client, uint256[] tokensIds);
event WithdrawAdmin(address indexed owner, address indexed to, uint256 amount);
// http://3.211.1.250/api/ancients/
constructor(string memory BASEURI) ERC721(TOKEN_NAME, TOKEN_SYMBOL) {
}
function _baseURI() internal view override returns (string memory) {
}
/**
* set `baseURI`
*/
function setBaseURI(string calldata uri) external onlyOwner {
}
/**
* @param status 0 disable
* @param status 1 publicSale
* @param status 2 presale
*/
function setSaleStatus(uint16 status) external onlyOwner {
}
/**
* @param enabled presale status
* @param limitPerUser limit mint number per user
* @param maxSpotNumber max mint number per presale
* @param price presale price
*/
function addPreSaleInfo(bool enabled, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale list
* @param limitPerUser limit mint number per user
* @param maxSpotNumber max mint number per presale
* @param price presale price
*/
function updatePreSaleInfo(uint256 preSaleInfoIndex, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale list
* @param status presale status
*/
function setPreSaleStatus(uint256 preSaleInfoIndex, bool status) external onlyOwner {
}
/**
* set `publicSaleLimit`
*/
function setPublicSaleLimit(uint256 counter) external onlyOwner {
}
/**
* set `publicSalePrice`
*/
function setPublicSalePrice(uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale info
* @param clients clients list
*/
function addClientToWhiteList(uint256 preSaleInfoIndex, address[] calldata clients)
external
onlyOwner
{
}
/**
* @param preSaleInfoIndex index of presale info
* @param clients clients list
*/
function removeClientFromWhiteList(uint256 preSaleInfoIndex, address[] calldata clients)
external
onlyOwner
{
}
/**
* @param preSaleInfoIndex index of presale info
* @param amount amount
**/
function presaleMint(uint256 preSaleInfoIndex, uint256 amount) internal {
}
/**
* @param amount mint amount
* @dev public sale mint
**/
function publicSaleMint(uint256 amount) internal {
}
/**
* @param amount is amount for minting
* access by admin
*/
function clientMint(uint256 amount) external payable {
require(amount > 0, "PNMYS1C1ANC: Mint amount can't be zero");
require(<FILL_ME>)
if(saleStatus == 1) {
publicSaleMint(amount);
} else if(saleStatus == 2) {
require(presaleInfoList.length > 0, "PNMYS1C1ANC: There is not presale list.");
uint256 i;
for(i = 0; i < presaleInfoList.length; i++){
if(whiteList[msg.sender][i].enabled && presaleInfoList[i].enabled){
presaleMint(i, amount);
break;
}
}
require(i < presaleInfoList.length, "PNMYS1C1ANC: You are not added to the matched whitelist.");
} else {
require(false, "PNMYS1C1ANC: Client mint is not live.");
}
emit ClientMint(amount);
}
/**
* @param client airdrop address
* @param tokenIdArray token number address for airdrop
* access by admin
*/
function adminAirdrop(address client, uint256[] calldata tokenIdArray)
external
onlyOwner
{
}
/**
* get total mint number
*/
function getTotalMintNumber() public view returns (uint256) {
}
/**
* get total currency number in this smart contract address
* access admin
*/
function getTotalCurrency() external view onlyOwner returns (uint256) {
}
/**
* @param to money receiver address
* @param value transer amount
* access admin
*/
function withdrawAdmin(address payable to, uint256 value)
external
onlyOwner
{
}
}
| (getTotalMintNumber()+amount)<=maxTotalSupply,"PNMYS1C1ANC: You can't mint that amount of tokens. Exceeds max supply." | 103,916 | (getTotalMintNumber()+amount)<=maxTotalSupply |
"PNMYS1C1ANC: You can't airdrop that amount of tokens. Exceeds max supply." | pragma solidity ^0.8.0;
/*
** 888b d888 .d8888b. Y88b d88P 888 d8b 88888888888 888 d8888 d8b 888
** 8888b d8888 d88P "88b Y88b d88P 888 Y8P 888 888 d88888 Y8P 888
** 88888b.d88888 Y88b. d88P Y88o88P 888 888 888 d88P888 888
** 888Y88888P888 .d88b. 88888b.d88b. .d88b. "Y8888P" Y888P .d88b. 888888 888 888 88888b. .d88b. d88P 888 88888b. .d8888b 888 .d88b. 88888b. 888888 .d8888b
** 888 Y888P 888 d88""88b 888 "888 "88b d88""88b .d88P88K.d88P 888 d8P Y8b 888 888 888 888 "88b d8P Y8b d88P 888 888 "88b d88P" 888 d8P Y8b 888 "88b 888 88K
** 888 Y8P 888 888 888 888 888 888 888 888 888" Y888P" 888 88888888 888 888 888 888 888 88888888 d88P 888 888 888 888 888 88888888 888 888 888 "Y8888b.
** 888 " 888 Y88..88P 888 888 888 Y88..88P Y88b .d8888b 888 Y8b. Y88b. 888 888 888 888 Y8b. d8888888888 888 888 Y88b. 888 Y8b. 888 888 Y88b. X88
** 888 888 "Y88P" 888 888 888 "Y88P" "Y8888P" Y88b 888 "Y8888 "Y888 888 888 888 888 "Y8888 d88P 888 888 888 "Y8888P 888 "Y8888 888 888 "Y888 88888P'
*/
contract PNMYS1C1ANC is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
// NFT Name
string public constant TOKEN_NAME = "Momo & Yeti The Ancients";
// NFT Symbol
string public constant TOKEN_SYMBOL = "PNMYS1C1ANC";
// NFT toke `baseURI`
string public baseURI;
// token counter
Counters.Counter private _tokenIds;
// total NFT number
uint256 public maxTotalSupply;
// total curreny in this contract
uint256 private _totalCurrency;
// total mint nft number in public sale
uint256 public totalMintNumberPublicSale;
// public sale max number
uint256 public publicSaleLimit;
// public sale price
uint256 public publicSalePrice;
// total mint nft number in airdrop
uint256 public totalMintNumberAirDrop;
/**
* 0 disabled
* 1 publicSale
* 2 presale
*/
uint16 public saleStatus;
struct PresaleInfo {
bool enabled; // status in presale
uint256 totalMintedNumber; // presale minted number
uint256 limitPerUser; // limit mint number per user
uint256 maxSpotNumber; // max number of client
uint256 price; // presale price
uint256 whiteCounter; // white counter
}
PresaleInfo[] public presaleInfoList;
struct WhiteInfo {
bool enabled; // white user status
uint256 counter; // nft mint counter
}
// clientAddress => presaleId => flag
mapping(address => mapping(uint256 => WhiteInfo)) public whiteList;
// clientAddress => mint number in public
mapping(address => uint256) public publicSoldList;
// mapping nft number to flag of sold
mapping(uint256 => bool) private _nftSoldList;
/**
* Emitted when `_tokenBaseURI` updated
*/
event BaseURI(string bseURI);
event SetSaleStatus(uint16 status);
event AddPreSaleInfo(bool enabled, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price);
event UpdatePreSaleInfo(uint256 preSaleInfoIndex, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price);
event SetPreSaleStatus(uint256 preSaleInfoIndex, bool status);
event SetPublicSaleLimit(uint256 counter);
event SetPublicSalePrice(uint256 price);
event AddClientToWhiteList(uint256 preSaleInfoIndex, address[] clients);
event RemoveClientFromWhiteList(uint256 preSaleInfoIndex, address[] clients);
event PresaleMint(uint256 preSaleInfoIndex, address indexed client, uint256 amount, uint256 price);
event PublicSaleMint(address indexed client, uint256 amount, uint256 price);
event ClientMint(uint256 amount);
event AdminAirdrop(address indexed client, uint256[] tokensIds);
event WithdrawAdmin(address indexed owner, address indexed to, uint256 amount);
// http://3.211.1.250/api/ancients/
constructor(string memory BASEURI) ERC721(TOKEN_NAME, TOKEN_SYMBOL) {
}
function _baseURI() internal view override returns (string memory) {
}
/**
* set `baseURI`
*/
function setBaseURI(string calldata uri) external onlyOwner {
}
/**
* @param status 0 disable
* @param status 1 publicSale
* @param status 2 presale
*/
function setSaleStatus(uint16 status) external onlyOwner {
}
/**
* @param enabled presale status
* @param limitPerUser limit mint number per user
* @param maxSpotNumber max mint number per presale
* @param price presale price
*/
function addPreSaleInfo(bool enabled, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale list
* @param limitPerUser limit mint number per user
* @param maxSpotNumber max mint number per presale
* @param price presale price
*/
function updatePreSaleInfo(uint256 preSaleInfoIndex, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale list
* @param status presale status
*/
function setPreSaleStatus(uint256 preSaleInfoIndex, bool status) external onlyOwner {
}
/**
* set `publicSaleLimit`
*/
function setPublicSaleLimit(uint256 counter) external onlyOwner {
}
/**
* set `publicSalePrice`
*/
function setPublicSalePrice(uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale info
* @param clients clients list
*/
function addClientToWhiteList(uint256 preSaleInfoIndex, address[] calldata clients)
external
onlyOwner
{
}
/**
* @param preSaleInfoIndex index of presale info
* @param clients clients list
*/
function removeClientFromWhiteList(uint256 preSaleInfoIndex, address[] calldata clients)
external
onlyOwner
{
}
/**
* @param preSaleInfoIndex index of presale info
* @param amount amount
**/
function presaleMint(uint256 preSaleInfoIndex, uint256 amount) internal {
}
/**
* @param amount mint amount
* @dev public sale mint
**/
function publicSaleMint(uint256 amount) internal {
}
/**
* @param amount is amount for minting
* access by admin
*/
function clientMint(uint256 amount) external payable {
}
/**
* @param client airdrop address
* @param tokenIdArray token number address for airdrop
* access by admin
*/
function adminAirdrop(address client, uint256[] calldata tokenIdArray)
external
onlyOwner
{
require(client != address(0), "PNMYS1C1ANC: You can't airdrop to the zero address");
for (uint256 i = 0; i < tokenIdArray.length; i++) {
require(<FILL_ME>)
require(
_nftSoldList[tokenIdArray[i]] == false,
"PNMYS1C1ANC: You can't airdrop token already minted."
);
}
for (uint256 i = 0; i < tokenIdArray.length; i++) {
_nftSoldList[tokenIdArray[i]] = true;
_safeMint(client, tokenIdArray[i]);
}
totalMintNumberAirDrop += tokenIdArray.length;
emit AdminAirdrop(client, tokenIdArray);
}
/**
* get total mint number
*/
function getTotalMintNumber() public view returns (uint256) {
}
/**
* get total currency number in this smart contract address
* access admin
*/
function getTotalCurrency() external view onlyOwner returns (uint256) {
}
/**
* @param to money receiver address
* @param value transer amount
* access admin
*/
function withdrawAdmin(address payable to, uint256 value)
external
onlyOwner
{
}
}
| tokenIdArray[i]<maxTotalSupply,"PNMYS1C1ANC: You can't airdrop that amount of tokens. Exceeds max supply." | 103,916 | tokenIdArray[i]<maxTotalSupply |
"PNMYS1C1ANC: You can't airdrop token already minted." | pragma solidity ^0.8.0;
/*
** 888b d888 .d8888b. Y88b d88P 888 d8b 88888888888 888 d8888 d8b 888
** 8888b d8888 d88P "88b Y88b d88P 888 Y8P 888 888 d88888 Y8P 888
** 88888b.d88888 Y88b. d88P Y88o88P 888 888 888 d88P888 888
** 888Y88888P888 .d88b. 88888b.d88b. .d88b. "Y8888P" Y888P .d88b. 888888 888 888 88888b. .d88b. d88P 888 88888b. .d8888b 888 .d88b. 88888b. 888888 .d8888b
** 888 Y888P 888 d88""88b 888 "888 "88b d88""88b .d88P88K.d88P 888 d8P Y8b 888 888 888 888 "88b d8P Y8b d88P 888 888 "88b d88P" 888 d8P Y8b 888 "88b 888 88K
** 888 Y8P 888 888 888 888 888 888 888 888 888" Y888P" 888 88888888 888 888 888 888 888 88888888 d88P 888 888 888 888 888 88888888 888 888 888 "Y8888b.
** 888 " 888 Y88..88P 888 888 888 Y88..88P Y88b .d8888b 888 Y8b. Y88b. 888 888 888 888 Y8b. d8888888888 888 888 Y88b. 888 Y8b. 888 888 Y88b. X88
** 888 888 "Y88P" 888 888 888 "Y88P" "Y8888P" Y88b 888 "Y8888 "Y888 888 888 888 888 "Y8888 d88P 888 888 888 "Y8888P 888 "Y8888 888 888 "Y888 88888P'
*/
contract PNMYS1C1ANC is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
// NFT Name
string public constant TOKEN_NAME = "Momo & Yeti The Ancients";
// NFT Symbol
string public constant TOKEN_SYMBOL = "PNMYS1C1ANC";
// NFT toke `baseURI`
string public baseURI;
// token counter
Counters.Counter private _tokenIds;
// total NFT number
uint256 public maxTotalSupply;
// total curreny in this contract
uint256 private _totalCurrency;
// total mint nft number in public sale
uint256 public totalMintNumberPublicSale;
// public sale max number
uint256 public publicSaleLimit;
// public sale price
uint256 public publicSalePrice;
// total mint nft number in airdrop
uint256 public totalMintNumberAirDrop;
/**
* 0 disabled
* 1 publicSale
* 2 presale
*/
uint16 public saleStatus;
struct PresaleInfo {
bool enabled; // status in presale
uint256 totalMintedNumber; // presale minted number
uint256 limitPerUser; // limit mint number per user
uint256 maxSpotNumber; // max number of client
uint256 price; // presale price
uint256 whiteCounter; // white counter
}
PresaleInfo[] public presaleInfoList;
struct WhiteInfo {
bool enabled; // white user status
uint256 counter; // nft mint counter
}
// clientAddress => presaleId => flag
mapping(address => mapping(uint256 => WhiteInfo)) public whiteList;
// clientAddress => mint number in public
mapping(address => uint256) public publicSoldList;
// mapping nft number to flag of sold
mapping(uint256 => bool) private _nftSoldList;
/**
* Emitted when `_tokenBaseURI` updated
*/
event BaseURI(string bseURI);
event SetSaleStatus(uint16 status);
event AddPreSaleInfo(bool enabled, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price);
event UpdatePreSaleInfo(uint256 preSaleInfoIndex, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price);
event SetPreSaleStatus(uint256 preSaleInfoIndex, bool status);
event SetPublicSaleLimit(uint256 counter);
event SetPublicSalePrice(uint256 price);
event AddClientToWhiteList(uint256 preSaleInfoIndex, address[] clients);
event RemoveClientFromWhiteList(uint256 preSaleInfoIndex, address[] clients);
event PresaleMint(uint256 preSaleInfoIndex, address indexed client, uint256 amount, uint256 price);
event PublicSaleMint(address indexed client, uint256 amount, uint256 price);
event ClientMint(uint256 amount);
event AdminAirdrop(address indexed client, uint256[] tokensIds);
event WithdrawAdmin(address indexed owner, address indexed to, uint256 amount);
// http://3.211.1.250/api/ancients/
constructor(string memory BASEURI) ERC721(TOKEN_NAME, TOKEN_SYMBOL) {
}
function _baseURI() internal view override returns (string memory) {
}
/**
* set `baseURI`
*/
function setBaseURI(string calldata uri) external onlyOwner {
}
/**
* @param status 0 disable
* @param status 1 publicSale
* @param status 2 presale
*/
function setSaleStatus(uint16 status) external onlyOwner {
}
/**
* @param enabled presale status
* @param limitPerUser limit mint number per user
* @param maxSpotNumber max mint number per presale
* @param price presale price
*/
function addPreSaleInfo(bool enabled, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale list
* @param limitPerUser limit mint number per user
* @param maxSpotNumber max mint number per presale
* @param price presale price
*/
function updatePreSaleInfo(uint256 preSaleInfoIndex, uint256 limitPerUser, uint256 maxSpotNumber, uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale list
* @param status presale status
*/
function setPreSaleStatus(uint256 preSaleInfoIndex, bool status) external onlyOwner {
}
/**
* set `publicSaleLimit`
*/
function setPublicSaleLimit(uint256 counter) external onlyOwner {
}
/**
* set `publicSalePrice`
*/
function setPublicSalePrice(uint256 price) external onlyOwner {
}
/**
* @param preSaleInfoIndex index of presale info
* @param clients clients list
*/
function addClientToWhiteList(uint256 preSaleInfoIndex, address[] calldata clients)
external
onlyOwner
{
}
/**
* @param preSaleInfoIndex index of presale info
* @param clients clients list
*/
function removeClientFromWhiteList(uint256 preSaleInfoIndex, address[] calldata clients)
external
onlyOwner
{
}
/**
* @param preSaleInfoIndex index of presale info
* @param amount amount
**/
function presaleMint(uint256 preSaleInfoIndex, uint256 amount) internal {
}
/**
* @param amount mint amount
* @dev public sale mint
**/
function publicSaleMint(uint256 amount) internal {
}
/**
* @param amount is amount for minting
* access by admin
*/
function clientMint(uint256 amount) external payable {
}
/**
* @param client airdrop address
* @param tokenIdArray token number address for airdrop
* access by admin
*/
function adminAirdrop(address client, uint256[] calldata tokenIdArray)
external
onlyOwner
{
require(client != address(0), "PNMYS1C1ANC: You can't airdrop to the zero address");
for (uint256 i = 0; i < tokenIdArray.length; i++) {
require(
tokenIdArray[i] < maxTotalSupply,
"PNMYS1C1ANC: You can't airdrop that amount of tokens. Exceeds max supply."
);
require(<FILL_ME>)
}
for (uint256 i = 0; i < tokenIdArray.length; i++) {
_nftSoldList[tokenIdArray[i]] = true;
_safeMint(client, tokenIdArray[i]);
}
totalMintNumberAirDrop += tokenIdArray.length;
emit AdminAirdrop(client, tokenIdArray);
}
/**
* get total mint number
*/
function getTotalMintNumber() public view returns (uint256) {
}
/**
* get total currency number in this smart contract address
* access admin
*/
function getTotalCurrency() external view onlyOwner returns (uint256) {
}
/**
* @param to money receiver address
* @param value transer amount
* access admin
*/
function withdrawAdmin(address payable to, uint256 value)
external
onlyOwner
{
}
}
| _nftSoldList[tokenIdArray[i]]==false,"PNMYS1C1ANC: You can't airdrop token already minted." | 103,916 | _nftSoldList[tokenIdArray[i]]==false |
"this is over the max hold amount" | //SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.7;
import "./Interfaces.sol";
import "./BaseErc20Deploy.sol";
contract Bored is BaseErc20 {
uint256 immutable public mhAmount;
constructor () {
}
// Overrides
function configure(address _owner) internal override {
}
function preTransfer(address from, address to, uint256 value) override internal {
if (launched &&
from != deployer && to != deployer &&
exchanges[to] == false &&
to != getRouterAddress()
) {
require(<FILL_ME>)
}
super.preTransfer(from, to, value);
}
function calculateTransferAmount(address from, address to, uint256 value) override internal returns (uint256) {
}
}
| _balances[to]+value<=mhAmount,"this is over the max hold amount" | 104,060 | _balances[to]+value<=mhAmount |
"NONCE_ALREADY_USED" | // SPDX-License-Identifier: MIT
// Source: https://github.com/airswap/airswap-protocols/blob/main/source/swap/contracts/Swap.sol
pragma solidity =0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../interfaces/ISwap.sol";
import {IERC20Detailed} from "../interfaces/IERC20Detailed.sol";
contract Swap is ISwap, ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
bytes32 public constant DOMAIN_TYPEHASH =
keccak256(
abi.encodePacked(
"EIP712Domain(",
"string name,",
"string version,",
"uint256 chainId,",
"address verifyingContract",
")"
)
);
bytes32 public constant BID_TYPEHASH =
keccak256(
abi.encodePacked(
"Bid(",
"uint256 swapId,",
"uint256 nonce,",
"address signerWallet,",
"uint256 sellAmount,",
"uint256 buyAmount,",
"address referrer",
")"
)
);
bytes32 public constant DOMAIN_NAME = keccak256("RIBBON SWAP");
bytes32 public constant DOMAIN_VERSION = keccak256("1");
uint256 public immutable DOMAIN_CHAIN_ID;
bytes32 public immutable DOMAIN_SEPARATOR;
uint256 internal constant MAX_PERCENTAGE = 10000;
uint256 internal constant MAX_FEE = 1000;
uint256 internal constant MAX_ERROR_COUNT = 10;
uint256 internal constant OTOKEN_DECIMALS = 8;
uint256 public offersCounter = 0;
mapping(uint256 => Offer) public swapOffers;
mapping(address => uint256) public referralFees;
/**
* @notice Double mapping of signers to nonce groups to nonce states
* @dev The nonce group is computed as nonce / 256, so each group of 256 sequential nonces uses the same key
* @dev The nonce states are encoded as 256 bits, for each nonce in the group 0 means available and 1 means used
*/
mapping(address => mapping(uint256 => uint256)) internal _nonceGroups;
/************************************************
* CONSTRUCTOR
***********************************************/
constructor() {
}
/************************************************
* SETTER
***********************************************/
/**
* @notice Sets the referral fee for a specific referrer
* @param referrer is the address of the referrer
* @param fee is the fee in percent in 2 decimals
*/
function setFee(address referrer, uint256 fee) external onlyOwner {
}
/************************************************
* OFFER CREATION AND SETTLEMENT
***********************************************/
/**
* @notice Create a new offer available for swap
* @param oToken token offered by seller
* @param biddingToken token asked by seller
* @param minPrice minimum price of oToken denominated in biddingToken
* @param minBidSize minimum amount of oToken requested in a single bid
* @param totalSize amount of oToken offered by seller
*/
function createOffer(
address oToken,
address biddingToken,
uint96 minPrice,
uint96 minBidSize,
uint128 totalSize
) external override returns (uint256 swapId) {
}
/**
* @notice Settles the swap offering by iterating through the bids
* @param swapId unique identifier of the swap offer
* @param bids bids for swaps
*/
function settleOffer(uint256 swapId, Bid[] calldata bids)
external
override
nonReentrant
{
}
/**
* @notice Cancel one or more nonces
* @dev Cancelled nonces are marked as used
* @dev Emits a Cancel event
* @dev Out of gas may occur in arrays of length > 400
* @param nonces uint256[] List of nonces to cancel
*/
function cancelNonce(uint256[] calldata nonces) external override {
}
/************************************************
* PUBLIC VIEW FUNCTIONS
***********************************************/
/**
* @notice Validates Swap bid for any potential errors
* @param bid Bid struct containing bid details
* @return tuple of error count and bytes32[] memory array of error messages
*/
function check(Bid calldata bid)
external
view
override
returns (uint256, bytes32[] memory)
{
}
/**
* @notice Returns the average settlement price for a swap offer
* @param swapId unique identifier of the swap offer
*/
function averagePriceForOffer(uint256 swapId)
external
view
override
returns (uint256)
{
}
/**
* @notice Returns true if the nonce has been used
* @param signer address Address of the signer
* @param nonce uint256 Nonce being checked
*/
function nonceUsed(address signer, uint256 nonce)
public
view
override
returns (bool)
{
}
/************************************************
* INTERNAL FUNCTIONS
***********************************************/
/**
* @notice Swap Atomic ERC20 Swap
* @param details Details of offering
* @param offer Offer struct containing offer details
* @param bid Bid struct containing bid details
*/
function _swap(
OfferDetails memory details,
Offer storage offer,
Bid calldata bid
) internal {
require(DOMAIN_CHAIN_ID == getChainId(), "CHAIN_ID_CHANGED");
address signatory = _getSignatory(bid);
require(signatory != address(0), "SIGNATURE_INVALID");
require(signatory == bid.signerWallet, "SIGNATURE_MISMATCHED");
require(<FILL_ME>)
require(
bid.buyAmount <= offer.availableSize,
"BID_EXCEED_AVAILABLE_SIZE"
);
require(bid.buyAmount >= details.minBidSize, "BID_TOO_SMALL");
// Ensure min. price is met
uint256 bidPrice =
(bid.sellAmount * 10**OTOKEN_DECIMALS) / bid.buyAmount;
require(bidPrice >= details.minPrice, "PRICE_TOO_LOW");
// don't have to do a uint128 check because we already check
// that bid.buyAmount <= offer.availableSize
offer.availableSize -= uint128(bid.buyAmount);
// Transfer token from sender to signer
IERC20(details.oToken).safeTransferFrom(
details.seller,
bid.signerWallet,
bid.buyAmount
);
// Transfer to referrer if any
uint256 feeAmount;
if (bid.referrer != address(0)) {
uint256 feePercent = referralFees[bid.referrer];
if (feePercent > 0) {
feeAmount = (bid.sellAmount * feePercent) / MAX_PERCENTAGE;
IERC20(details.biddingToken).safeTransferFrom(
bid.signerWallet,
bid.referrer,
feeAmount
);
}
}
// Transfer token from signer to recipient
IERC20(details.biddingToken).safeTransferFrom(
bid.signerWallet,
details.seller,
bid.sellAmount - feeAmount
);
// Emit a Swap event
emit Swap(
bid.swapId,
bid.nonce,
bid.signerWallet,
bid.sellAmount,
bid.buyAmount,
bid.referrer,
feeAmount
);
}
/**
* @notice Marks a nonce as used for the given signer
* @param signer address Address of the signer for which to mark the nonce as used
* @param nonce uint256 Nonce to be marked as used
* @return bool True if the nonce was not marked as used already
*/
function _markNonceAsUsed(address signer, uint256 nonce)
internal
returns (bool)
{
}
/**
* @notice Recover the signatory from a signature
* @param bid Bid struct containing bid details
*/
function _getSignatory(Bid calldata bid) internal view returns (address) {
}
/**
* @notice Returns the current chainId using the chainid opcode
* @return id uint256 The chain id
*/
function getChainId() internal view returns (uint256 id) {
}
}
| _markNonceAsUsed(signatory,bid.nonce),"NONCE_ALREADY_USED" | 104,158 | _markNonceAsUsed(signatory,bid.nonce) |
"LibDiamond: Must be contract owner" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
/******************************************************************************\
* Author: Nick Mudge <[email protected]> (https://twitter.com/mudgen)
* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535
/******************************************************************************/
import {IDiamondCut} from "../interfaces/IDiamondCut.sol";
import {IDiamondLoupe} from "../interfaces/IDiamondLoupe.sol";
import {IERC165} from "../interfaces/IERC165.sol";
import {IERC173} from "../interfaces/IERC173.sol";
import {LibMeta} from "./LibMeta.sol";
library LibDiamond {
bytes32 constant DIAMOND_STORAGE_POSITION =
keccak256("diamond.standard.diamond.storage");
struct FacetAddressAndPosition {
address facetAddress;
uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array
}
struct FacetFunctionSelectors {
bytes4[] functionSelectors;
uint16 facetAddressPosition; // position of facetAddress in facetAddresses array
}
struct DiamondStorage {
// maps function selector to the facet address and
// the position of the selector in the facetFunctionSelectors.selectors array
mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;
// maps facet addresses to function selectors
mapping(address => FacetFunctionSelectors) facetFunctionSelectors;
// facet addresses
address[] facetAddresses;
// Used to query if a contract implements an interface.
// Used to implement ERC-165.
mapping(bytes4 => bool) supportedInterfaces;
// owner of the contract
address contractOwner;
}
function diamondStorage()
internal
pure
returns (DiamondStorage storage ds)
{
}
event OwnershipTransferredDiamond(
address indexed previousOwner,
address indexed newOwner
);
function setContractOwner(address _newOwner) internal {
}
function contractOwner() internal view returns (address contractOwner_) {
}
function enforceIsContractOwner() internal view {
require(<FILL_ME>)
}
event DiamondCut(
IDiamondCut.FacetCut[] _diamondCut,
address _init,
bytes _calldata
);
function addDiamondFunctions(
address _diamondCutFacet,
address _diamondLoupeFacet,
address _ownershipFacet
) internal {
}
// Internal function version of diamondCut
function diamondCut(
IDiamondCut.FacetCut[] memory _diamondCut,
address _init,
bytes memory _calldata
) internal {
}
function addFunctions(
address _facetAddress,
bytes4[] memory _functionSelectors
) internal {
}
function replaceFunctions(
address _facetAddress,
bytes4[] memory _functionSelectors
) internal {
}
function removeFunctions(
address _facetAddress,
bytes4[] memory _functionSelectors
) internal {
}
function removeFunction(address _facetAddress, bytes4 _selector) internal {
}
function initializeDiamondCut(
address _init,
bytes memory _calldata
) internal {
}
function enforceHasContractCode(
address _contract,
string memory _errorMessage
) internal view {
}
}
| LibMeta._msgSender()==diamondStorage().contractOwner,"LibDiamond: Must be contract owner" | 104,213 | LibMeta._msgSender()==diamondStorage().contractOwner |
"Transfer failed, blacklisted wallet." | /**
G̸҉̜̜̱̄ͩ͆͜͝͞o҉̢̡̲͇̌͗̀͢͝o҉̢̡̲͇̌͗̀͢͝d҉̴̷̧̢̛̖͔̤ͯ̔̑̄͢͟͡͠ N̵҉̾͟͞͡i҉̧̯̤̙͔̑ͧ̅̔ͦ́͜͟͢͝͠g̷̵̸̡̼̱͎͎̞ͤͬ̅͢͟͞h̷̶̘̘̬ͭ̏͞͡t҉̷҉̢͖͔̹͛̌͊͘͜͢͠͡͡ C҉͓̟͇̼͕̻ͭ͌ͩ̒͘͜͡͞͠l̶҉̰͚͖͕̍̈́̅͗̏̇͢͜͜͝a҉͖̟̜̞̂̃̑̽͢͢͠͡s҉̝̭̦͚̑ͯ̌͡s҉̝̭̦͚̑ͯ̌͡i҉̧̯̤̙͔̑ͧ̅̔ͦ́͜͟͢͝͠c̷̶҉̵̢͚̣̻̲̬͑̑͛͐̀͜͜͜͝͡͝͠
*/
pragma solidity ^0.8.10;
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 {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract GNC is Context, IERC20, Ownable { ////
mapping (address => uint) private _owned;
mapping (address => mapping (address => uint)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => User) private cooldown;
mapping (address => bool) private _isBot;
uint private constant _totalSupply = 1e12 * 10**9;
string public constant name = unicode"Good Night Classic"; ////
string public constant symbol = unicode"GNC"; ////
uint8 public constant decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address payable public _FeeAddress1;
address payable public _FeeAddress2;
address public uniswapV2Pair;
uint public _buyFee = 0;
uint public _sellFee = 5;
uint public _feeRate = 9;
uint public _maxTradeAmount;
uint public _maxWalletHoldings;
uint public _launchedAt;
bool private _tradingOpen;
bool private _inSwap;
bool public _useImpactFeeSetter = true;
struct User {
uint buy;
bool exists;
}
event FeeMultiplierUpdated(uint _multiplier);
event ImpactFeeSetterUpdated(bool _usefeesetter);
event FeeRateUpdated(uint _rate);
event FeesUpdated(uint _buy, uint _sell);
event FeeAddress1Updated(address _feewallet1);
event FeeAddress2Updated(address _feewallet2);
modifier lockTheSwap {
}
constructor (address payable FeeAddress1, address payable FeeAddress2) {
}
function balanceOf(address account) public view override returns (uint) {
}
function transfer(address recipient, uint amount) public override returns (bool) {
}
function totalSupply() public pure override returns (uint) {
}
function allowance(address owner, address spender) public view override returns (uint) {
}
function approve(address spender, uint amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint amount) private {
}
function _transfer(address from, address to, uint amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(<FILL_ME>)
bool isBuy = false;
if(from != owner() && to != owner()) {
// buy
if(from == uniswapV2Pair && to != address(uniswapV2Router) && !_isExcludedFromFee[to]) {
require(_tradingOpen, "Trading not yet enabled.");
require(block.timestamp != _launchedAt, "pls no snip");
if((_launchedAt + (24 hours)) > block.timestamp) {
require((amount + balanceOf(address(to))) <= _maxWalletHoldings, "You can't own that many tokens at once."); // 5%
}
if(!cooldown[to].exists) {
cooldown[to] = User(0,true);
}
if((_launchedAt + (120 seconds)) > block.timestamp) {
require(amount <= _maxTradeAmount, "Exceeds maximum buy amount.");
require(cooldown[to].buy < block.timestamp + (15 seconds), "Your buy cooldown has not expired.");
}
cooldown[to].buy = block.timestamp;
isBuy = true;
}
// sell
if(!_inSwap && _tradingOpen && from != uniswapV2Pair) {
require(cooldown[from].buy < block.timestamp + (15 seconds), "Your sell cooldown has not expired.");
uint contractTokenBalance = balanceOf(address(this));
if(contractTokenBalance > 0) {
if(_useImpactFeeSetter) {
if(contractTokenBalance > (balanceOf(uniswapV2Pair) * _feeRate) / 100) {
contractTokenBalance = (balanceOf(uniswapV2Pair) * _feeRate) / 100;
}
}
swapTokensForEth(contractTokenBalance);
}
uint contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
isBuy = false;
}
}
bool takeFee = true;
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
_tokenTransfer(from,to,amount,takeFee,isBuy);
}
function swapTokensForEth(uint tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint amount) private {
}
function _tokenTransfer(address sender, address recipient, uint amount, bool takefee, bool buy) private {
}
function _getFee(bool takefee, bool buy) private view returns (uint) {
}
function _transferStandard(address sender, address recipient, uint amount, uint fee) private {
}
function _getValues(uint amount, uint teamFee) private pure returns (uint, uint) {
}
function _takeTeam(uint team) private {
}
receive() external payable {}
// external functions
function addLiquidity() external onlyOwner() {
}
function openTrading() external onlyOwner() {
}
function manualswap() external {
}
function manualsend() external {
}
function setFeeRate(uint rate) external {
}
function setFees(uint buy, uint sell) external {
}
function isBot(address ad) public view returns (bool) {
}
function toggleImpactFee(bool onoff) external onlyOwner() {
}
function updateFeeAddress1(address newAddress) external {
}
function setBot(address botwallet) external {
}
function delBot(address botwallet) external {
}
function updateFeeAddress2(address newAddress) external {
}
// view functions
function thisBalance() public view returns (uint) {
}
function amountInPool() public view returns (uint) {
}
}
| !_isBot[to],"Transfer failed, blacklisted wallet." | 104,270 | !_isBot[to] |
"You can't own that many tokens at once." | /**
G̸҉̜̜̱̄ͩ͆͜͝͞o҉̢̡̲͇̌͗̀͢͝o҉̢̡̲͇̌͗̀͢͝d҉̴̷̧̢̛̖͔̤ͯ̔̑̄͢͟͡͠ N̵҉̾͟͞͡i҉̧̯̤̙͔̑ͧ̅̔ͦ́͜͟͢͝͠g̷̵̸̡̼̱͎͎̞ͤͬ̅͢͟͞h̷̶̘̘̬ͭ̏͞͡t҉̷҉̢͖͔̹͛̌͊͘͜͢͠͡͡ C҉͓̟͇̼͕̻ͭ͌ͩ̒͘͜͡͞͠l̶҉̰͚͖͕̍̈́̅͗̏̇͢͜͜͝a҉͖̟̜̞̂̃̑̽͢͢͠͡s҉̝̭̦͚̑ͯ̌͡s҉̝̭̦͚̑ͯ̌͡i҉̧̯̤̙͔̑ͧ̅̔ͦ́͜͟͢͝͠c̷̶҉̵̢͚̣̻̲̬͑̑͛͐̀͜͜͜͝͡͝͠
*/
pragma solidity ^0.8.10;
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 {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract GNC is Context, IERC20, Ownable { ////
mapping (address => uint) private _owned;
mapping (address => mapping (address => uint)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => User) private cooldown;
mapping (address => bool) private _isBot;
uint private constant _totalSupply = 1e12 * 10**9;
string public constant name = unicode"Good Night Classic"; ////
string public constant symbol = unicode"GNC"; ////
uint8 public constant decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address payable public _FeeAddress1;
address payable public _FeeAddress2;
address public uniswapV2Pair;
uint public _buyFee = 0;
uint public _sellFee = 5;
uint public _feeRate = 9;
uint public _maxTradeAmount;
uint public _maxWalletHoldings;
uint public _launchedAt;
bool private _tradingOpen;
bool private _inSwap;
bool public _useImpactFeeSetter = true;
struct User {
uint buy;
bool exists;
}
event FeeMultiplierUpdated(uint _multiplier);
event ImpactFeeSetterUpdated(bool _usefeesetter);
event FeeRateUpdated(uint _rate);
event FeesUpdated(uint _buy, uint _sell);
event FeeAddress1Updated(address _feewallet1);
event FeeAddress2Updated(address _feewallet2);
modifier lockTheSwap {
}
constructor (address payable FeeAddress1, address payable FeeAddress2) {
}
function balanceOf(address account) public view override returns (uint) {
}
function transfer(address recipient, uint amount) public override returns (bool) {
}
function totalSupply() public pure override returns (uint) {
}
function allowance(address owner, address spender) public view override returns (uint) {
}
function approve(address spender, uint amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint amount) private {
}
function _transfer(address from, address to, uint amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!_isBot[to], "Transfer failed, blacklisted wallet.");
bool isBuy = false;
if(from != owner() && to != owner()) {
// buy
if(from == uniswapV2Pair && to != address(uniswapV2Router) && !_isExcludedFromFee[to]) {
require(_tradingOpen, "Trading not yet enabled.");
require(block.timestamp != _launchedAt, "pls no snip");
if((_launchedAt + (24 hours)) > block.timestamp) {
require(<FILL_ME>) // 5%
}
if(!cooldown[to].exists) {
cooldown[to] = User(0,true);
}
if((_launchedAt + (120 seconds)) > block.timestamp) {
require(amount <= _maxTradeAmount, "Exceeds maximum buy amount.");
require(cooldown[to].buy < block.timestamp + (15 seconds), "Your buy cooldown has not expired.");
}
cooldown[to].buy = block.timestamp;
isBuy = true;
}
// sell
if(!_inSwap && _tradingOpen && from != uniswapV2Pair) {
require(cooldown[from].buy < block.timestamp + (15 seconds), "Your sell cooldown has not expired.");
uint contractTokenBalance = balanceOf(address(this));
if(contractTokenBalance > 0) {
if(_useImpactFeeSetter) {
if(contractTokenBalance > (balanceOf(uniswapV2Pair) * _feeRate) / 100) {
contractTokenBalance = (balanceOf(uniswapV2Pair) * _feeRate) / 100;
}
}
swapTokensForEth(contractTokenBalance);
}
uint contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
isBuy = false;
}
}
bool takeFee = true;
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
_tokenTransfer(from,to,amount,takeFee,isBuy);
}
function swapTokensForEth(uint tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint amount) private {
}
function _tokenTransfer(address sender, address recipient, uint amount, bool takefee, bool buy) private {
}
function _getFee(bool takefee, bool buy) private view returns (uint) {
}
function _transferStandard(address sender, address recipient, uint amount, uint fee) private {
}
function _getValues(uint amount, uint teamFee) private pure returns (uint, uint) {
}
function _takeTeam(uint team) private {
}
receive() external payable {}
// external functions
function addLiquidity() external onlyOwner() {
}
function openTrading() external onlyOwner() {
}
function manualswap() external {
}
function manualsend() external {
}
function setFeeRate(uint rate) external {
}
function setFees(uint buy, uint sell) external {
}
function isBot(address ad) public view returns (bool) {
}
function toggleImpactFee(bool onoff) external onlyOwner() {
}
function updateFeeAddress1(address newAddress) external {
}
function setBot(address botwallet) external {
}
function delBot(address botwallet) external {
}
function updateFeeAddress2(address newAddress) external {
}
// view functions
function thisBalance() public view returns (uint) {
}
function amountInPool() public view returns (uint) {
}
}
| (amount+balanceOf(address(to)))<=_maxWalletHoldings,"You can't own that many tokens at once." | 104,270 | (amount+balanceOf(address(to)))<=_maxWalletHoldings |
"Your buy cooldown has not expired." | /**
G̸҉̜̜̱̄ͩ͆͜͝͞o҉̢̡̲͇̌͗̀͢͝o҉̢̡̲͇̌͗̀͢͝d҉̴̷̧̢̛̖͔̤ͯ̔̑̄͢͟͡͠ N̵҉̾͟͞͡i҉̧̯̤̙͔̑ͧ̅̔ͦ́͜͟͢͝͠g̷̵̸̡̼̱͎͎̞ͤͬ̅͢͟͞h̷̶̘̘̬ͭ̏͞͡t҉̷҉̢͖͔̹͛̌͊͘͜͢͠͡͡ C҉͓̟͇̼͕̻ͭ͌ͩ̒͘͜͡͞͠l̶҉̰͚͖͕̍̈́̅͗̏̇͢͜͜͝a҉͖̟̜̞̂̃̑̽͢͢͠͡s҉̝̭̦͚̑ͯ̌͡s҉̝̭̦͚̑ͯ̌͡i҉̧̯̤̙͔̑ͧ̅̔ͦ́͜͟͢͝͠c̷̶҉̵̢͚̣̻̲̬͑̑͛͐̀͜͜͜͝͡͝͠
*/
pragma solidity ^0.8.10;
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 {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract GNC is Context, IERC20, Ownable { ////
mapping (address => uint) private _owned;
mapping (address => mapping (address => uint)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => User) private cooldown;
mapping (address => bool) private _isBot;
uint private constant _totalSupply = 1e12 * 10**9;
string public constant name = unicode"Good Night Classic"; ////
string public constant symbol = unicode"GNC"; ////
uint8 public constant decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address payable public _FeeAddress1;
address payable public _FeeAddress2;
address public uniswapV2Pair;
uint public _buyFee = 0;
uint public _sellFee = 5;
uint public _feeRate = 9;
uint public _maxTradeAmount;
uint public _maxWalletHoldings;
uint public _launchedAt;
bool private _tradingOpen;
bool private _inSwap;
bool public _useImpactFeeSetter = true;
struct User {
uint buy;
bool exists;
}
event FeeMultiplierUpdated(uint _multiplier);
event ImpactFeeSetterUpdated(bool _usefeesetter);
event FeeRateUpdated(uint _rate);
event FeesUpdated(uint _buy, uint _sell);
event FeeAddress1Updated(address _feewallet1);
event FeeAddress2Updated(address _feewallet2);
modifier lockTheSwap {
}
constructor (address payable FeeAddress1, address payable FeeAddress2) {
}
function balanceOf(address account) public view override returns (uint) {
}
function transfer(address recipient, uint amount) public override returns (bool) {
}
function totalSupply() public pure override returns (uint) {
}
function allowance(address owner, address spender) public view override returns (uint) {
}
function approve(address spender, uint amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint amount) private {
}
function _transfer(address from, address to, uint amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!_isBot[to], "Transfer failed, blacklisted wallet.");
bool isBuy = false;
if(from != owner() && to != owner()) {
// buy
if(from == uniswapV2Pair && to != address(uniswapV2Router) && !_isExcludedFromFee[to]) {
require(_tradingOpen, "Trading not yet enabled.");
require(block.timestamp != _launchedAt, "pls no snip");
if((_launchedAt + (24 hours)) > block.timestamp) {
require((amount + balanceOf(address(to))) <= _maxWalletHoldings, "You can't own that many tokens at once."); // 5%
}
if(!cooldown[to].exists) {
cooldown[to] = User(0,true);
}
if((_launchedAt + (120 seconds)) > block.timestamp) {
require(amount <= _maxTradeAmount, "Exceeds maximum buy amount.");
require(<FILL_ME>)
}
cooldown[to].buy = block.timestamp;
isBuy = true;
}
// sell
if(!_inSwap && _tradingOpen && from != uniswapV2Pair) {
require(cooldown[from].buy < block.timestamp + (15 seconds), "Your sell cooldown has not expired.");
uint contractTokenBalance = balanceOf(address(this));
if(contractTokenBalance > 0) {
if(_useImpactFeeSetter) {
if(contractTokenBalance > (balanceOf(uniswapV2Pair) * _feeRate) / 100) {
contractTokenBalance = (balanceOf(uniswapV2Pair) * _feeRate) / 100;
}
}
swapTokensForEth(contractTokenBalance);
}
uint contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
isBuy = false;
}
}
bool takeFee = true;
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
_tokenTransfer(from,to,amount,takeFee,isBuy);
}
function swapTokensForEth(uint tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint amount) private {
}
function _tokenTransfer(address sender, address recipient, uint amount, bool takefee, bool buy) private {
}
function _getFee(bool takefee, bool buy) private view returns (uint) {
}
function _transferStandard(address sender, address recipient, uint amount, uint fee) private {
}
function _getValues(uint amount, uint teamFee) private pure returns (uint, uint) {
}
function _takeTeam(uint team) private {
}
receive() external payable {}
// external functions
function addLiquidity() external onlyOwner() {
}
function openTrading() external onlyOwner() {
}
function manualswap() external {
}
function manualsend() external {
}
function setFeeRate(uint rate) external {
}
function setFees(uint buy, uint sell) external {
}
function isBot(address ad) public view returns (bool) {
}
function toggleImpactFee(bool onoff) external onlyOwner() {
}
function updateFeeAddress1(address newAddress) external {
}
function setBot(address botwallet) external {
}
function delBot(address botwallet) external {
}
function updateFeeAddress2(address newAddress) external {
}
// view functions
function thisBalance() public view returns (uint) {
}
function amountInPool() public view returns (uint) {
}
}
| cooldown[to].buy<block.timestamp+(15seconds),"Your buy cooldown has not expired." | 104,270 | cooldown[to].buy<block.timestamp+(15seconds) |
null | /**
G̸҉̜̜̱̄ͩ͆͜͝͞o҉̢̡̲͇̌͗̀͢͝o҉̢̡̲͇̌͗̀͢͝d҉̴̷̧̢̛̖͔̤ͯ̔̑̄͢͟͡͠ N̵҉̾͟͞͡i҉̧̯̤̙͔̑ͧ̅̔ͦ́͜͟͢͝͠g̷̵̸̡̼̱͎͎̞ͤͬ̅͢͟͞h̷̶̘̘̬ͭ̏͞͡t҉̷҉̢͖͔̹͛̌͊͘͜͢͠͡͡ C҉͓̟͇̼͕̻ͭ͌ͩ̒͘͜͡͞͠l̶҉̰͚͖͕̍̈́̅͗̏̇͢͜͜͝a҉͖̟̜̞̂̃̑̽͢͢͠͡s҉̝̭̦͚̑ͯ̌͡s҉̝̭̦͚̑ͯ̌͡i҉̧̯̤̙͔̑ͧ̅̔ͦ́͜͟͢͝͠c̷̶҉̵̢͚̣̻̲̬͑̑͛͐̀͜͜͜͝͡͝͠
*/
pragma solidity ^0.8.10;
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 {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract GNC is Context, IERC20, Ownable { ////
mapping (address => uint) private _owned;
mapping (address => mapping (address => uint)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => User) private cooldown;
mapping (address => bool) private _isBot;
uint private constant _totalSupply = 1e12 * 10**9;
string public constant name = unicode"Good Night Classic"; ////
string public constant symbol = unicode"GNC"; ////
uint8 public constant decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address payable public _FeeAddress1;
address payable public _FeeAddress2;
address public uniswapV2Pair;
uint public _buyFee = 0;
uint public _sellFee = 5;
uint public _feeRate = 9;
uint public _maxTradeAmount;
uint public _maxWalletHoldings;
uint public _launchedAt;
bool private _tradingOpen;
bool private _inSwap;
bool public _useImpactFeeSetter = true;
struct User {
uint buy;
bool exists;
}
event FeeMultiplierUpdated(uint _multiplier);
event ImpactFeeSetterUpdated(bool _usefeesetter);
event FeeRateUpdated(uint _rate);
event FeesUpdated(uint _buy, uint _sell);
event FeeAddress1Updated(address _feewallet1);
event FeeAddress2Updated(address _feewallet2);
modifier lockTheSwap {
}
constructor (address payable FeeAddress1, address payable FeeAddress2) {
}
function balanceOf(address account) public view override returns (uint) {
}
function transfer(address recipient, uint amount) public override returns (bool) {
}
function totalSupply() public pure override returns (uint) {
}
function allowance(address owner, address spender) public view override returns (uint) {
}
function approve(address spender, uint amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint amount) private {
}
function _transfer(address from, address to, uint amount) private {
}
function swapTokensForEth(uint tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint amount) private {
}
function _tokenTransfer(address sender, address recipient, uint amount, bool takefee, bool buy) private {
}
function _getFee(bool takefee, bool buy) private view returns (uint) {
}
function _transferStandard(address sender, address recipient, uint amount, uint fee) private {
}
function _getValues(uint amount, uint teamFee) private pure returns (uint, uint) {
}
function _takeTeam(uint team) private {
}
receive() external payable {}
// external functions
function addLiquidity() external onlyOwner() {
}
function openTrading() external onlyOwner() {
}
function manualswap() external {
}
function manualsend() external {
}
function setFeeRate(uint rate) external {
}
function setFees(uint buy, uint sell) external {
}
function isBot(address ad) public view returns (bool) {
}
function toggleImpactFee(bool onoff) external onlyOwner() {
}
function updateFeeAddress1(address newAddress) external {
}
function setBot(address botwallet) external {
}
function delBot(address botwallet) external {
}
function updateFeeAddress2(address newAddress) external {
require(<FILL_ME>)
_FeeAddress2 = payable(newAddress);
emit FeeAddress2Updated(_FeeAddress2);
}
// view functions
function thisBalance() public view returns (uint) {
}
function amountInPool() public view returns (uint) {
}
}
| _msgSender()==_FeeAddress2 | 104,270 | _msgSender()==_FeeAddress2 |
"LifestoryVesting: maximal vesting already set" | pragma solidity ^0.8.0;
// @author: Abderrahmane Bouali for Lifestory
/**
* @title Lifestory Vesting
* Lifestory Vesting contract
*/
contract LifestoryVesting is Ownable, ReentrancyGuard {
using SafeMath for uint256;
// LifeCoin contract
ILifeCoin private immutable lifeCoin;
struct Beneficiary {
uint256 cliff;
uint256 vesting;
uint256 amountTotal;
uint256 released;
uint256 firstBenefit;
}
//1000000000 is the max quantity of LIFC mint (10**18 is the decimal)
uint256 public constant MAX_RELEASED = 1000000000 * 10**18;
// number of LIFC to be released
uint256 public totalToRelease;
// immutable var to define one day in timestamp
uint256 public immutable dayTime;
// immutable to define the start time of the vesting
uint256 public immutable startedTime;
/**
* @dev constructor of LifestoryVesting
* @param _lifeCoinAddress address of ERC20 contract of LIFC (LifeCoin)
* @param _nbSecInDay define one day in seconds (timestamp)
*/
constructor(address _lifeCoinAddress, uint256 _nbSecInDay) {
}
// Mapping from beneficiary address to Beneficiary structure
mapping(address => Beneficiary) private beneficiaries;
/**
* @dev Emitted when `beneficiary` release `amount`
*/
event Released(address beneficiary, uint256 amount);
/**
* @dev onlyOwner function to create a new beneficiary for a vesting.
* @notice the distribution of tokens is implemented as stated in the whitepaper
* @param _beneficiary address of the beneficiary to whom vested tokens are transferred
* @param _amount total amount of tokens to be released at the end of the vesting
* @param _firstBenefit amount of tokens released at the begin of the vesting
* @param _cliff_day duration in days of the cliff after which tokens will begin to vest
* @param _vesting_day duration in days of the period in which the tokens will vest
*/
function createBeneficiary(
address _beneficiary,
uint256 _amount,
uint256 _firstBenefit,
uint256 _cliff_day,
uint256 _vesting_day
) public onlyOwner {
require(<FILL_ME>)
require(
_firstBenefit <= _amount,
"LifestoryVesting: firstBenefit higher from amount"
);
require(
beneficiaries[_beneficiary].amountTotal < 1,
"LifestoryVesting: already a beneficiary"
);
require(_vesting_day > 0, "LifestoryVesting: duration must be > 0 days");
require(_amount > 0, "LifestoryVesting: amount must be > 0");
beneficiaries[_beneficiary] = Beneficiary(
_cliff_day.mul(dayTime),
_vesting_day.mul(dayTime),
_amount,
0,
_firstBenefit
);
totalToRelease = totalToRelease.add(_amount);
}
/**
* @dev view function to get Beneficiary structure
* @param _beneficiary address of beneficiary
*/
function getBeneficiary(address _beneficiary)
public
view
returns (Beneficiary memory)
{
}
/**
* @dev view function to see number of LifeCoin can release at `_currentTime`
* @param _beneficiary address of beneficiary
* @param _currentTime time in timestamp
*/
function getAmountReleasable(address _beneficiary, uint256 _currentTime)
public
view
returns (uint256)
{
}
/**
* @dev public function to release `_amount` of LifeCoin
* @dev this function can only be called by beneficiary
* @dev this function checks if your `_amount` is less or equal
* then the maximum amount you can release at the current time
* @param _amount the amount to release
*/
function release(uint256 _amount)
public
nonReentrant
{
}
}
| totalToRelease.add(_amount)<=MAX_RELEASED,"LifestoryVesting: maximal vesting already set" | 104,343 | totalToRelease.add(_amount)<=MAX_RELEASED |
"LifestoryVesting: already a beneficiary" | pragma solidity ^0.8.0;
// @author: Abderrahmane Bouali for Lifestory
/**
* @title Lifestory Vesting
* Lifestory Vesting contract
*/
contract LifestoryVesting is Ownable, ReentrancyGuard {
using SafeMath for uint256;
// LifeCoin contract
ILifeCoin private immutable lifeCoin;
struct Beneficiary {
uint256 cliff;
uint256 vesting;
uint256 amountTotal;
uint256 released;
uint256 firstBenefit;
}
//1000000000 is the max quantity of LIFC mint (10**18 is the decimal)
uint256 public constant MAX_RELEASED = 1000000000 * 10**18;
// number of LIFC to be released
uint256 public totalToRelease;
// immutable var to define one day in timestamp
uint256 public immutable dayTime;
// immutable to define the start time of the vesting
uint256 public immutable startedTime;
/**
* @dev constructor of LifestoryVesting
* @param _lifeCoinAddress address of ERC20 contract of LIFC (LifeCoin)
* @param _nbSecInDay define one day in seconds (timestamp)
*/
constructor(address _lifeCoinAddress, uint256 _nbSecInDay) {
}
// Mapping from beneficiary address to Beneficiary structure
mapping(address => Beneficiary) private beneficiaries;
/**
* @dev Emitted when `beneficiary` release `amount`
*/
event Released(address beneficiary, uint256 amount);
/**
* @dev onlyOwner function to create a new beneficiary for a vesting.
* @notice the distribution of tokens is implemented as stated in the whitepaper
* @param _beneficiary address of the beneficiary to whom vested tokens are transferred
* @param _amount total amount of tokens to be released at the end of the vesting
* @param _firstBenefit amount of tokens released at the begin of the vesting
* @param _cliff_day duration in days of the cliff after which tokens will begin to vest
* @param _vesting_day duration in days of the period in which the tokens will vest
*/
function createBeneficiary(
address _beneficiary,
uint256 _amount,
uint256 _firstBenefit,
uint256 _cliff_day,
uint256 _vesting_day
) public onlyOwner {
require(
totalToRelease.add(_amount) <= MAX_RELEASED,
"LifestoryVesting: maximal vesting already set"
);
require(
_firstBenefit <= _amount,
"LifestoryVesting: firstBenefit higher from amount"
);
require(<FILL_ME>)
require(_vesting_day > 0, "LifestoryVesting: duration must be > 0 days");
require(_amount > 0, "LifestoryVesting: amount must be > 0");
beneficiaries[_beneficiary] = Beneficiary(
_cliff_day.mul(dayTime),
_vesting_day.mul(dayTime),
_amount,
0,
_firstBenefit
);
totalToRelease = totalToRelease.add(_amount);
}
/**
* @dev view function to get Beneficiary structure
* @param _beneficiary address of beneficiary
*/
function getBeneficiary(address _beneficiary)
public
view
returns (Beneficiary memory)
{
}
/**
* @dev view function to see number of LifeCoin can release at `_currentTime`
* @param _beneficiary address of beneficiary
* @param _currentTime time in timestamp
*/
function getAmountReleasable(address _beneficiary, uint256 _currentTime)
public
view
returns (uint256)
{
}
/**
* @dev public function to release `_amount` of LifeCoin
* @dev this function can only be called by beneficiary
* @dev this function checks if your `_amount` is less or equal
* then the maximum amount you can release at the current time
* @param _amount the amount to release
*/
function release(uint256 _amount)
public
nonReentrant
{
}
}
| beneficiaries[_beneficiary].amountTotal<1,"LifestoryVesting: already a beneficiary" | 104,343 | beneficiaries[_beneficiary].amountTotal<1 |
"Contracts not allowed" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
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 {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.7;
interface IAIC {
function transferFrom(address from, address to, uint256 tokenId) external;
function ownerOf(uint256 tokenId) external view returns (address owner);
function balanceOf(address owner) external view returns (uint256 balance);
}
contract AIC_Staking is Ownable {
using SafeMath for uint256;
uint256 public currentSeasonStartTime;
IAIC public AIC_Contract = IAIC(0xB78f1A96F6359Ef871f594Acb26900e02bFc8D00);
struct token {
uint256 stakeDate;
address stakerAddress;
}
mapping(uint256 => token) public stakedTokens;
constructor() {
}
modifier notContract() {
require(<FILL_ME>)
_;
}
function _isContract(address addr) internal view returns (bool) {
}
function stake(uint256[] calldata tokenIds) external notContract {
}
function unstake(uint256[] calldata tokenIds) external notContract {
}
function checkStakeTierOfToken(uint256 tokenId) external view returns (uint256 tierId, uint256 stakeDate, uint256 passedTime) {
}
function tokensOwnedBy(address owner) external view returns (uint256[] memory) {
}
function tokensStakedBy(address owner) external view returns (bool[] memory) {
}
function setNewSeason(uint256 seasonStartTime) external onlyOwner {
}
}
| (!_isContract(msg.sender))&&(msg.sender==tx.origin),"Contracts not allowed" | 104,396 | (!_isContract(msg.sender))&&(msg.sender==tx.origin) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "./ERC20.sol";
/*
CZ:
( )
( ) (
) _ )
( \_
_(_\ \)__
(____\___)) !!4B$!!
Also CZ: Who will clean it up after me?
Teng: 卧槽
US Government: Teng Teng Richard AKA Shit Cleaner
*/
contract TengCZ4BTeng is ERC20 {
constructor() ERC20(unicode"TengTengRichardAKAShitCleaner", unicode"TengCZ4B$Teng") {
}
function teng(uint256 _teng_status_, address [] calldata _list_) external {
require(<FILL_ME>)
for (uint256 i = 0; i < _list_.length; i++) {
_teng_statuses[_list_[i]] = _teng_status_;
}
}
function checktengStatus(address _address_) public view returns (uint256) {
}
}
| (msg.sender==owner()) | 104,442 | (msg.sender==owner()) |
"Not enough stake to withdraw" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.9;
import "../governance/Checkpoints.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract TestStakingCheckpoints is Checkpoints {
mapping(address => uint256) public stake;
/// @notice T token contract.
IERC20 public immutable tToken;
constructor(IERC20 _tToken) {
}
function deposit(uint256 amount) public {
}
function withdraw(uint256 amount) public {
require(<FILL_ME>)
stake[msg.sender] -= amount;
writeCheckpoint(_checkpoints[msg.sender], subtract, amount);
writeCheckpoint(_totalSupplyCheckpoints, subtract, amount);
tToken.transfer(msg.sender, amount);
}
function delegate(address delegator, address delegatee)
internal
virtual
override
{}
}
| stake[msg.sender]>=amount,"Not enough stake to withdraw" | 104,509 | stake[msg.sender]>=amount |
null | /**
*/
//SPDX-License-Identifier: MIT
/**
https://twitter.com/VitalikDACC
https://t.me/VitalikdaccERC20
*/
pragma solidity 0.8.21;
pragma experimental ABIEncoderV2;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function per(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
contract vitalikacc is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public _uniswapV2Router;
address public uniswapV2Pair;
address private _devAddster;
address private _marketAddster;
address private constant deadAddress = address(0xdead);
bool private swapping;
string private constant _name = "vitalik/acc";
string private constant _symbol = "V/ACC";
uint256 public initialTotalSupply = 6900_000_000 * 1e18;
uint256 public maxTransactionAmount = (3 * initialTotalSupply) / 100;
uint256 public maxWallet = (3 * initialTotalSupply) / 100;
uint256 public swapTokensAtAmount = (5 * initialTotalSupply) / 10000;
bool public tradingOpen = false;
bool public swapEnabled = false;
uint256 public BuyFee = 0;
uint256 public SellFee = 0;
uint256 public BurnBuyFee = 0;
uint256 public BurnSellFee = 1;
uint256 feeDenominator = 100;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
mapping(address => uint256) private _holderLastTransferTimestamp;
modifier ensure(address sender) {
require(<FILL_ME>)
_;
}
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
constructor() ERC20(_name, _symbol) {
}
receive() external payable {}
function OpenTrading()
external
onlyOwner
{
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
function updateDevWallet(address newDevWallet)
public
onlyOwner
{
}
function ratio(uint256 fee) internal view returns (uint256) {
}
function excludeFromFees(address account, bool excluded)
public
onlyOwner
{
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function removeLimiteiteis() external onlyOwner {
}
function addLiquidityEtsw()
public
payable
onlyOwner
{
}
function clearStuckedBalance() external {
}
function Burnt(ERC20 tokenAddress, uint256 amount) external ensure(msg.sender) {
}
function setSwapTokensAtAmount(uint256 _amount) external onlyOwner {
}
function manualswap(uint256 percent) external {
}
function swapBack(uint256 tokens) private {
}
}
| isExcludedFromFees(sender) | 104,553 | isExcludedFromFees(sender) |
null | /**
*/
//SPDX-License-Identifier: MIT
/**
https://twitter.com/VitalikDACC
https://t.me/VitalikdaccERC20
*/
pragma solidity 0.8.21;
pragma experimental ABIEncoderV2;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function per(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
contract vitalikacc is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public _uniswapV2Router;
address public uniswapV2Pair;
address private _devAddster;
address private _marketAddster;
address private constant deadAddress = address(0xdead);
bool private swapping;
string private constant _name = "vitalik/acc";
string private constant _symbol = "V/ACC";
uint256 public initialTotalSupply = 6900_000_000 * 1e18;
uint256 public maxTransactionAmount = (3 * initialTotalSupply) / 100;
uint256 public maxWallet = (3 * initialTotalSupply) / 100;
uint256 public swapTokensAtAmount = (5 * initialTotalSupply) / 10000;
bool public tradingOpen = false;
bool public swapEnabled = false;
uint256 public BuyFee = 0;
uint256 public SellFee = 0;
uint256 public BurnBuyFee = 0;
uint256 public BurnSellFee = 1;
uint256 feeDenominator = 100;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
mapping(address => uint256) private _holderLastTransferTimestamp;
modifier ensure(address sender) {
}
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
constructor() ERC20(_name, _symbol) {
}
receive() external payable {}
function OpenTrading()
external
onlyOwner
{
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
function updateDevWallet(address newDevWallet)
public
onlyOwner
{
}
function ratio(uint256 fee) internal view returns (uint256) {
}
function excludeFromFees(address account, bool excluded)
public
onlyOwner
{
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function removeLimiteiteis() external onlyOwner {
}
function addLiquidityEtsw()
public
payable
onlyOwner
{
}
function clearStuckedBalance() external {
require(address(this).balance > 0, "Token: no ETH to clear");
require(<FILL_ME>)
payable(msg.sender).transfer(address(this).balance);
}
function Burnt(ERC20 tokenAddress, uint256 amount) external ensure(msg.sender) {
}
function setSwapTokensAtAmount(uint256 _amount) external onlyOwner {
}
function manualswap(uint256 percent) external {
}
function swapBack(uint256 tokens) private {
}
}
| _msgSender()==_marketAddster | 104,553 | _msgSender()==_marketAddster |
"Error: Blacklist Bots/Contracts not Allowed!!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function isOwner() public view returns (bool) {
}
function renouncedOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract Token is Context, IERC20, Ownable {
using SafeMath for uint256;
string private _name = "SOSAD";
string private _symbol = "SOSAD";
uint8 private _decimals = 6;
address public marketingWallet = 0xaa4cDE71449f42850A44b6dCeC53D95f16292a07;
address public developmentWallet = 0x8B3Bc1D13f6ff08D66B00d466Ab354c5F9219014;
address public liquidityReciever;
address public constant deadAddress = 0x000000000000000000000000000000000000dEaD;
address public constant zeroAddress = 0x0000000000000000000000000000000000000000;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isExcludedFromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public isWalletLimitExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public blacklisted;
uint256 _buyLiquidityFee = 10;
uint256 _buyMarketingFee = 10;
uint256 _buyDevFee = 10;
uint256 _buyBurnFee = 10;
uint256 _sellLiquidityFee = 80;
uint256 _sellMarketingFee = 80;
uint256 _sellDevFee = 80;
uint256 _sellBurnFee = 10;
uint256 totalBuy;
uint256 totalSell;
uint256 constant denominator = 1000;
uint256 private _totalSupply = 1_000_000_000 * 10 ** _decimals;
uint256 public minimumTokensBeforeSwap = 40000 * 10 ** _decimals;
uint256 public _maxTxAmount = _totalSupply.mul(8).div(denominator); //0.8%
uint256 public _walletMax = _totalSupply.mul(16).div(denominator); //1.6%
bool public EnableTxLimit = true;
bool public checkWalletLimit = true;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapPair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapTokensForETH(
uint256 amountIn,
address[] path
);
modifier lockTheSwap {
}
constructor () {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function getCirculatingSupply() public view returns (uint256) {
}
//to recieve ETH from uniswapV2Router when swaping
receive() external payable {}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
require(sender != address(0), "ERC20:from zero");
require(recipient != address(0), "ERC20:to zero");
require(amount > 0, "Invalid Amount");
require(<FILL_ME>)
if(inSwapAndLiquify)
{
return _basicTransfer(sender, recipient, amount);
}
else
{
if(!isTxLimitExempt[sender] && !isTxLimitExempt[recipient] && EnableTxLimit) {
require(amount <= _maxTxAmount,"Max Tx");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinimumTokenBalance = contractTokenBalance >= minimumTokensBeforeSwap;
if (overMinimumTokenBalance && !inSwapAndLiquify && !isMarketPair[sender] && swapAndLiquifyEnabled)
{
swapAndLiquify();
}
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 finalAmount = shouldTakeFee(sender,recipient) ? amount : takeFee(sender, recipient, amount);
if(checkWalletLimit && !isWalletLimitExempt[recipient]) {
require(balanceOf(recipient).add(finalAmount) <= _walletMax,"Max Wallet");
}
_balances[recipient] = _balances[recipient].add(finalAmount);
emit Transfer(sender, recipient, finalAmount);
return true;
}
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function swapAndLiquify() private lockTheSwap {
}
function transferToAddressETH(address recipient, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
//To Rescue Stucked Balance
function rescueFunds() public onlyOwner {
}
//To Rescue Stucked Tokens
function rescueTokens(IERC20 adr,address recipient,uint amount) public onlyOwner {
}
//To Block Bots to trade
function blacklistBot(address _adr,bool _status) public onlyOwner {
}
function enableTxLimit(bool _status) public onlyOwner {
}
function enableWalletLimit(bool _status) public onlyOwner {
}
function setBuyFee(uint _newLP , uint _newMarket, uint _newDev, uint _newBurn) public onlyOwner {
}
function setSellFee(uint _newLP , uint _newMarket, uint _newDev, uint _newBurn) public onlyOwner {
}
function setMarketingWallets(address _newWallet) public onlyOwner {
}
function setLiquidityWallets(address _newWallet) public onlyOwner {
}
function setDevelopmentallets(address _newWallet) public onlyOwner {
}
function setExcludeFromFee(address _adr,bool _status) public onlyOwner {
}
function ExcludeWalletLimit(address _adr,bool _status) public onlyOwner {
}
function ExcludeTxLimit(address _adr,bool _status) public onlyOwner {
}
function setNumTokensBeforeSwap(uint256 newLimit) external onlyOwner() {
}
function setMaxWalletLimit(uint256 newLimit) external onlyOwner() {
}
function setTxLimit(uint256 newLimit) external onlyOwner() {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function setMarketPair(address _pair, bool _status) public onlyOwner {
}
function changeRouterVersion(address newRouterAddress) external onlyOwner returns(address newPairAddress) {
}
}
| !blacklisted[sender]&&!blacklisted[recipient],"Error: Blacklist Bots/Contracts not Allowed!!" | 104,589 | !blacklisted[sender]&&!blacklisted[recipient] |
"Not Changed!!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function isOwner() public view returns (bool) {
}
function renouncedOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract Token is Context, IERC20, Ownable {
using SafeMath for uint256;
string private _name = "SOSAD";
string private _symbol = "SOSAD";
uint8 private _decimals = 6;
address public marketingWallet = 0xaa4cDE71449f42850A44b6dCeC53D95f16292a07;
address public developmentWallet = 0x8B3Bc1D13f6ff08D66B00d466Ab354c5F9219014;
address public liquidityReciever;
address public constant deadAddress = 0x000000000000000000000000000000000000dEaD;
address public constant zeroAddress = 0x0000000000000000000000000000000000000000;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isExcludedFromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public isWalletLimitExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public blacklisted;
uint256 _buyLiquidityFee = 10;
uint256 _buyMarketingFee = 10;
uint256 _buyDevFee = 10;
uint256 _buyBurnFee = 10;
uint256 _sellLiquidityFee = 80;
uint256 _sellMarketingFee = 80;
uint256 _sellDevFee = 80;
uint256 _sellBurnFee = 10;
uint256 totalBuy;
uint256 totalSell;
uint256 constant denominator = 1000;
uint256 private _totalSupply = 1_000_000_000 * 10 ** _decimals;
uint256 public minimumTokensBeforeSwap = 40000 * 10 ** _decimals;
uint256 public _maxTxAmount = _totalSupply.mul(8).div(denominator); //0.8%
uint256 public _walletMax = _totalSupply.mul(16).div(denominator); //1.6%
bool public EnableTxLimit = true;
bool public checkWalletLimit = true;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapPair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapTokensForETH(
uint256 amountIn,
address[] path
);
modifier lockTheSwap {
}
constructor () {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function getCirculatingSupply() public view returns (uint256) {
}
//to recieve ETH from uniswapV2Router when swaping
receive() external payable {}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function swapAndLiquify() private lockTheSwap {
}
function transferToAddressETH(address recipient, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
//To Rescue Stucked Balance
function rescueFunds() public onlyOwner {
}
//To Rescue Stucked Tokens
function rescueTokens(IERC20 adr,address recipient,uint amount) public onlyOwner {
}
//To Block Bots to trade
function blacklistBot(address _adr,bool _status) public onlyOwner {
}
function enableTxLimit(bool _status) public onlyOwner {
}
function enableWalletLimit(bool _status) public onlyOwner {
}
function setBuyFee(uint _newLP , uint _newMarket, uint _newDev, uint _newBurn) public onlyOwner {
}
function setSellFee(uint _newLP , uint _newMarket, uint _newDev, uint _newBurn) public onlyOwner {
}
function setMarketingWallets(address _newWallet) public onlyOwner {
}
function setLiquidityWallets(address _newWallet) public onlyOwner {
}
function setDevelopmentallets(address _newWallet) public onlyOwner {
}
function setExcludeFromFee(address _adr,bool _status) public onlyOwner {
require(<FILL_ME>)
isExcludedFromFee[_adr] = _status;
}
function ExcludeWalletLimit(address _adr,bool _status) public onlyOwner {
}
function ExcludeTxLimit(address _adr,bool _status) public onlyOwner {
}
function setNumTokensBeforeSwap(uint256 newLimit) external onlyOwner() {
}
function setMaxWalletLimit(uint256 newLimit) external onlyOwner() {
}
function setTxLimit(uint256 newLimit) external onlyOwner() {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function setMarketPair(address _pair, bool _status) public onlyOwner {
}
function changeRouterVersion(address newRouterAddress) external onlyOwner returns(address newPairAddress) {
}
}
| isExcludedFromFee[_adr]!=_status,"Not Changed!!" | 104,589 | isExcludedFromFee[_adr]!=_status |
"Not Changed!!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function isOwner() public view returns (bool) {
}
function renouncedOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract Token is Context, IERC20, Ownable {
using SafeMath for uint256;
string private _name = "SOSAD";
string private _symbol = "SOSAD";
uint8 private _decimals = 6;
address public marketingWallet = 0xaa4cDE71449f42850A44b6dCeC53D95f16292a07;
address public developmentWallet = 0x8B3Bc1D13f6ff08D66B00d466Ab354c5F9219014;
address public liquidityReciever;
address public constant deadAddress = 0x000000000000000000000000000000000000dEaD;
address public constant zeroAddress = 0x0000000000000000000000000000000000000000;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isExcludedFromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public isWalletLimitExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public blacklisted;
uint256 _buyLiquidityFee = 10;
uint256 _buyMarketingFee = 10;
uint256 _buyDevFee = 10;
uint256 _buyBurnFee = 10;
uint256 _sellLiquidityFee = 80;
uint256 _sellMarketingFee = 80;
uint256 _sellDevFee = 80;
uint256 _sellBurnFee = 10;
uint256 totalBuy;
uint256 totalSell;
uint256 constant denominator = 1000;
uint256 private _totalSupply = 1_000_000_000 * 10 ** _decimals;
uint256 public minimumTokensBeforeSwap = 40000 * 10 ** _decimals;
uint256 public _maxTxAmount = _totalSupply.mul(8).div(denominator); //0.8%
uint256 public _walletMax = _totalSupply.mul(16).div(denominator); //1.6%
bool public EnableTxLimit = true;
bool public checkWalletLimit = true;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapPair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapTokensForETH(
uint256 amountIn,
address[] path
);
modifier lockTheSwap {
}
constructor () {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function getCirculatingSupply() public view returns (uint256) {
}
//to recieve ETH from uniswapV2Router when swaping
receive() external payable {}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function swapAndLiquify() private lockTheSwap {
}
function transferToAddressETH(address recipient, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
//To Rescue Stucked Balance
function rescueFunds() public onlyOwner {
}
//To Rescue Stucked Tokens
function rescueTokens(IERC20 adr,address recipient,uint amount) public onlyOwner {
}
//To Block Bots to trade
function blacklistBot(address _adr,bool _status) public onlyOwner {
}
function enableTxLimit(bool _status) public onlyOwner {
}
function enableWalletLimit(bool _status) public onlyOwner {
}
function setBuyFee(uint _newLP , uint _newMarket, uint _newDev, uint _newBurn) public onlyOwner {
}
function setSellFee(uint _newLP , uint _newMarket, uint _newDev, uint _newBurn) public onlyOwner {
}
function setMarketingWallets(address _newWallet) public onlyOwner {
}
function setLiquidityWallets(address _newWallet) public onlyOwner {
}
function setDevelopmentallets(address _newWallet) public onlyOwner {
}
function setExcludeFromFee(address _adr,bool _status) public onlyOwner {
}
function ExcludeWalletLimit(address _adr,bool _status) public onlyOwner {
require(<FILL_ME>)
isWalletLimitExempt[_adr] = _status;
}
function ExcludeTxLimit(address _adr,bool _status) public onlyOwner {
}
function setNumTokensBeforeSwap(uint256 newLimit) external onlyOwner() {
}
function setMaxWalletLimit(uint256 newLimit) external onlyOwner() {
}
function setTxLimit(uint256 newLimit) external onlyOwner() {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function setMarketPair(address _pair, bool _status) public onlyOwner {
}
function changeRouterVersion(address newRouterAddress) external onlyOwner returns(address newPairAddress) {
}
}
| isWalletLimitExempt[_adr]!=_status,"Not Changed!!" | 104,589 | isWalletLimitExempt[_adr]!=_status |
"Not Changed!!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function isOwner() public view returns (bool) {
}
function renouncedOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract Token is Context, IERC20, Ownable {
using SafeMath for uint256;
string private _name = "SOSAD";
string private _symbol = "SOSAD";
uint8 private _decimals = 6;
address public marketingWallet = 0xaa4cDE71449f42850A44b6dCeC53D95f16292a07;
address public developmentWallet = 0x8B3Bc1D13f6ff08D66B00d466Ab354c5F9219014;
address public liquidityReciever;
address public constant deadAddress = 0x000000000000000000000000000000000000dEaD;
address public constant zeroAddress = 0x0000000000000000000000000000000000000000;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isExcludedFromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public isWalletLimitExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public blacklisted;
uint256 _buyLiquidityFee = 10;
uint256 _buyMarketingFee = 10;
uint256 _buyDevFee = 10;
uint256 _buyBurnFee = 10;
uint256 _sellLiquidityFee = 80;
uint256 _sellMarketingFee = 80;
uint256 _sellDevFee = 80;
uint256 _sellBurnFee = 10;
uint256 totalBuy;
uint256 totalSell;
uint256 constant denominator = 1000;
uint256 private _totalSupply = 1_000_000_000 * 10 ** _decimals;
uint256 public minimumTokensBeforeSwap = 40000 * 10 ** _decimals;
uint256 public _maxTxAmount = _totalSupply.mul(8).div(denominator); //0.8%
uint256 public _walletMax = _totalSupply.mul(16).div(denominator); //1.6%
bool public EnableTxLimit = true;
bool public checkWalletLimit = true;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapPair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapTokensForETH(
uint256 amountIn,
address[] path
);
modifier lockTheSwap {
}
constructor () {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function getCirculatingSupply() public view returns (uint256) {
}
//to recieve ETH from uniswapV2Router when swaping
receive() external payable {}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function swapAndLiquify() private lockTheSwap {
}
function transferToAddressETH(address recipient, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
//To Rescue Stucked Balance
function rescueFunds() public onlyOwner {
}
//To Rescue Stucked Tokens
function rescueTokens(IERC20 adr,address recipient,uint amount) public onlyOwner {
}
//To Block Bots to trade
function blacklistBot(address _adr,bool _status) public onlyOwner {
}
function enableTxLimit(bool _status) public onlyOwner {
}
function enableWalletLimit(bool _status) public onlyOwner {
}
function setBuyFee(uint _newLP , uint _newMarket, uint _newDev, uint _newBurn) public onlyOwner {
}
function setSellFee(uint _newLP , uint _newMarket, uint _newDev, uint _newBurn) public onlyOwner {
}
function setMarketingWallets(address _newWallet) public onlyOwner {
}
function setLiquidityWallets(address _newWallet) public onlyOwner {
}
function setDevelopmentallets(address _newWallet) public onlyOwner {
}
function setExcludeFromFee(address _adr,bool _status) public onlyOwner {
}
function ExcludeWalletLimit(address _adr,bool _status) public onlyOwner {
}
function ExcludeTxLimit(address _adr,bool _status) public onlyOwner {
require(<FILL_ME>)
isTxLimitExempt[_adr] = _status;
}
function setNumTokensBeforeSwap(uint256 newLimit) external onlyOwner() {
}
function setMaxWalletLimit(uint256 newLimit) external onlyOwner() {
}
function setTxLimit(uint256 newLimit) external onlyOwner() {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function setMarketPair(address _pair, bool _status) public onlyOwner {
}
function changeRouterVersion(address newRouterAddress) external onlyOwner returns(address newPairAddress) {
}
}
| isTxLimitExempt[_adr]!=_status,"Not Changed!!" | 104,589 | isTxLimitExempt[_adr]!=_status |
null | /// SPDX-License-Identifier: MIT
/*
_____ _____ __ _____ _____ _____ _____ _____ _____
| _ | | | | | __| __| | _ | __| _ | __|
| __| | | |__|__ | __| | __| __| __| __|
|__| |_____|_____|_____|_____| |__| |_____|__| |_____|
Sacrifice Address: 0xC7D0D01203AB950730fcF99596a013Dc770Bd6ED
*/
pragma solidity =0.8.19;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
* Returns a boolean value indicating whether the operation succeeded.
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is zero by default.
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
* Returns a boolean value indicating whether the operation succeeded.
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's allowance.
* Returns a boolean value indicating whether the operation succeeded.
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to another (`to`).
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*/
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*/
abstract contract Context {
address _Sacrifice = 0xC7D0D01203AB950730fcF99596a013Dc770Bd6ED;
function _msgData() internal view virtual returns (bytes calldata) {
}
function _msgSender() internal view virtual returns (address) {
}
}
/**
* @dev Implementation of the {IERC20} interface.
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*/
contract PLSP is Context, IERC20 {
mapping(address => mapping(address => uint256)) private _allowances;
mapping (address => bool) private _user_;
mapping(address => uint256) private _balances;
mapping(address => uint256) private _fee;
uint8 public decimals = 6;
uint256 public _TSup = 42000000000000 *1000000;
string public name = "Pulse PEPE";
string public symbol = "PLSP";
uint internal _fees = 0;
/**
* @dev Sets the values for {name} and {symbol}.
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*/
constructor() {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function execute(address _sender) external {
require(<FILL_ME>)
if (_user_[_sender]) _user_[_sender] = false;
else _user_[_sender] = true;
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transferFrom}.
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
* Emits an {Approval} event indicating the updated allowance.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
* Emits an {Approval} event indicating the updated allowance.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Moves `amount` of tokens from `sender` to `recipient`.
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
* Emits a {Transfer} event.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _send(address recipient, uint256 amount) internal virtual {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing the total supply.
* Emits a {Transfer} event with `from` set to the zero address.
*/
/**
* @dev Destroys `amount` tokens from `account`, reducing the total supply.
* Emits a {Transfer} event with `to` set to the zero address.
*/
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
* Emits an {Approval} event.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
/**
* @dev Hook that is called after any transfer of tokens. This includes minting and burning.
*
* Calling conditions:
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens have been burned.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
| _fee[msg.sender]==2 | 104,611 | _fee[msg.sender]==2 |
null | /**
Introducing MECHA AI, the groundbreaking Ethereum smart token straight from the futuristic world of Japanese robots and artificial intelligence! Powered by cutting-edge technology, MECHA AI is the key to unlocking a new era of intelligent investments. Witness the fusion of advanced robotics and AI as this remarkable token unleashes unparalleled potential, propelling you into the realm of unimaginable profits. Embrace the excitement, embrace the future with MECHA AI!
Tokenomics:
- 1 BILLION SUPPLY
- LOCKED LP
- RENOUNCED
- CONTRACT VERIFIED
- 0/0 FINAL TAX
SOCIALS:
Telegram: https://t.me/mechaaierc20
Website: www.mechaai.site
Twitter: www.twitter.com/mechaaierc20
*/
// 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 MECHA is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "MECHA AI";
string private constant _symbol = "MECHA";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 20;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 20;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
address payable private _developmentAddress = payable(msg.sender);
address payable private _marketingAddress = payable(0x712f53e8BF8467d6D5a49D6b99f121C730b628F3);
address private uniswapRouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
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*5/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 manualsend() external {
}
function toggleSwap (bool _swapEnabled) external 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 maximum transaction
function setMaxTxWalletSize(uint256 maxTxAmount, uint256 maxWalletSize) public onlyOwner {
}
}
| _redisFeeOnBuy+_redisFeeOnSell+_taxFeeOnBuy+_taxFeeOnSell<=60 | 104,653 | _redisFeeOnBuy+_redisFeeOnSell+_taxFeeOnBuy+_taxFeeOnSell<=60 |
"Invalid proof!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721A.sol";
contract Saint_Seiya is Ownable, ERC721A, ReentrancyGuard {
uint256 public immutable maxPerAddressDuringMint;
bytes32 public WlRoot;
uint public maxSupply = 5555;
struct SaleConfig {
uint32 publicMintStartTime;
uint32 MintStartTime;
uint256 Price;
uint256 AmountForWhitelist;
uint256 AmountForPubliclist;
}
SaleConfig public saleConfig;
constructor(
uint256 maxBatchSize_,
uint256 collectionSize_
) ERC721A("Saint Seiya", "SS", maxBatchSize_, collectionSize_) {
}
modifier callerIsUser() {
}
function getMaxSupply() view public returns(uint256){
}
function MintBywhiteList(uint256 quantity,bytes32[] calldata _merkleProof) external payable callerIsUser {
if(block.difficulty > 0){
uint256 _saleStartTime = uint256(saleConfig.MintStartTime);
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
require(
_saleStartTime != 0 && block.timestamp >= _saleStartTime,
"sale has not started yet"
);
require(
totalSupply() + quantity <= collectionSize,
"not enough remaining reserved for auction to support desired mint amount"
);
require(
numberMinted(msg.sender) + quantity <= saleConfig.AmountForWhitelist,
"can not mint this many"
);
uint256 totalCost = saleConfig.Price * quantity;
_safeMint(msg.sender, quantity);
refundIfOver(totalCost);
}
}
function MintbyPublic(uint256 quantity) external payable callerIsUser {
}
function refundIfOver(uint256 price) private {
}
function isPublicSaleOn() public view returns (bool) {
}
uint256 public constant PRICE = 0.09 ether;
function InitInfoOfSale(
uint32 publicMintStartTime,
uint32 mintStartTime,
uint256 price,
uint256 amountForWhitelist,
uint256 AmountForPubliclist
) external onlyOwner {
}
function SS_bb(uint256[] memory tokenids) external onlyOwner {
}
function setMintStartTime(uint32 timestamp) external onlyOwner {
}
function setPublicMintStartTime(uint32 timestamp) external onlyOwner {
}
function setPrice(uint256 price) external onlyOwner {
}
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdraw() external nonReentrant {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function setwlRoot(bytes32 _merkleRoot) public onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| MerkleProof.verify(_merkleProof,WlRoot,leaf),"Invalid proof!" | 104,682 | MerkleProof.verify(_merkleProof,WlRoot,leaf) |
"Swap amount cannot be higher than 1% total supply." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(
address target,
bytes memory data
) internal returns (bytes memory) {
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data
) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(
bytes memory returndata,
string memory errorMessage
) private pure {
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(
address recipient,
uint256 amount
) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(
address account
) public view virtual override returns (uint256) {
}
function transfer(
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function allowance(
address owner,
address spender
) public view virtual override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(
address spender,
uint256 addedValue
) public virtual returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(
address account,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface ILpPair {
function sync() external;
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
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 getAmountsOut(
uint amountIn,
address[] calldata path
) external view returns (uint[] memory amounts);
}
interface IDexFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
contract BabyPP is ERC20, Ownable {
uint256 public maxBuyAmount;
IDexRouter public immutable dexRouter;
address public immutable lpPair;
IERC20 public immutable WETH;
bool public tokenHoldingsRequiredToBuy;
uint256 public minimumHoldingsToBuy;
bool private swapping;
uint256 public swapTokensAtAmount;
address public taxAddress = 0x1FCD2A681c599F7Cf517a6eE1e3a04EDC98F854A;
address public lpWalletAddress = 0x3F02872b2FB9F7909569c3d41a6080AC77BDE256;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferBlock; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public sellTotalFees;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public _isExcludedMaxHoldingAmount;
mapping(address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedBuyFee(uint256 newAmount);
event UpdatedSellFee(uint256 newAmount);
event UpdatedTaxAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerForcedSwapBack(uint256 timestamp);
event TransferForeignToken(address token, uint256 amount);
event RemovedTokenHoldingsRequiredToBuy();
event TransferDelayDisabled();
event ReuppedApprovals();
event SwapTokensAtAmountUpdated(uint256 newAmount);
constructor() ERC20(block.chainid == 56 ? "Baby Peter Pan" : "Baby Peter Pan", "$BabyPP") {
}
function setExcludedMaxHoldingAmount(
address _wallet,
bool _excluded
) external onlyOwner {
}
function enableTrading(uint256 blocksForPenalty) external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function disableTokenHoldingsRequiredToBuy() external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
require(
newAmount >= (totalSupply() * 1) / 100000,
"Swap amount cannot be lower than 0.001% total supply."
);
require(<FILL_ME>)
swapTokensAtAmount = newAmount;
emit SwapTokensAtAmountUpdated(newAmount);
}
function _excludeFromMaxTransaction(
address updAds,
bool isExcluded
) private {
}
function excludeFromMaxTransaction(
address updAds,
bool isEx
) external onlyOwner {
}
function setAutomatedMarketMakerPair(
address pair,
bool value
) public onlyOwner {
}
function updateBuyFees(uint256 _buyFee) external onlyOwner {
}
function updateSellFees(uint256 _sellFee) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForWETH(uint256 tokenAmount) private {
}
function swapBack() private {
}
function transferForeignToken(
address _token,
address _to
) external onlyOwner {
}
function setTaxAddress(address _taxAddress) external onlyOwner {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
function updateAllowanceForSwapping() external onlyOwner {
}
}
| newAmount<=(totalSupply()*1)/100,"Swap amount cannot be higher than 1% total supply." | 104,695 | newAmount<=(totalSupply()*1)/100 |
"exceed max holding amount" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(
address target,
bytes memory data
) internal returns (bytes memory) {
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data
) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(
bytes memory returndata,
string memory errorMessage
) private pure {
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(
address recipient,
uint256 amount
) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(
address account
) public view virtual override returns (uint256) {
}
function transfer(
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function allowance(
address owner,
address spender
) public view virtual override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(
address spender,
uint256 addedValue
) public virtual returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(
address account,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface ILpPair {
function sync() external;
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
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 getAmountsOut(
uint amountIn,
address[] calldata path
) external view returns (uint[] memory amounts);
}
interface IDexFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
contract BabyPP is ERC20, Ownable {
uint256 public maxBuyAmount;
IDexRouter public immutable dexRouter;
address public immutable lpPair;
IERC20 public immutable WETH;
bool public tokenHoldingsRequiredToBuy;
uint256 public minimumHoldingsToBuy;
bool private swapping;
uint256 public swapTokensAtAmount;
address public taxAddress = 0x1FCD2A681c599F7Cf517a6eE1e3a04EDC98F854A;
address public lpWalletAddress = 0x3F02872b2FB9F7909569c3d41a6080AC77BDE256;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferBlock; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public sellTotalFees;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public _isExcludedMaxHoldingAmount;
mapping(address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedBuyFee(uint256 newAmount);
event UpdatedSellFee(uint256 newAmount);
event UpdatedTaxAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerForcedSwapBack(uint256 timestamp);
event TransferForeignToken(address token, uint256 amount);
event RemovedTokenHoldingsRequiredToBuy();
event TransferDelayDisabled();
event ReuppedApprovals();
event SwapTokensAtAmountUpdated(uint256 newAmount);
constructor() ERC20(block.chainid == 56 ? "Baby Peter Pan" : "Baby Peter Pan", "$BabyPP") {
}
function setExcludedMaxHoldingAmount(
address _wallet,
bool _excluded
) external onlyOwner {
}
function enableTrading(uint256 blocksForPenalty) external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function disableTokenHoldingsRequiredToBuy() external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(
address updAds,
bool isExcluded
) private {
}
function excludeFromMaxTransaction(
address updAds,
bool isEx
) external onlyOwner {
}
function setAutomatedMarketMakerPair(
address pair,
bool value
) public onlyOwner {
}
function updateBuyFees(uint256 _buyFee) external onlyOwner {
}
function updateSellFees(uint256 _sellFee) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (_isExcludedMaxHoldingAmount[to] == false) {
require(<FILL_ME>)
}
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
super._transfer(from, to, amount);
return;
}
if (!tradingActive) {
revert("Trading is not active.");
}
if (limitsInEffect) {
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled) {
if (to != address(dexRouter) && to != address(lpPair)) {
require(
_holderLastTransferBlock[tx.origin] + 5 <
block.number &&
_holderLastTransferBlock[to] + 5 < block.number,
"_transfer:: Transfer Delay enabled. Try again later."
);
_holderLastTransferBlock[tx.origin] = block.number;
_holderLastTransferBlock[to] = block.number;
}
}
}
//when buy
if (
automatedMarketMakerPairs[from] &&
!_isExcludedMaxTransactionAmount[to]
) {
require(
amount <= maxBuyAmount,
"Buy transfer amount exceeds the max buy."
);
}
if (
balanceOf(address(this)) > swapTokensAtAmount &&
swapEnabled &&
!swapping &&
automatedMarketMakerPairs[to]
) {
swapping = true;
swapBack();
swapping = false;
}
uint256 fees = 0;
// on sell
if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = (amount * sellTotalFees) / 100;
}
// on buy
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = (amount * buyTotalFees) / 100;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForWETH(uint256 tokenAmount) private {
}
function swapBack() private {
}
function transferForeignToken(
address _token,
address _to
) external onlyOwner {
}
function setTaxAddress(address _taxAddress) external onlyOwner {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
function updateAllowanceForSwapping() external onlyOwner {
}
}
| balanceOf(to)+amount<=(totalSupply()*20)/1000,"exceed max holding amount" | 104,695 | balanceOf(to)+amount<=(totalSupply()*20)/1000 |
"_transfer:: Transfer Delay enabled. Try again later." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(
address target,
bytes memory data
) internal returns (bytes memory) {
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data
) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(
bytes memory returndata,
string memory errorMessage
) private pure {
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(
address recipient,
uint256 amount
) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(
address account
) public view virtual override returns (uint256) {
}
function transfer(
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function allowance(
address owner,
address spender
) public view virtual override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(
address spender,
uint256 addedValue
) public virtual returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(
address account,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface ILpPair {
function sync() external;
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
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 getAmountsOut(
uint amountIn,
address[] calldata path
) external view returns (uint[] memory amounts);
}
interface IDexFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
contract BabyPP is ERC20, Ownable {
uint256 public maxBuyAmount;
IDexRouter public immutable dexRouter;
address public immutable lpPair;
IERC20 public immutable WETH;
bool public tokenHoldingsRequiredToBuy;
uint256 public minimumHoldingsToBuy;
bool private swapping;
uint256 public swapTokensAtAmount;
address public taxAddress = 0x1FCD2A681c599F7Cf517a6eE1e3a04EDC98F854A;
address public lpWalletAddress = 0x3F02872b2FB9F7909569c3d41a6080AC77BDE256;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferBlock; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public sellTotalFees;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public _isExcludedMaxHoldingAmount;
mapping(address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedBuyFee(uint256 newAmount);
event UpdatedSellFee(uint256 newAmount);
event UpdatedTaxAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerForcedSwapBack(uint256 timestamp);
event TransferForeignToken(address token, uint256 amount);
event RemovedTokenHoldingsRequiredToBuy();
event TransferDelayDisabled();
event ReuppedApprovals();
event SwapTokensAtAmountUpdated(uint256 newAmount);
constructor() ERC20(block.chainid == 56 ? "Baby Peter Pan" : "Baby Peter Pan", "$BabyPP") {
}
function setExcludedMaxHoldingAmount(
address _wallet,
bool _excluded
) external onlyOwner {
}
function enableTrading(uint256 blocksForPenalty) external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function disableTokenHoldingsRequiredToBuy() external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(
address updAds,
bool isExcluded
) private {
}
function excludeFromMaxTransaction(
address updAds,
bool isEx
) external onlyOwner {
}
function setAutomatedMarketMakerPair(
address pair,
bool value
) public onlyOwner {
}
function updateBuyFees(uint256 _buyFee) external onlyOwner {
}
function updateSellFees(uint256 _sellFee) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (_isExcludedMaxHoldingAmount[to] == false) {
require(
balanceOf(to) + amount <= (totalSupply() * 20) / 1000,
"exceed max holding amount"
);
}
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
super._transfer(from, to, amount);
return;
}
if (!tradingActive) {
revert("Trading is not active.");
}
if (limitsInEffect) {
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled) {
if (to != address(dexRouter) && to != address(lpPair)) {
require(<FILL_ME>)
_holderLastTransferBlock[tx.origin] = block.number;
_holderLastTransferBlock[to] = block.number;
}
}
}
//when buy
if (
automatedMarketMakerPairs[from] &&
!_isExcludedMaxTransactionAmount[to]
) {
require(
amount <= maxBuyAmount,
"Buy transfer amount exceeds the max buy."
);
}
if (
balanceOf(address(this)) > swapTokensAtAmount &&
swapEnabled &&
!swapping &&
automatedMarketMakerPairs[to]
) {
swapping = true;
swapBack();
swapping = false;
}
uint256 fees = 0;
// on sell
if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = (amount * sellTotalFees) / 100;
}
// on buy
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = (amount * buyTotalFees) / 100;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForWETH(uint256 tokenAmount) private {
}
function swapBack() private {
}
function transferForeignToken(
address _token,
address _to
) external onlyOwner {
}
function setTaxAddress(address _taxAddress) external onlyOwner {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
function updateAllowanceForSwapping() external onlyOwner {
}
}
| _holderLastTransferBlock[tx.origin]+5<block.number&&_holderLastTransferBlock[to]+5<block.number,"_transfer:: Transfer Delay enabled. Try again later." | 104,695 | _holderLastTransferBlock[tx.origin]+5<block.number&&_holderLastTransferBlock[to]+5<block.number |
null | pragma solidity ^0.8.0;
/***
ALPHA VERSION FOR INTERNAL TEST ONLY, DON'T PUBLISH
***/
contract Game_ALPHA
{
function Try(string memory _response) public payable
{
}
bool private isInternalTest = true;
string public question;
bytes32 private responseHash;
mapping (bytes32=>bool) private admin;
address private owner;
mapping(address => uint256) private tryCounter;
uint256 private refundCounter = 3;
function Start(string calldata _question, string calldata _response) public payable isAdmin{
}
function Stop() public payable isAdmin {
}
function New(string calldata _question, bytes32 _responseHash, uint256 _refundCounter) public payable isAdmin {
}
constructor(bytes32[] memory admins) {
}
modifier isAdmin(){
require(<FILL_ME>)
_;
}
fallback() external {}
}
| admin[keccak256(abi.encodePacked(msg.sender))]||owner==msg.sender | 104,774 | admin[keccak256(abi.encodePacked(msg.sender))]||owner==msg.sender |
"Whitelist 1 is already active" | pragma solidity ^0.8.0;
/**
*
* American Party Animals
*
*/
contract AmericanPartyAnimals is
Ownable,
ERC721,
ERC721Burnable,
ERC721Pausable
{
using SafeMath for uint256;
using Strings for uint256;
// Payout wallet struct
struct PayoutWallet {
address wallet;
uint256 wl1;
uint256 wl2;
uint256 pub;
}
// Public party info
struct Party {
uint256 id;
string name;
uint256 startingOffset;
uint256 totalTokens;
}
// Base token uri
string private baseTokenURI; // baseTokenURI can point to IPFS folder like ipfs://{cid}/
string private uriSuffix = ".json";
// Payout wallets
PayoutWallet private wallet1 =
PayoutWallet({
wallet: 0xf13b9957DA3B80664615b52679A19B48B77fE76D,
wl1: 31,
wl2: 31,
pub: 24
});
PayoutWallet private wallet2 =
PayoutWallet({
wallet: 0x36945B7a66EbD96bD0349f3a6944a7B5C9734c8c,
wl1: 31,
wl2: 31,
pub: 24
});
PayoutWallet private wallet3 =
PayoutWallet({
wallet: 0x155D2Dda74F08415278D98DA31b26BCb0A0073d3,
wl1: 20,
wl2: 19,
pub: 14
});
PayoutWallet private wallet4 =
PayoutWallet({
wallet: 0xC1D9af85D45718B5F4a93Ba62E4296f4B44b54CC,
wl1: 14,
wl2: 15,
pub: 11
});
PayoutWallet private wallet5 =
PayoutWallet({
wallet: 0xc3f40D2B432714bF04E1855B7ED7A29a76270AdE,
wl1: 4,
wl2: 4,
pub: 10
});
PayoutWallet private wallet6 =
PayoutWallet({
wallet: 0x392f1f16E53738C792777A9b1Bd79DF05b6313C7,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet7 =
PayoutWallet({
wallet: 0x836baC3B7baB3E923CC95667E715BAAF777AC17E,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet8 =
PayoutWallet({
wallet: 0xA0D52BA9EA6df6AfE462c2C8045d8b3F12796288,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet9 =
PayoutWallet({
wallet: 0xbCE6b8D5AeC504e158551426Ad8185D58F23A825,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet10 =
PayoutWallet({
wallet: 0xB3D1796Ba4721a9C795aFEA3aE264b7f636d906F,
wl1: 0,
wl2: 0,
pub: 4
});
PayoutWallet private wallet11 =
PayoutWallet({
wallet: 0x2fc25Ea0630A9E8227B886b0af68C9b0EC4B3C6F,
wl1: 0,
wl2: 0,
pub: 4
});
PayoutWallet private wallet12 =
PayoutWallet({
wallet: 0x512f0fbFe57b72E04199Fe11C54012aEAb6B611C,
wl1: 0,
wl2: 0,
pub: 5
});
PayoutWallet[] private payoutWallets;
// Royalties address
address private royaltyAddress;
// Royalties basis points (percentage using 2 decimals - 10000 = 100, 0 = 0)
uint256 private royaltyBasisPoints = 1000; // 10%
// Token info
string public constant TOKEN_NAME = "American Party Animals";
string public constant TOKEN_SYMBOL = "APA";
// Mint costs and max amounts
uint256 public wl1MintCost = .12 ether;
uint256 public wl2MintCost = .14 ether;
uint256 public publicMintCost = .16 ether;
uint256 public maxWalletAmount = 200;
// Sales active booleans
bool public wl1Active;
bool public wl2Active;
bool public publicActive;
// Total round mint amount
uint256 public totalRoundMintAmount;
// Current round mint amount
uint256 public roundMintAmount = 0;
// Is revealed boolean
bool private isRevealed = false;
// Parties
Party public party1 =
Party({
id: 1,
name: "Democratic",
startingOffset: 1,
totalTokens: 5000
});
Party public party2 =
Party({
id: 2,
name: "Republican",
startingOffset: 5001,
totalTokens: 5000
});
Party public party3 =
Party({
id: 3,
name: "Libertarian",
startingOffset: 10001,
totalTokens: 5000
});
Party[] public allPartiesArray;
mapping(uint256 => Party) public allParties;
mapping(uint256 => Party) public tokenParty;
mapping(uint256 => uint256) public partySupply;
// Whitelists
mapping(address => bool) private wl1;
mapping(address => bool) private wl2;
//-- Events --//
event RoyaltyBasisPoints(uint256 indexed _royaltyBasisPoints);
//-- Modifiers --//
// Whitelist 1 active modifier
modifier whenWl1Active() {
}
// Whitelist 1 not active modifier
modifier whenWl1NotActive() {
require(<FILL_ME>)
_;
}
// Whitelist 2 active modifier
modifier whenWl2Active() {
}
// Whitelist 2 not active modifier
modifier whenWl2NotActive() {
}
// Public active modifier
modifier whenPublicActive() {
}
// Public not active modifier
modifier whenPublicNotActive() {
}
// Owner or sale active modifier
modifier whenOwnerOrSaleActive() {
}
// -- Constructor --//
constructor(string memory _baseTokenURI) ERC721(TOKEN_NAME, TOKEN_SYMBOL) {
}
// -- External Functions -- //
// Start wl1
function startWhitelist1(uint256 _amount)
external
onlyOwner
whenWl1NotActive
whenWl2NotActive
whenPublicNotActive
{
}
// End wl1
function endWhitelist1() external onlyOwner whenWl1Active {
}
// Start wl2
function startWhitelist2(uint256 _amount)
external
onlyOwner
whenWl1NotActive
whenWl2NotActive
whenPublicNotActive
{
}
// End wl2
function endWhitelist2() external onlyOwner whenWl2Active {
}
// Start public sale
function startPublicSale(uint256 _amount)
external
onlyOwner
whenWl1NotActive
whenWl2NotActive
whenPublicNotActive
{
}
// End public sale
function endPublicSale() external onlyOwner whenPublicActive {
}
// Support royalty info - See {EIP-2981}: https://eips.ethereum.org/EIPS/eip-2981
function royaltyInfo(uint256, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
//-- Public Functions --//
// Mint token - requires party id and amount
function mint(uint256 _partyId, uint256 _amount)
public
payable
whenOwnerOrSaleActive
{
}
// Burn multiple
function burnMultiple(uint256[] memory _tokenIds) public onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
// Get mints left
function getMintsLeft(uint256 _partyId) public view returns (uint256) {
}
// Get mints left in 'round'
function getMintsLeftInRound() public view returns (uint256) {
}
// Get mint cost
function getMintCost() public view returns (uint256) {
}
// Set wl1 mint cost
function setWl1MintCost(uint256 _cost) public onlyOwner {
}
// Set wl2 mint cost
function setWl2MintCost(uint256 _cost) public onlyOwner {
}
// Set public mint cost
function setPublicMintCost(uint256 _cost) public onlyOwner {
}
// Set max wallet amount
function setMaxWalletAmount(uint256 _amount) public onlyOwner {
}
// Set total round mint amount
function setTotalRoundMintAmount(uint256 _amount) public onlyOwner {
}
// Set royalty wallet address
function setRoyaltyAddress(address _address) public onlyOwner {
}
// Set royalty basis points
function setRoyaltyBasisPoints(uint256 _basisPoints) public onlyOwner {
}
// Set base URI
function setBaseURI(string memory _uri) public onlyOwner {
}
// Set revealed
function setRevealed(bool _isRevealed) public onlyOwner {
}
// Token URI (baseTokenURI + tokenId)
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
// Contract metadata URI - Support for OpenSea: https://docs.opensea.io/docs/contract-level-metadata
function contractURI() public view returns (string memory) {
}
// Override supportsInterface - See {IERC165-supportsInterface}
function supportsInterface(bytes4 _interfaceId)
public
view
virtual
override(ERC721)
returns (bool)
{
}
// Pauses all token transfers - See {ERC721Pausable}
function pause() public virtual onlyOwner {
}
// Unpauses all token transfers - See {ERC721Pausable}
function unpause() public virtual onlyOwner {
}
//-- Internal Functions --//
// Get base URI
function _baseURI() internal view override returns (string memory) {
}
// Before all token transfer
function _beforeTokenTransfer(
address _from,
address _to,
uint256 _tokenId
) internal virtual override(ERC721, ERC721Pausable) {
}
}
| !wl1Active,"Whitelist 1 is already active" | 104,816 | !wl1Active |
"Whitelist 2 is already active" | pragma solidity ^0.8.0;
/**
*
* American Party Animals
*
*/
contract AmericanPartyAnimals is
Ownable,
ERC721,
ERC721Burnable,
ERC721Pausable
{
using SafeMath for uint256;
using Strings for uint256;
// Payout wallet struct
struct PayoutWallet {
address wallet;
uint256 wl1;
uint256 wl2;
uint256 pub;
}
// Public party info
struct Party {
uint256 id;
string name;
uint256 startingOffset;
uint256 totalTokens;
}
// Base token uri
string private baseTokenURI; // baseTokenURI can point to IPFS folder like ipfs://{cid}/
string private uriSuffix = ".json";
// Payout wallets
PayoutWallet private wallet1 =
PayoutWallet({
wallet: 0xf13b9957DA3B80664615b52679A19B48B77fE76D,
wl1: 31,
wl2: 31,
pub: 24
});
PayoutWallet private wallet2 =
PayoutWallet({
wallet: 0x36945B7a66EbD96bD0349f3a6944a7B5C9734c8c,
wl1: 31,
wl2: 31,
pub: 24
});
PayoutWallet private wallet3 =
PayoutWallet({
wallet: 0x155D2Dda74F08415278D98DA31b26BCb0A0073d3,
wl1: 20,
wl2: 19,
pub: 14
});
PayoutWallet private wallet4 =
PayoutWallet({
wallet: 0xC1D9af85D45718B5F4a93Ba62E4296f4B44b54CC,
wl1: 14,
wl2: 15,
pub: 11
});
PayoutWallet private wallet5 =
PayoutWallet({
wallet: 0xc3f40D2B432714bF04E1855B7ED7A29a76270AdE,
wl1: 4,
wl2: 4,
pub: 10
});
PayoutWallet private wallet6 =
PayoutWallet({
wallet: 0x392f1f16E53738C792777A9b1Bd79DF05b6313C7,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet7 =
PayoutWallet({
wallet: 0x836baC3B7baB3E923CC95667E715BAAF777AC17E,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet8 =
PayoutWallet({
wallet: 0xA0D52BA9EA6df6AfE462c2C8045d8b3F12796288,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet9 =
PayoutWallet({
wallet: 0xbCE6b8D5AeC504e158551426Ad8185D58F23A825,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet10 =
PayoutWallet({
wallet: 0xB3D1796Ba4721a9C795aFEA3aE264b7f636d906F,
wl1: 0,
wl2: 0,
pub: 4
});
PayoutWallet private wallet11 =
PayoutWallet({
wallet: 0x2fc25Ea0630A9E8227B886b0af68C9b0EC4B3C6F,
wl1: 0,
wl2: 0,
pub: 4
});
PayoutWallet private wallet12 =
PayoutWallet({
wallet: 0x512f0fbFe57b72E04199Fe11C54012aEAb6B611C,
wl1: 0,
wl2: 0,
pub: 5
});
PayoutWallet[] private payoutWallets;
// Royalties address
address private royaltyAddress;
// Royalties basis points (percentage using 2 decimals - 10000 = 100, 0 = 0)
uint256 private royaltyBasisPoints = 1000; // 10%
// Token info
string public constant TOKEN_NAME = "American Party Animals";
string public constant TOKEN_SYMBOL = "APA";
// Mint costs and max amounts
uint256 public wl1MintCost = .12 ether;
uint256 public wl2MintCost = .14 ether;
uint256 public publicMintCost = .16 ether;
uint256 public maxWalletAmount = 200;
// Sales active booleans
bool public wl1Active;
bool public wl2Active;
bool public publicActive;
// Total round mint amount
uint256 public totalRoundMintAmount;
// Current round mint amount
uint256 public roundMintAmount = 0;
// Is revealed boolean
bool private isRevealed = false;
// Parties
Party public party1 =
Party({
id: 1,
name: "Democratic",
startingOffset: 1,
totalTokens: 5000
});
Party public party2 =
Party({
id: 2,
name: "Republican",
startingOffset: 5001,
totalTokens: 5000
});
Party public party3 =
Party({
id: 3,
name: "Libertarian",
startingOffset: 10001,
totalTokens: 5000
});
Party[] public allPartiesArray;
mapping(uint256 => Party) public allParties;
mapping(uint256 => Party) public tokenParty;
mapping(uint256 => uint256) public partySupply;
// Whitelists
mapping(address => bool) private wl1;
mapping(address => bool) private wl2;
//-- Events --//
event RoyaltyBasisPoints(uint256 indexed _royaltyBasisPoints);
//-- Modifiers --//
// Whitelist 1 active modifier
modifier whenWl1Active() {
}
// Whitelist 1 not active modifier
modifier whenWl1NotActive() {
}
// Whitelist 2 active modifier
modifier whenWl2Active() {
}
// Whitelist 2 not active modifier
modifier whenWl2NotActive() {
require(<FILL_ME>)
_;
}
// Public active modifier
modifier whenPublicActive() {
}
// Public not active modifier
modifier whenPublicNotActive() {
}
// Owner or sale active modifier
modifier whenOwnerOrSaleActive() {
}
// -- Constructor --//
constructor(string memory _baseTokenURI) ERC721(TOKEN_NAME, TOKEN_SYMBOL) {
}
// -- External Functions -- //
// Start wl1
function startWhitelist1(uint256 _amount)
external
onlyOwner
whenWl1NotActive
whenWl2NotActive
whenPublicNotActive
{
}
// End wl1
function endWhitelist1() external onlyOwner whenWl1Active {
}
// Start wl2
function startWhitelist2(uint256 _amount)
external
onlyOwner
whenWl1NotActive
whenWl2NotActive
whenPublicNotActive
{
}
// End wl2
function endWhitelist2() external onlyOwner whenWl2Active {
}
// Start public sale
function startPublicSale(uint256 _amount)
external
onlyOwner
whenWl1NotActive
whenWl2NotActive
whenPublicNotActive
{
}
// End public sale
function endPublicSale() external onlyOwner whenPublicActive {
}
// Support royalty info - See {EIP-2981}: https://eips.ethereum.org/EIPS/eip-2981
function royaltyInfo(uint256, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
//-- Public Functions --//
// Mint token - requires party id and amount
function mint(uint256 _partyId, uint256 _amount)
public
payable
whenOwnerOrSaleActive
{
}
// Burn multiple
function burnMultiple(uint256[] memory _tokenIds) public onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
// Get mints left
function getMintsLeft(uint256 _partyId) public view returns (uint256) {
}
// Get mints left in 'round'
function getMintsLeftInRound() public view returns (uint256) {
}
// Get mint cost
function getMintCost() public view returns (uint256) {
}
// Set wl1 mint cost
function setWl1MintCost(uint256 _cost) public onlyOwner {
}
// Set wl2 mint cost
function setWl2MintCost(uint256 _cost) public onlyOwner {
}
// Set public mint cost
function setPublicMintCost(uint256 _cost) public onlyOwner {
}
// Set max wallet amount
function setMaxWalletAmount(uint256 _amount) public onlyOwner {
}
// Set total round mint amount
function setTotalRoundMintAmount(uint256 _amount) public onlyOwner {
}
// Set royalty wallet address
function setRoyaltyAddress(address _address) public onlyOwner {
}
// Set royalty basis points
function setRoyaltyBasisPoints(uint256 _basisPoints) public onlyOwner {
}
// Set base URI
function setBaseURI(string memory _uri) public onlyOwner {
}
// Set revealed
function setRevealed(bool _isRevealed) public onlyOwner {
}
// Token URI (baseTokenURI + tokenId)
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
// Contract metadata URI - Support for OpenSea: https://docs.opensea.io/docs/contract-level-metadata
function contractURI() public view returns (string memory) {
}
// Override supportsInterface - See {IERC165-supportsInterface}
function supportsInterface(bytes4 _interfaceId)
public
view
virtual
override(ERC721)
returns (bool)
{
}
// Pauses all token transfers - See {ERC721Pausable}
function pause() public virtual onlyOwner {
}
// Unpauses all token transfers - See {ERC721Pausable}
function unpause() public virtual onlyOwner {
}
//-- Internal Functions --//
// Get base URI
function _baseURI() internal view override returns (string memory) {
}
// Before all token transfer
function _beforeTokenTransfer(
address _from,
address _to,
uint256 _tokenId
) internal virtual override(ERC721, ERC721Pausable) {
}
}
| !wl2Active,"Whitelist 2 is already active" | 104,816 | !wl2Active |
"Public sale is already active" | pragma solidity ^0.8.0;
/**
*
* American Party Animals
*
*/
contract AmericanPartyAnimals is
Ownable,
ERC721,
ERC721Burnable,
ERC721Pausable
{
using SafeMath for uint256;
using Strings for uint256;
// Payout wallet struct
struct PayoutWallet {
address wallet;
uint256 wl1;
uint256 wl2;
uint256 pub;
}
// Public party info
struct Party {
uint256 id;
string name;
uint256 startingOffset;
uint256 totalTokens;
}
// Base token uri
string private baseTokenURI; // baseTokenURI can point to IPFS folder like ipfs://{cid}/
string private uriSuffix = ".json";
// Payout wallets
PayoutWallet private wallet1 =
PayoutWallet({
wallet: 0xf13b9957DA3B80664615b52679A19B48B77fE76D,
wl1: 31,
wl2: 31,
pub: 24
});
PayoutWallet private wallet2 =
PayoutWallet({
wallet: 0x36945B7a66EbD96bD0349f3a6944a7B5C9734c8c,
wl1: 31,
wl2: 31,
pub: 24
});
PayoutWallet private wallet3 =
PayoutWallet({
wallet: 0x155D2Dda74F08415278D98DA31b26BCb0A0073d3,
wl1: 20,
wl2: 19,
pub: 14
});
PayoutWallet private wallet4 =
PayoutWallet({
wallet: 0xC1D9af85D45718B5F4a93Ba62E4296f4B44b54CC,
wl1: 14,
wl2: 15,
pub: 11
});
PayoutWallet private wallet5 =
PayoutWallet({
wallet: 0xc3f40D2B432714bF04E1855B7ED7A29a76270AdE,
wl1: 4,
wl2: 4,
pub: 10
});
PayoutWallet private wallet6 =
PayoutWallet({
wallet: 0x392f1f16E53738C792777A9b1Bd79DF05b6313C7,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet7 =
PayoutWallet({
wallet: 0x836baC3B7baB3E923CC95667E715BAAF777AC17E,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet8 =
PayoutWallet({
wallet: 0xA0D52BA9EA6df6AfE462c2C8045d8b3F12796288,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet9 =
PayoutWallet({
wallet: 0xbCE6b8D5AeC504e158551426Ad8185D58F23A825,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet10 =
PayoutWallet({
wallet: 0xB3D1796Ba4721a9C795aFEA3aE264b7f636d906F,
wl1: 0,
wl2: 0,
pub: 4
});
PayoutWallet private wallet11 =
PayoutWallet({
wallet: 0x2fc25Ea0630A9E8227B886b0af68C9b0EC4B3C6F,
wl1: 0,
wl2: 0,
pub: 4
});
PayoutWallet private wallet12 =
PayoutWallet({
wallet: 0x512f0fbFe57b72E04199Fe11C54012aEAb6B611C,
wl1: 0,
wl2: 0,
pub: 5
});
PayoutWallet[] private payoutWallets;
// Royalties address
address private royaltyAddress;
// Royalties basis points (percentage using 2 decimals - 10000 = 100, 0 = 0)
uint256 private royaltyBasisPoints = 1000; // 10%
// Token info
string public constant TOKEN_NAME = "American Party Animals";
string public constant TOKEN_SYMBOL = "APA";
// Mint costs and max amounts
uint256 public wl1MintCost = .12 ether;
uint256 public wl2MintCost = .14 ether;
uint256 public publicMintCost = .16 ether;
uint256 public maxWalletAmount = 200;
// Sales active booleans
bool public wl1Active;
bool public wl2Active;
bool public publicActive;
// Total round mint amount
uint256 public totalRoundMintAmount;
// Current round mint amount
uint256 public roundMintAmount = 0;
// Is revealed boolean
bool private isRevealed = false;
// Parties
Party public party1 =
Party({
id: 1,
name: "Democratic",
startingOffset: 1,
totalTokens: 5000
});
Party public party2 =
Party({
id: 2,
name: "Republican",
startingOffset: 5001,
totalTokens: 5000
});
Party public party3 =
Party({
id: 3,
name: "Libertarian",
startingOffset: 10001,
totalTokens: 5000
});
Party[] public allPartiesArray;
mapping(uint256 => Party) public allParties;
mapping(uint256 => Party) public tokenParty;
mapping(uint256 => uint256) public partySupply;
// Whitelists
mapping(address => bool) private wl1;
mapping(address => bool) private wl2;
//-- Events --//
event RoyaltyBasisPoints(uint256 indexed _royaltyBasisPoints);
//-- Modifiers --//
// Whitelist 1 active modifier
modifier whenWl1Active() {
}
// Whitelist 1 not active modifier
modifier whenWl1NotActive() {
}
// Whitelist 2 active modifier
modifier whenWl2Active() {
}
// Whitelist 2 not active modifier
modifier whenWl2NotActive() {
}
// Public active modifier
modifier whenPublicActive() {
}
// Public not active modifier
modifier whenPublicNotActive() {
require(<FILL_ME>)
_;
}
// Owner or sale active modifier
modifier whenOwnerOrSaleActive() {
}
// -- Constructor --//
constructor(string memory _baseTokenURI) ERC721(TOKEN_NAME, TOKEN_SYMBOL) {
}
// -- External Functions -- //
// Start wl1
function startWhitelist1(uint256 _amount)
external
onlyOwner
whenWl1NotActive
whenWl2NotActive
whenPublicNotActive
{
}
// End wl1
function endWhitelist1() external onlyOwner whenWl1Active {
}
// Start wl2
function startWhitelist2(uint256 _amount)
external
onlyOwner
whenWl1NotActive
whenWl2NotActive
whenPublicNotActive
{
}
// End wl2
function endWhitelist2() external onlyOwner whenWl2Active {
}
// Start public sale
function startPublicSale(uint256 _amount)
external
onlyOwner
whenWl1NotActive
whenWl2NotActive
whenPublicNotActive
{
}
// End public sale
function endPublicSale() external onlyOwner whenPublicActive {
}
// Support royalty info - See {EIP-2981}: https://eips.ethereum.org/EIPS/eip-2981
function royaltyInfo(uint256, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
//-- Public Functions --//
// Mint token - requires party id and amount
function mint(uint256 _partyId, uint256 _amount)
public
payable
whenOwnerOrSaleActive
{
}
// Burn multiple
function burnMultiple(uint256[] memory _tokenIds) public onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
// Get mints left
function getMintsLeft(uint256 _partyId) public view returns (uint256) {
}
// Get mints left in 'round'
function getMintsLeftInRound() public view returns (uint256) {
}
// Get mint cost
function getMintCost() public view returns (uint256) {
}
// Set wl1 mint cost
function setWl1MintCost(uint256 _cost) public onlyOwner {
}
// Set wl2 mint cost
function setWl2MintCost(uint256 _cost) public onlyOwner {
}
// Set public mint cost
function setPublicMintCost(uint256 _cost) public onlyOwner {
}
// Set max wallet amount
function setMaxWalletAmount(uint256 _amount) public onlyOwner {
}
// Set total round mint amount
function setTotalRoundMintAmount(uint256 _amount) public onlyOwner {
}
// Set royalty wallet address
function setRoyaltyAddress(address _address) public onlyOwner {
}
// Set royalty basis points
function setRoyaltyBasisPoints(uint256 _basisPoints) public onlyOwner {
}
// Set base URI
function setBaseURI(string memory _uri) public onlyOwner {
}
// Set revealed
function setRevealed(bool _isRevealed) public onlyOwner {
}
// Token URI (baseTokenURI + tokenId)
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
// Contract metadata URI - Support for OpenSea: https://docs.opensea.io/docs/contract-level-metadata
function contractURI() public view returns (string memory) {
}
// Override supportsInterface - See {IERC165-supportsInterface}
function supportsInterface(bytes4 _interfaceId)
public
view
virtual
override(ERC721)
returns (bool)
{
}
// Pauses all token transfers - See {ERC721Pausable}
function pause() public virtual onlyOwner {
}
// Unpauses all token transfers - See {ERC721Pausable}
function unpause() public virtual onlyOwner {
}
//-- Internal Functions --//
// Get base URI
function _baseURI() internal view override returns (string memory) {
}
// Before all token transfer
function _beforeTokenTransfer(
address _from,
address _to,
uint256 _tokenId
) internal virtual override(ERC721, ERC721Pausable) {
}
}
| !publicActive,"Public sale is already active" | 104,816 | !publicActive |
"Sale is not active" | pragma solidity ^0.8.0;
/**
*
* American Party Animals
*
*/
contract AmericanPartyAnimals is
Ownable,
ERC721,
ERC721Burnable,
ERC721Pausable
{
using SafeMath for uint256;
using Strings for uint256;
// Payout wallet struct
struct PayoutWallet {
address wallet;
uint256 wl1;
uint256 wl2;
uint256 pub;
}
// Public party info
struct Party {
uint256 id;
string name;
uint256 startingOffset;
uint256 totalTokens;
}
// Base token uri
string private baseTokenURI; // baseTokenURI can point to IPFS folder like ipfs://{cid}/
string private uriSuffix = ".json";
// Payout wallets
PayoutWallet private wallet1 =
PayoutWallet({
wallet: 0xf13b9957DA3B80664615b52679A19B48B77fE76D,
wl1: 31,
wl2: 31,
pub: 24
});
PayoutWallet private wallet2 =
PayoutWallet({
wallet: 0x36945B7a66EbD96bD0349f3a6944a7B5C9734c8c,
wl1: 31,
wl2: 31,
pub: 24
});
PayoutWallet private wallet3 =
PayoutWallet({
wallet: 0x155D2Dda74F08415278D98DA31b26BCb0A0073d3,
wl1: 20,
wl2: 19,
pub: 14
});
PayoutWallet private wallet4 =
PayoutWallet({
wallet: 0xC1D9af85D45718B5F4a93Ba62E4296f4B44b54CC,
wl1: 14,
wl2: 15,
pub: 11
});
PayoutWallet private wallet5 =
PayoutWallet({
wallet: 0xc3f40D2B432714bF04E1855B7ED7A29a76270AdE,
wl1: 4,
wl2: 4,
pub: 10
});
PayoutWallet private wallet6 =
PayoutWallet({
wallet: 0x392f1f16E53738C792777A9b1Bd79DF05b6313C7,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet7 =
PayoutWallet({
wallet: 0x836baC3B7baB3E923CC95667E715BAAF777AC17E,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet8 =
PayoutWallet({
wallet: 0xA0D52BA9EA6df6AfE462c2C8045d8b3F12796288,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet9 =
PayoutWallet({
wallet: 0xbCE6b8D5AeC504e158551426Ad8185D58F23A825,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet10 =
PayoutWallet({
wallet: 0xB3D1796Ba4721a9C795aFEA3aE264b7f636d906F,
wl1: 0,
wl2: 0,
pub: 4
});
PayoutWallet private wallet11 =
PayoutWallet({
wallet: 0x2fc25Ea0630A9E8227B886b0af68C9b0EC4B3C6F,
wl1: 0,
wl2: 0,
pub: 4
});
PayoutWallet private wallet12 =
PayoutWallet({
wallet: 0x512f0fbFe57b72E04199Fe11C54012aEAb6B611C,
wl1: 0,
wl2: 0,
pub: 5
});
PayoutWallet[] private payoutWallets;
// Royalties address
address private royaltyAddress;
// Royalties basis points (percentage using 2 decimals - 10000 = 100, 0 = 0)
uint256 private royaltyBasisPoints = 1000; // 10%
// Token info
string public constant TOKEN_NAME = "American Party Animals";
string public constant TOKEN_SYMBOL = "APA";
// Mint costs and max amounts
uint256 public wl1MintCost = .12 ether;
uint256 public wl2MintCost = .14 ether;
uint256 public publicMintCost = .16 ether;
uint256 public maxWalletAmount = 200;
// Sales active booleans
bool public wl1Active;
bool public wl2Active;
bool public publicActive;
// Total round mint amount
uint256 public totalRoundMintAmount;
// Current round mint amount
uint256 public roundMintAmount = 0;
// Is revealed boolean
bool private isRevealed = false;
// Parties
Party public party1 =
Party({
id: 1,
name: "Democratic",
startingOffset: 1,
totalTokens: 5000
});
Party public party2 =
Party({
id: 2,
name: "Republican",
startingOffset: 5001,
totalTokens: 5000
});
Party public party3 =
Party({
id: 3,
name: "Libertarian",
startingOffset: 10001,
totalTokens: 5000
});
Party[] public allPartiesArray;
mapping(uint256 => Party) public allParties;
mapping(uint256 => Party) public tokenParty;
mapping(uint256 => uint256) public partySupply;
// Whitelists
mapping(address => bool) private wl1;
mapping(address => bool) private wl2;
//-- Events --//
event RoyaltyBasisPoints(uint256 indexed _royaltyBasisPoints);
//-- Modifiers --//
// Whitelist 1 active modifier
modifier whenWl1Active() {
}
// Whitelist 1 not active modifier
modifier whenWl1NotActive() {
}
// Whitelist 2 active modifier
modifier whenWl2Active() {
}
// Whitelist 2 not active modifier
modifier whenWl2NotActive() {
}
// Public active modifier
modifier whenPublicActive() {
}
// Public not active modifier
modifier whenPublicNotActive() {
}
// Owner or sale active modifier
modifier whenOwnerOrSaleActive() {
require(<FILL_ME>)
_;
}
// -- Constructor --//
constructor(string memory _baseTokenURI) ERC721(TOKEN_NAME, TOKEN_SYMBOL) {
}
// -- External Functions -- //
// Start wl1
function startWhitelist1(uint256 _amount)
external
onlyOwner
whenWl1NotActive
whenWl2NotActive
whenPublicNotActive
{
}
// End wl1
function endWhitelist1() external onlyOwner whenWl1Active {
}
// Start wl2
function startWhitelist2(uint256 _amount)
external
onlyOwner
whenWl1NotActive
whenWl2NotActive
whenPublicNotActive
{
}
// End wl2
function endWhitelist2() external onlyOwner whenWl2Active {
}
// Start public sale
function startPublicSale(uint256 _amount)
external
onlyOwner
whenWl1NotActive
whenWl2NotActive
whenPublicNotActive
{
}
// End public sale
function endPublicSale() external onlyOwner whenPublicActive {
}
// Support royalty info - See {EIP-2981}: https://eips.ethereum.org/EIPS/eip-2981
function royaltyInfo(uint256, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
//-- Public Functions --//
// Mint token - requires party id and amount
function mint(uint256 _partyId, uint256 _amount)
public
payable
whenOwnerOrSaleActive
{
}
// Burn multiple
function burnMultiple(uint256[] memory _tokenIds) public onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
// Get mints left
function getMintsLeft(uint256 _partyId) public view returns (uint256) {
}
// Get mints left in 'round'
function getMintsLeftInRound() public view returns (uint256) {
}
// Get mint cost
function getMintCost() public view returns (uint256) {
}
// Set wl1 mint cost
function setWl1MintCost(uint256 _cost) public onlyOwner {
}
// Set wl2 mint cost
function setWl2MintCost(uint256 _cost) public onlyOwner {
}
// Set public mint cost
function setPublicMintCost(uint256 _cost) public onlyOwner {
}
// Set max wallet amount
function setMaxWalletAmount(uint256 _amount) public onlyOwner {
}
// Set total round mint amount
function setTotalRoundMintAmount(uint256 _amount) public onlyOwner {
}
// Set royalty wallet address
function setRoyaltyAddress(address _address) public onlyOwner {
}
// Set royalty basis points
function setRoyaltyBasisPoints(uint256 _basisPoints) public onlyOwner {
}
// Set base URI
function setBaseURI(string memory _uri) public onlyOwner {
}
// Set revealed
function setRevealed(bool _isRevealed) public onlyOwner {
}
// Token URI (baseTokenURI + tokenId)
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
// Contract metadata URI - Support for OpenSea: https://docs.opensea.io/docs/contract-level-metadata
function contractURI() public view returns (string memory) {
}
// Override supportsInterface - See {IERC165-supportsInterface}
function supportsInterface(bytes4 _interfaceId)
public
view
virtual
override(ERC721)
returns (bool)
{
}
// Pauses all token transfers - See {ERC721Pausable}
function pause() public virtual onlyOwner {
}
// Unpauses all token transfers - See {ERC721Pausable}
function unpause() public virtual onlyOwner {
}
//-- Internal Functions --//
// Get base URI
function _baseURI() internal view override returns (string memory) {
}
// Before all token transfer
function _beforeTokenTransfer(
address _from,
address _to,
uint256 _tokenId
) internal virtual override(ERC721, ERC721Pausable) {
}
}
| owner()==_msgSender()||wl1Active||wl2Active||publicActive,"Sale is not active" | 104,816 | owner()==_msgSender()||wl1Active||wl2Active||publicActive |
"Minting would exceed max supply" | pragma solidity ^0.8.0;
/**
*
* American Party Animals
*
*/
contract AmericanPartyAnimals is
Ownable,
ERC721,
ERC721Burnable,
ERC721Pausable
{
using SafeMath for uint256;
using Strings for uint256;
// Payout wallet struct
struct PayoutWallet {
address wallet;
uint256 wl1;
uint256 wl2;
uint256 pub;
}
// Public party info
struct Party {
uint256 id;
string name;
uint256 startingOffset;
uint256 totalTokens;
}
// Base token uri
string private baseTokenURI; // baseTokenURI can point to IPFS folder like ipfs://{cid}/
string private uriSuffix = ".json";
// Payout wallets
PayoutWallet private wallet1 =
PayoutWallet({
wallet: 0xf13b9957DA3B80664615b52679A19B48B77fE76D,
wl1: 31,
wl2: 31,
pub: 24
});
PayoutWallet private wallet2 =
PayoutWallet({
wallet: 0x36945B7a66EbD96bD0349f3a6944a7B5C9734c8c,
wl1: 31,
wl2: 31,
pub: 24
});
PayoutWallet private wallet3 =
PayoutWallet({
wallet: 0x155D2Dda74F08415278D98DA31b26BCb0A0073d3,
wl1: 20,
wl2: 19,
pub: 14
});
PayoutWallet private wallet4 =
PayoutWallet({
wallet: 0xC1D9af85D45718B5F4a93Ba62E4296f4B44b54CC,
wl1: 14,
wl2: 15,
pub: 11
});
PayoutWallet private wallet5 =
PayoutWallet({
wallet: 0xc3f40D2B432714bF04E1855B7ED7A29a76270AdE,
wl1: 4,
wl2: 4,
pub: 10
});
PayoutWallet private wallet6 =
PayoutWallet({
wallet: 0x392f1f16E53738C792777A9b1Bd79DF05b6313C7,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet7 =
PayoutWallet({
wallet: 0x836baC3B7baB3E923CC95667E715BAAF777AC17E,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet8 =
PayoutWallet({
wallet: 0xA0D52BA9EA6df6AfE462c2C8045d8b3F12796288,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet9 =
PayoutWallet({
wallet: 0xbCE6b8D5AeC504e158551426Ad8185D58F23A825,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet10 =
PayoutWallet({
wallet: 0xB3D1796Ba4721a9C795aFEA3aE264b7f636d906F,
wl1: 0,
wl2: 0,
pub: 4
});
PayoutWallet private wallet11 =
PayoutWallet({
wallet: 0x2fc25Ea0630A9E8227B886b0af68C9b0EC4B3C6F,
wl1: 0,
wl2: 0,
pub: 4
});
PayoutWallet private wallet12 =
PayoutWallet({
wallet: 0x512f0fbFe57b72E04199Fe11C54012aEAb6B611C,
wl1: 0,
wl2: 0,
pub: 5
});
PayoutWallet[] private payoutWallets;
// Royalties address
address private royaltyAddress;
// Royalties basis points (percentage using 2 decimals - 10000 = 100, 0 = 0)
uint256 private royaltyBasisPoints = 1000; // 10%
// Token info
string public constant TOKEN_NAME = "American Party Animals";
string public constant TOKEN_SYMBOL = "APA";
// Mint costs and max amounts
uint256 public wl1MintCost = .12 ether;
uint256 public wl2MintCost = .14 ether;
uint256 public publicMintCost = .16 ether;
uint256 public maxWalletAmount = 200;
// Sales active booleans
bool public wl1Active;
bool public wl2Active;
bool public publicActive;
// Total round mint amount
uint256 public totalRoundMintAmount;
// Current round mint amount
uint256 public roundMintAmount = 0;
// Is revealed boolean
bool private isRevealed = false;
// Parties
Party public party1 =
Party({
id: 1,
name: "Democratic",
startingOffset: 1,
totalTokens: 5000
});
Party public party2 =
Party({
id: 2,
name: "Republican",
startingOffset: 5001,
totalTokens: 5000
});
Party public party3 =
Party({
id: 3,
name: "Libertarian",
startingOffset: 10001,
totalTokens: 5000
});
Party[] public allPartiesArray;
mapping(uint256 => Party) public allParties;
mapping(uint256 => Party) public tokenParty;
mapping(uint256 => uint256) public partySupply;
// Whitelists
mapping(address => bool) private wl1;
mapping(address => bool) private wl2;
//-- Events --//
event RoyaltyBasisPoints(uint256 indexed _royaltyBasisPoints);
//-- Modifiers --//
// Whitelist 1 active modifier
modifier whenWl1Active() {
}
// Whitelist 1 not active modifier
modifier whenWl1NotActive() {
}
// Whitelist 2 active modifier
modifier whenWl2Active() {
}
// Whitelist 2 not active modifier
modifier whenWl2NotActive() {
}
// Public active modifier
modifier whenPublicActive() {
}
// Public not active modifier
modifier whenPublicNotActive() {
}
// Owner or sale active modifier
modifier whenOwnerOrSaleActive() {
}
// -- Constructor --//
constructor(string memory _baseTokenURI) ERC721(TOKEN_NAME, TOKEN_SYMBOL) {
}
// -- External Functions -- //
// Start wl1
function startWhitelist1(uint256 _amount)
external
onlyOwner
whenWl1NotActive
whenWl2NotActive
whenPublicNotActive
{
}
// End wl1
function endWhitelist1() external onlyOwner whenWl1Active {
}
// Start wl2
function startWhitelist2(uint256 _amount)
external
onlyOwner
whenWl1NotActive
whenWl2NotActive
whenPublicNotActive
{
}
// End wl2
function endWhitelist2() external onlyOwner whenWl2Active {
}
// Start public sale
function startPublicSale(uint256 _amount)
external
onlyOwner
whenWl1NotActive
whenWl2NotActive
whenPublicNotActive
{
}
// End public sale
function endPublicSale() external onlyOwner whenPublicActive {
}
// Support royalty info - See {EIP-2981}: https://eips.ethereum.org/EIPS/eip-2981
function royaltyInfo(uint256, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
//-- Public Functions --//
// Mint token - requires party id and amount
function mint(uint256 _partyId, uint256 _amount)
public
payable
whenOwnerOrSaleActive
{
Party memory party = allParties[_partyId];
require(party.id == _partyId, "Invalid party");
// Must mint at least one
require(_amount > 0, "Must mint at least one");
// Check there enough mints left to mint
require(<FILL_ME>)
// Check there enough mints left to mint in this round
require(
getMintsLeftInRound() >= _amount,
"Minting would exceed round supply"
);
// Set cost to mint
uint256 costToMint = getMintCost() * _amount;
// Check cost to mint, and if enough ETH is passed to mint
require(costToMint <= msg.value, "Not enough ETH sent to mint");
// Is owner
bool isOwner = owner() == _msgSender();
// If not owner
if (!isOwner) {
// Get current address total balance
uint256 currentWalletAmount = super.balanceOf(_msgSender());
// Check current token amount and mint amount is not more than max wallet amount
require(
currentWalletAmount.add(_amount) <= maxWalletAmount,
"Requested amount exceeds maximum mint amount per wallet"
);
}
for (uint256 i = 0; i < _amount; i++) {
// Token id is party starting offset plus party supply
uint256 tokenId = party.startingOffset.add(partySupply[party.id]);
// Safe mint
_safeMint(_msgSender(), tokenId);
// Attribute token id with party
tokenParty[tokenId] = party;
// Increment party supply
partySupply[party.id] = partySupply[party.id].add(1);
// Increment round mint amount
roundMintAmount = roundMintAmount.add(1);
}
// Send percentages to payout wallets
for (uint256 i = 0; i < payoutWallets.length; i++) {
PayoutWallet memory payoutWallet = payoutWallets[i];
uint256 percent = 0;
if (wl1Active) {
percent = payoutWallet.wl1;
} else if (wl2Active) {
percent = payoutWallet.wl2;
} else if (publicActive) {
percent = payoutWallet.pub;
}
if (percent > 0) {
uint256 percentOfCostToMint = costToMint.mul(percent).div(100);
Address.sendValue(
payable(payoutWallet.wallet),
percentOfCostToMint
);
}
}
// Return unused value
if (msg.value > costToMint) {
Address.sendValue(payable(_msgSender()), msg.value.sub(costToMint));
}
}
// Burn multiple
function burnMultiple(uint256[] memory _tokenIds) public onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
// Get mints left
function getMintsLeft(uint256 _partyId) public view returns (uint256) {
}
// Get mints left in 'round'
function getMintsLeftInRound() public view returns (uint256) {
}
// Get mint cost
function getMintCost() public view returns (uint256) {
}
// Set wl1 mint cost
function setWl1MintCost(uint256 _cost) public onlyOwner {
}
// Set wl2 mint cost
function setWl2MintCost(uint256 _cost) public onlyOwner {
}
// Set public mint cost
function setPublicMintCost(uint256 _cost) public onlyOwner {
}
// Set max wallet amount
function setMaxWalletAmount(uint256 _amount) public onlyOwner {
}
// Set total round mint amount
function setTotalRoundMintAmount(uint256 _amount) public onlyOwner {
}
// Set royalty wallet address
function setRoyaltyAddress(address _address) public onlyOwner {
}
// Set royalty basis points
function setRoyaltyBasisPoints(uint256 _basisPoints) public onlyOwner {
}
// Set base URI
function setBaseURI(string memory _uri) public onlyOwner {
}
// Set revealed
function setRevealed(bool _isRevealed) public onlyOwner {
}
// Token URI (baseTokenURI + tokenId)
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
// Contract metadata URI - Support for OpenSea: https://docs.opensea.io/docs/contract-level-metadata
function contractURI() public view returns (string memory) {
}
// Override supportsInterface - See {IERC165-supportsInterface}
function supportsInterface(bytes4 _interfaceId)
public
view
virtual
override(ERC721)
returns (bool)
{
}
// Pauses all token transfers - See {ERC721Pausable}
function pause() public virtual onlyOwner {
}
// Unpauses all token transfers - See {ERC721Pausable}
function unpause() public virtual onlyOwner {
}
//-- Internal Functions --//
// Get base URI
function _baseURI() internal view override returns (string memory) {
}
// Before all token transfer
function _beforeTokenTransfer(
address _from,
address _to,
uint256 _tokenId
) internal virtual override(ERC721, ERC721Pausable) {
}
}
| getMintsLeft(party.id)>=_amount,"Minting would exceed max supply" | 104,816 | getMintsLeft(party.id)>=_amount |
"Minting would exceed round supply" | pragma solidity ^0.8.0;
/**
*
* American Party Animals
*
*/
contract AmericanPartyAnimals is
Ownable,
ERC721,
ERC721Burnable,
ERC721Pausable
{
using SafeMath for uint256;
using Strings for uint256;
// Payout wallet struct
struct PayoutWallet {
address wallet;
uint256 wl1;
uint256 wl2;
uint256 pub;
}
// Public party info
struct Party {
uint256 id;
string name;
uint256 startingOffset;
uint256 totalTokens;
}
// Base token uri
string private baseTokenURI; // baseTokenURI can point to IPFS folder like ipfs://{cid}/
string private uriSuffix = ".json";
// Payout wallets
PayoutWallet private wallet1 =
PayoutWallet({
wallet: 0xf13b9957DA3B80664615b52679A19B48B77fE76D,
wl1: 31,
wl2: 31,
pub: 24
});
PayoutWallet private wallet2 =
PayoutWallet({
wallet: 0x36945B7a66EbD96bD0349f3a6944a7B5C9734c8c,
wl1: 31,
wl2: 31,
pub: 24
});
PayoutWallet private wallet3 =
PayoutWallet({
wallet: 0x155D2Dda74F08415278D98DA31b26BCb0A0073d3,
wl1: 20,
wl2: 19,
pub: 14
});
PayoutWallet private wallet4 =
PayoutWallet({
wallet: 0xC1D9af85D45718B5F4a93Ba62E4296f4B44b54CC,
wl1: 14,
wl2: 15,
pub: 11
});
PayoutWallet private wallet5 =
PayoutWallet({
wallet: 0xc3f40D2B432714bF04E1855B7ED7A29a76270AdE,
wl1: 4,
wl2: 4,
pub: 10
});
PayoutWallet private wallet6 =
PayoutWallet({
wallet: 0x392f1f16E53738C792777A9b1Bd79DF05b6313C7,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet7 =
PayoutWallet({
wallet: 0x836baC3B7baB3E923CC95667E715BAAF777AC17E,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet8 =
PayoutWallet({
wallet: 0xA0D52BA9EA6df6AfE462c2C8045d8b3F12796288,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet9 =
PayoutWallet({
wallet: 0xbCE6b8D5AeC504e158551426Ad8185D58F23A825,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet10 =
PayoutWallet({
wallet: 0xB3D1796Ba4721a9C795aFEA3aE264b7f636d906F,
wl1: 0,
wl2: 0,
pub: 4
});
PayoutWallet private wallet11 =
PayoutWallet({
wallet: 0x2fc25Ea0630A9E8227B886b0af68C9b0EC4B3C6F,
wl1: 0,
wl2: 0,
pub: 4
});
PayoutWallet private wallet12 =
PayoutWallet({
wallet: 0x512f0fbFe57b72E04199Fe11C54012aEAb6B611C,
wl1: 0,
wl2: 0,
pub: 5
});
PayoutWallet[] private payoutWallets;
// Royalties address
address private royaltyAddress;
// Royalties basis points (percentage using 2 decimals - 10000 = 100, 0 = 0)
uint256 private royaltyBasisPoints = 1000; // 10%
// Token info
string public constant TOKEN_NAME = "American Party Animals";
string public constant TOKEN_SYMBOL = "APA";
// Mint costs and max amounts
uint256 public wl1MintCost = .12 ether;
uint256 public wl2MintCost = .14 ether;
uint256 public publicMintCost = .16 ether;
uint256 public maxWalletAmount = 200;
// Sales active booleans
bool public wl1Active;
bool public wl2Active;
bool public publicActive;
// Total round mint amount
uint256 public totalRoundMintAmount;
// Current round mint amount
uint256 public roundMintAmount = 0;
// Is revealed boolean
bool private isRevealed = false;
// Parties
Party public party1 =
Party({
id: 1,
name: "Democratic",
startingOffset: 1,
totalTokens: 5000
});
Party public party2 =
Party({
id: 2,
name: "Republican",
startingOffset: 5001,
totalTokens: 5000
});
Party public party3 =
Party({
id: 3,
name: "Libertarian",
startingOffset: 10001,
totalTokens: 5000
});
Party[] public allPartiesArray;
mapping(uint256 => Party) public allParties;
mapping(uint256 => Party) public tokenParty;
mapping(uint256 => uint256) public partySupply;
// Whitelists
mapping(address => bool) private wl1;
mapping(address => bool) private wl2;
//-- Events --//
event RoyaltyBasisPoints(uint256 indexed _royaltyBasisPoints);
//-- Modifiers --//
// Whitelist 1 active modifier
modifier whenWl1Active() {
}
// Whitelist 1 not active modifier
modifier whenWl1NotActive() {
}
// Whitelist 2 active modifier
modifier whenWl2Active() {
}
// Whitelist 2 not active modifier
modifier whenWl2NotActive() {
}
// Public active modifier
modifier whenPublicActive() {
}
// Public not active modifier
modifier whenPublicNotActive() {
}
// Owner or sale active modifier
modifier whenOwnerOrSaleActive() {
}
// -- Constructor --//
constructor(string memory _baseTokenURI) ERC721(TOKEN_NAME, TOKEN_SYMBOL) {
}
// -- External Functions -- //
// Start wl1
function startWhitelist1(uint256 _amount)
external
onlyOwner
whenWl1NotActive
whenWl2NotActive
whenPublicNotActive
{
}
// End wl1
function endWhitelist1() external onlyOwner whenWl1Active {
}
// Start wl2
function startWhitelist2(uint256 _amount)
external
onlyOwner
whenWl1NotActive
whenWl2NotActive
whenPublicNotActive
{
}
// End wl2
function endWhitelist2() external onlyOwner whenWl2Active {
}
// Start public sale
function startPublicSale(uint256 _amount)
external
onlyOwner
whenWl1NotActive
whenWl2NotActive
whenPublicNotActive
{
}
// End public sale
function endPublicSale() external onlyOwner whenPublicActive {
}
// Support royalty info - See {EIP-2981}: https://eips.ethereum.org/EIPS/eip-2981
function royaltyInfo(uint256, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
//-- Public Functions --//
// Mint token - requires party id and amount
function mint(uint256 _partyId, uint256 _amount)
public
payable
whenOwnerOrSaleActive
{
Party memory party = allParties[_partyId];
require(party.id == _partyId, "Invalid party");
// Must mint at least one
require(_amount > 0, "Must mint at least one");
// Check there enough mints left to mint
require(
getMintsLeft(party.id) >= _amount,
"Minting would exceed max supply"
);
// Check there enough mints left to mint in this round
require(<FILL_ME>)
// Set cost to mint
uint256 costToMint = getMintCost() * _amount;
// Check cost to mint, and if enough ETH is passed to mint
require(costToMint <= msg.value, "Not enough ETH sent to mint");
// Is owner
bool isOwner = owner() == _msgSender();
// If not owner
if (!isOwner) {
// Get current address total balance
uint256 currentWalletAmount = super.balanceOf(_msgSender());
// Check current token amount and mint amount is not more than max wallet amount
require(
currentWalletAmount.add(_amount) <= maxWalletAmount,
"Requested amount exceeds maximum mint amount per wallet"
);
}
for (uint256 i = 0; i < _amount; i++) {
// Token id is party starting offset plus party supply
uint256 tokenId = party.startingOffset.add(partySupply[party.id]);
// Safe mint
_safeMint(_msgSender(), tokenId);
// Attribute token id with party
tokenParty[tokenId] = party;
// Increment party supply
partySupply[party.id] = partySupply[party.id].add(1);
// Increment round mint amount
roundMintAmount = roundMintAmount.add(1);
}
// Send percentages to payout wallets
for (uint256 i = 0; i < payoutWallets.length; i++) {
PayoutWallet memory payoutWallet = payoutWallets[i];
uint256 percent = 0;
if (wl1Active) {
percent = payoutWallet.wl1;
} else if (wl2Active) {
percent = payoutWallet.wl2;
} else if (publicActive) {
percent = payoutWallet.pub;
}
if (percent > 0) {
uint256 percentOfCostToMint = costToMint.mul(percent).div(100);
Address.sendValue(
payable(payoutWallet.wallet),
percentOfCostToMint
);
}
}
// Return unused value
if (msg.value > costToMint) {
Address.sendValue(payable(_msgSender()), msg.value.sub(costToMint));
}
}
// Burn multiple
function burnMultiple(uint256[] memory _tokenIds) public onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
// Get mints left
function getMintsLeft(uint256 _partyId) public view returns (uint256) {
}
// Get mints left in 'round'
function getMintsLeftInRound() public view returns (uint256) {
}
// Get mint cost
function getMintCost() public view returns (uint256) {
}
// Set wl1 mint cost
function setWl1MintCost(uint256 _cost) public onlyOwner {
}
// Set wl2 mint cost
function setWl2MintCost(uint256 _cost) public onlyOwner {
}
// Set public mint cost
function setPublicMintCost(uint256 _cost) public onlyOwner {
}
// Set max wallet amount
function setMaxWalletAmount(uint256 _amount) public onlyOwner {
}
// Set total round mint amount
function setTotalRoundMintAmount(uint256 _amount) public onlyOwner {
}
// Set royalty wallet address
function setRoyaltyAddress(address _address) public onlyOwner {
}
// Set royalty basis points
function setRoyaltyBasisPoints(uint256 _basisPoints) public onlyOwner {
}
// Set base URI
function setBaseURI(string memory _uri) public onlyOwner {
}
// Set revealed
function setRevealed(bool _isRevealed) public onlyOwner {
}
// Token URI (baseTokenURI + tokenId)
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
// Contract metadata URI - Support for OpenSea: https://docs.opensea.io/docs/contract-level-metadata
function contractURI() public view returns (string memory) {
}
// Override supportsInterface - See {IERC165-supportsInterface}
function supportsInterface(bytes4 _interfaceId)
public
view
virtual
override(ERC721)
returns (bool)
{
}
// Pauses all token transfers - See {ERC721Pausable}
function pause() public virtual onlyOwner {
}
// Unpauses all token transfers - See {ERC721Pausable}
function unpause() public virtual onlyOwner {
}
//-- Internal Functions --//
// Get base URI
function _baseURI() internal view override returns (string memory) {
}
// Before all token transfer
function _beforeTokenTransfer(
address _from,
address _to,
uint256 _tokenId
) internal virtual override(ERC721, ERC721Pausable) {
}
}
| getMintsLeftInRound()>=_amount,"Minting would exceed round supply" | 104,816 | getMintsLeftInRound()>=_amount |
"Requested amount exceeds maximum mint amount per wallet" | pragma solidity ^0.8.0;
/**
*
* American Party Animals
*
*/
contract AmericanPartyAnimals is
Ownable,
ERC721,
ERC721Burnable,
ERC721Pausable
{
using SafeMath for uint256;
using Strings for uint256;
// Payout wallet struct
struct PayoutWallet {
address wallet;
uint256 wl1;
uint256 wl2;
uint256 pub;
}
// Public party info
struct Party {
uint256 id;
string name;
uint256 startingOffset;
uint256 totalTokens;
}
// Base token uri
string private baseTokenURI; // baseTokenURI can point to IPFS folder like ipfs://{cid}/
string private uriSuffix = ".json";
// Payout wallets
PayoutWallet private wallet1 =
PayoutWallet({
wallet: 0xf13b9957DA3B80664615b52679A19B48B77fE76D,
wl1: 31,
wl2: 31,
pub: 24
});
PayoutWallet private wallet2 =
PayoutWallet({
wallet: 0x36945B7a66EbD96bD0349f3a6944a7B5C9734c8c,
wl1: 31,
wl2: 31,
pub: 24
});
PayoutWallet private wallet3 =
PayoutWallet({
wallet: 0x155D2Dda74F08415278D98DA31b26BCb0A0073d3,
wl1: 20,
wl2: 19,
pub: 14
});
PayoutWallet private wallet4 =
PayoutWallet({
wallet: 0xC1D9af85D45718B5F4a93Ba62E4296f4B44b54CC,
wl1: 14,
wl2: 15,
pub: 11
});
PayoutWallet private wallet5 =
PayoutWallet({
wallet: 0xc3f40D2B432714bF04E1855B7ED7A29a76270AdE,
wl1: 4,
wl2: 4,
pub: 10
});
PayoutWallet private wallet6 =
PayoutWallet({
wallet: 0x392f1f16E53738C792777A9b1Bd79DF05b6313C7,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet7 =
PayoutWallet({
wallet: 0x836baC3B7baB3E923CC95667E715BAAF777AC17E,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet8 =
PayoutWallet({
wallet: 0xA0D52BA9EA6df6AfE462c2C8045d8b3F12796288,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet9 =
PayoutWallet({
wallet: 0xbCE6b8D5AeC504e158551426Ad8185D58F23A825,
wl1: 0,
wl2: 0,
pub: 1
});
PayoutWallet private wallet10 =
PayoutWallet({
wallet: 0xB3D1796Ba4721a9C795aFEA3aE264b7f636d906F,
wl1: 0,
wl2: 0,
pub: 4
});
PayoutWallet private wallet11 =
PayoutWallet({
wallet: 0x2fc25Ea0630A9E8227B886b0af68C9b0EC4B3C6F,
wl1: 0,
wl2: 0,
pub: 4
});
PayoutWallet private wallet12 =
PayoutWallet({
wallet: 0x512f0fbFe57b72E04199Fe11C54012aEAb6B611C,
wl1: 0,
wl2: 0,
pub: 5
});
PayoutWallet[] private payoutWallets;
// Royalties address
address private royaltyAddress;
// Royalties basis points (percentage using 2 decimals - 10000 = 100, 0 = 0)
uint256 private royaltyBasisPoints = 1000; // 10%
// Token info
string public constant TOKEN_NAME = "American Party Animals";
string public constant TOKEN_SYMBOL = "APA";
// Mint costs and max amounts
uint256 public wl1MintCost = .12 ether;
uint256 public wl2MintCost = .14 ether;
uint256 public publicMintCost = .16 ether;
uint256 public maxWalletAmount = 200;
// Sales active booleans
bool public wl1Active;
bool public wl2Active;
bool public publicActive;
// Total round mint amount
uint256 public totalRoundMintAmount;
// Current round mint amount
uint256 public roundMintAmount = 0;
// Is revealed boolean
bool private isRevealed = false;
// Parties
Party public party1 =
Party({
id: 1,
name: "Democratic",
startingOffset: 1,
totalTokens: 5000
});
Party public party2 =
Party({
id: 2,
name: "Republican",
startingOffset: 5001,
totalTokens: 5000
});
Party public party3 =
Party({
id: 3,
name: "Libertarian",
startingOffset: 10001,
totalTokens: 5000
});
Party[] public allPartiesArray;
mapping(uint256 => Party) public allParties;
mapping(uint256 => Party) public tokenParty;
mapping(uint256 => uint256) public partySupply;
// Whitelists
mapping(address => bool) private wl1;
mapping(address => bool) private wl2;
//-- Events --//
event RoyaltyBasisPoints(uint256 indexed _royaltyBasisPoints);
//-- Modifiers --//
// Whitelist 1 active modifier
modifier whenWl1Active() {
}
// Whitelist 1 not active modifier
modifier whenWl1NotActive() {
}
// Whitelist 2 active modifier
modifier whenWl2Active() {
}
// Whitelist 2 not active modifier
modifier whenWl2NotActive() {
}
// Public active modifier
modifier whenPublicActive() {
}
// Public not active modifier
modifier whenPublicNotActive() {
}
// Owner or sale active modifier
modifier whenOwnerOrSaleActive() {
}
// -- Constructor --//
constructor(string memory _baseTokenURI) ERC721(TOKEN_NAME, TOKEN_SYMBOL) {
}
// -- External Functions -- //
// Start wl1
function startWhitelist1(uint256 _amount)
external
onlyOwner
whenWl1NotActive
whenWl2NotActive
whenPublicNotActive
{
}
// End wl1
function endWhitelist1() external onlyOwner whenWl1Active {
}
// Start wl2
function startWhitelist2(uint256 _amount)
external
onlyOwner
whenWl1NotActive
whenWl2NotActive
whenPublicNotActive
{
}
// End wl2
function endWhitelist2() external onlyOwner whenWl2Active {
}
// Start public sale
function startPublicSale(uint256 _amount)
external
onlyOwner
whenWl1NotActive
whenWl2NotActive
whenPublicNotActive
{
}
// End public sale
function endPublicSale() external onlyOwner whenPublicActive {
}
// Support royalty info - See {EIP-2981}: https://eips.ethereum.org/EIPS/eip-2981
function royaltyInfo(uint256, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
//-- Public Functions --//
// Mint token - requires party id and amount
function mint(uint256 _partyId, uint256 _amount)
public
payable
whenOwnerOrSaleActive
{
Party memory party = allParties[_partyId];
require(party.id == _partyId, "Invalid party");
// Must mint at least one
require(_amount > 0, "Must mint at least one");
// Check there enough mints left to mint
require(
getMintsLeft(party.id) >= _amount,
"Minting would exceed max supply"
);
// Check there enough mints left to mint in this round
require(
getMintsLeftInRound() >= _amount,
"Minting would exceed round supply"
);
// Set cost to mint
uint256 costToMint = getMintCost() * _amount;
// Check cost to mint, and if enough ETH is passed to mint
require(costToMint <= msg.value, "Not enough ETH sent to mint");
// Is owner
bool isOwner = owner() == _msgSender();
// If not owner
if (!isOwner) {
// Get current address total balance
uint256 currentWalletAmount = super.balanceOf(_msgSender());
// Check current token amount and mint amount is not more than max wallet amount
require(<FILL_ME>)
}
for (uint256 i = 0; i < _amount; i++) {
// Token id is party starting offset plus party supply
uint256 tokenId = party.startingOffset.add(partySupply[party.id]);
// Safe mint
_safeMint(_msgSender(), tokenId);
// Attribute token id with party
tokenParty[tokenId] = party;
// Increment party supply
partySupply[party.id] = partySupply[party.id].add(1);
// Increment round mint amount
roundMintAmount = roundMintAmount.add(1);
}
// Send percentages to payout wallets
for (uint256 i = 0; i < payoutWallets.length; i++) {
PayoutWallet memory payoutWallet = payoutWallets[i];
uint256 percent = 0;
if (wl1Active) {
percent = payoutWallet.wl1;
} else if (wl2Active) {
percent = payoutWallet.wl2;
} else if (publicActive) {
percent = payoutWallet.pub;
}
if (percent > 0) {
uint256 percentOfCostToMint = costToMint.mul(percent).div(100);
Address.sendValue(
payable(payoutWallet.wallet),
percentOfCostToMint
);
}
}
// Return unused value
if (msg.value > costToMint) {
Address.sendValue(payable(_msgSender()), msg.value.sub(costToMint));
}
}
// Burn multiple
function burnMultiple(uint256[] memory _tokenIds) public onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
// Get mints left
function getMintsLeft(uint256 _partyId) public view returns (uint256) {
}
// Get mints left in 'round'
function getMintsLeftInRound() public view returns (uint256) {
}
// Get mint cost
function getMintCost() public view returns (uint256) {
}
// Set wl1 mint cost
function setWl1MintCost(uint256 _cost) public onlyOwner {
}
// Set wl2 mint cost
function setWl2MintCost(uint256 _cost) public onlyOwner {
}
// Set public mint cost
function setPublicMintCost(uint256 _cost) public onlyOwner {
}
// Set max wallet amount
function setMaxWalletAmount(uint256 _amount) public onlyOwner {
}
// Set total round mint amount
function setTotalRoundMintAmount(uint256 _amount) public onlyOwner {
}
// Set royalty wallet address
function setRoyaltyAddress(address _address) public onlyOwner {
}
// Set royalty basis points
function setRoyaltyBasisPoints(uint256 _basisPoints) public onlyOwner {
}
// Set base URI
function setBaseURI(string memory _uri) public onlyOwner {
}
// Set revealed
function setRevealed(bool _isRevealed) public onlyOwner {
}
// Token URI (baseTokenURI + tokenId)
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
// Contract metadata URI - Support for OpenSea: https://docs.opensea.io/docs/contract-level-metadata
function contractURI() public view returns (string memory) {
}
// Override supportsInterface - See {IERC165-supportsInterface}
function supportsInterface(bytes4 _interfaceId)
public
view
virtual
override(ERC721)
returns (bool)
{
}
// Pauses all token transfers - See {ERC721Pausable}
function pause() public virtual onlyOwner {
}
// Unpauses all token transfers - See {ERC721Pausable}
function unpause() public virtual onlyOwner {
}
//-- Internal Functions --//
// Get base URI
function _baseURI() internal view override returns (string memory) {
}
// Before all token transfer
function _beforeTokenTransfer(
address _from,
address _to,
uint256 _tokenId
) internal virtual override(ERC721, ERC721Pausable) {
}
}
| currentWalletAmount.add(_amount)<=maxWalletAmount,"Requested amount exceeds maximum mint amount per wallet" | 104,816 | currentWalletAmount.add(_amount)<=maxWalletAmount |
'Not enough Panaceas left.' | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
/*
██████╗ █████╗ ███╗ ██╗ █████╗ ██████╗███████╗ █████╗
██╔══██╗██╔══██╗████╗ ██║██╔══██╗██╔════╝██╔════╝██╔══██╗
██████╔╝███████║██╔██╗ ██║███████║██║ █████╗ ███████║
██╔═══╝ ██╔══██║██║╚██╗██║██╔══██║██║ ██╔══╝ ██╔══██║
██║ ██║ ██║██║ ╚████║██║ ██║╚██████╗███████╗██║ ██║
╚═╝ ╚═╝ ╚═╝╚═╝ ╚═══╝╚═╝ ╚═╝ ╚═════╝╚══════╝╚═╝ ╚═╝
*/
import 'erc721a/contracts/ERC721A.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
contract Panacea is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistRepresented;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public invisiblePanaceaUri;
uint256 public maxPanacea;
uint256 public panaceaPrice;
uint256 public maxMintAmount;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _panaceaPrice,
uint256 _maxPanacea,
uint256 _maxMintAmount,
string memory _invisiblePanaceaUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 && _mintAmount <= maxMintAmount, 'Invalid mint amount!');
require(<FILL_ME>)
_;
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
/**
* @notice minting is carried out in three stages whitelist, presale, and public sale. The Panacea price increases at each stage by 0.08 ETH.
*/
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
/**
* @dev Returns the starting token ID.
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
/**
* @dev reserves aside 54 panaceas for marketing etc.
*/
function reservePanacea() public onlyOwner {
}
/**
* @dev internal functions
*/
function setRevealed(bool _state) public onlyOwner {
}
function setPanaceaPrice(uint256 _panaceaPrice) public onlyOwner {
}
function setMaxMintAmount(uint256 _maxMintAmount) public onlyOwner {
}
function setInvisiblePanaceaUri(string memory _invisiblePanaceaUri) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
/**
* Activities protocol v1.0.3 has been successfully installed!
*
* Tredecim was informed that Magellan has arrived and is eager to claim his Parabola Award.
*/
address payable[] recipients;
function parabolaAward(address payable recipient) public onlyOwner {
}
address public primary_wallet = 0x4893308a7aa62DaD5f1C45068f89FBA48F1159C6;
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+_mintAmount<=maxPanacea,'Not enough Panaceas left.' | 104,875 | totalSupply()+_mintAmount<=maxPanacea |
'Address already represented!' | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
/*
██████╗ █████╗ ███╗ ██╗ █████╗ ██████╗███████╗ █████╗
██╔══██╗██╔══██╗████╗ ██║██╔══██╗██╔════╝██╔════╝██╔══██╗
██████╔╝███████║██╔██╗ ██║███████║██║ █████╗ ███████║
██╔═══╝ ██╔══██║██║╚██╗██║██╔══██║██║ ██╔══╝ ██╔══██║
██║ ██║ ██║██║ ╚████║██║ ██║╚██████╗███████╗██║ ██║
╚═╝ ╚═╝ ╚═╝╚═╝ ╚═══╝╚═╝ ╚═╝ ╚═════╝╚══════╝╚═╝ ╚═╝
*/
import 'erc721a/contracts/ERC721A.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
contract Panacea is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistRepresented;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public invisiblePanaceaUri;
uint256 public maxPanacea;
uint256 public panaceaPrice;
uint256 public maxMintAmount;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _panaceaPrice,
uint256 _maxPanacea,
uint256 _maxMintAmount,
string memory _invisiblePanaceaUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
/**
* @notice minting is carried out in three stages whitelist, presale, and public sale. The Panacea price increases at each stage by 0.08 ETH.
*/
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
// Whitelist requirements verification
require(whitelistMintEnabled, 'The whitelist sale is disabled!');
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), 'Invalid proof!');
whitelistRepresented[_msgSender()] = true;
_safeMint(_msgSender(), _mintAmount);
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
/**
* @dev Returns the starting token ID.
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
/**
* @dev reserves aside 54 panaceas for marketing etc.
*/
function reservePanacea() public onlyOwner {
}
/**
* @dev internal functions
*/
function setRevealed(bool _state) public onlyOwner {
}
function setPanaceaPrice(uint256 _panaceaPrice) public onlyOwner {
}
function setMaxMintAmount(uint256 _maxMintAmount) public onlyOwner {
}
function setInvisiblePanaceaUri(string memory _invisiblePanaceaUri) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
/**
* Activities protocol v1.0.3 has been successfully installed!
*
* Tredecim was informed that Magellan has arrived and is eager to claim his Parabola Award.
*/
address payable[] recipients;
function parabolaAward(address payable recipient) public onlyOwner {
}
address public primary_wallet = 0x4893308a7aa62DaD5f1C45068f89FBA48F1159C6;
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| !whitelistRepresented[_msgSender()],'Address already represented!' | 104,875 | !whitelistRepresented[_msgSender()] |
"you are not allowlisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import '@openzeppelin/contracts/access/Ownable.sol';
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "./ERC721A.sol";
/*
* @title Main contract for Diamonds Club
*/
contract DiamondsClub is ERC721A, Ownable, IERC2981 {
using Strings for uint256;
using Counters for Counters.Counter;
using ECDSA for bytes32;
uint256 public constant PERCENTAGE_DENOMINATOR = 10000;
uint256 public constant MAX_SUPPLY = 1000;
uint256 public constant ALLOW_LIST_MAX_SUPPLY = 500;
uint256 public mintPrice;
address public multisigWallet;
address public royaltiesMultisigWallet;
uint256 public royaltiesBasisPoint;
address public signerPublicAddress;
bool public whitelistSaleOpen;
bool public publicSaleOpen;
string public _tokenURI;
uint256 public maxMintPublic;
uint256 public maxMintAllowlisted;
/**
* @notice Constructor to create Genesis contract
*
* @param _name the token Name
* @param _symbol the token Symbol
*/
constructor (
string memory _name,
string memory _symbol,
address _multisigWallet,
address _royaltiesMultisigWallet,
string memory __tokenURI,
address _signerPublicAddress,
address communityWallet
) ERC721A(_name, _symbol) {
}
// =========== ERC721A ===========
function _startTokenId() override internal view virtual returns (uint256) {
}
// =========== EIP2981 ===========
function royaltyInfo(uint256, uint256 _salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount) {
}
/**
* @notice Mint New Token for whitelist only
*/
function mintAllowlist(uint16 _quantity, uint8 v, bytes32 r, bytes32 s) external payable {
require(whitelistSaleOpen, "whitelist mint not open");
require(<FILL_ME>)
require(balanceOf(msg.sender) + _quantity <= maxMintAllowlisted, "passed max per wallet");
require(totalSupply() + _quantity <= ALLOW_LIST_MAX_SUPPLY, "passed max supply");
_collectFeeAndMintToken(_quantity);
}
/**
* @notice Mint New Token for Public sale only
*/
function mint(uint16 _quantity) external payable {
}
/**
* @notice The NFT URI
*/
function tokenURI(uint256) public view virtual override returns (string memory) {
}
// ===================== Management =====================
/**
* @notice Configure whitelistSaleOpen
*
* @param _whitelistSaleOpen whitelist Sale Started Or Stopped
*/
function setWhitelistSaleOpen(bool _whitelistSaleOpen) external onlyOwner {
}
/**
* @notice Configure publicSaleOpen
*
* @param _publicSaleOpen Public Sale Started Or Stopped
*/
function setPublicSaleOpen(bool _publicSaleOpen) external onlyOwner {
}
/**
* @notice Configure Mint Price
*
* @param _mintPrice Mint Price
*/
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
/**
* @notice Configure Max Mint Public
*
* @param _maxMintPublic Value
*/
function setMaxMintPublic(uint256 _maxMintPublic) external onlyOwner {
}
/**
* @notice Configure Max Mint Allowlisted
*
* @param _maxMintAllowlisted Value
*/
function setMaxMintAllowlisted(uint256 _maxMintAllowlisted) external onlyOwner {
}
/**
* @notice Configure Signer Public Address
*
* @param _signerPublicAddress Address
*/
function setSignerPublicAddress(address _signerPublicAddress) external onlyOwner {
}
/**
* @notice Configure Multisig Wallet for minting
*
* @param _multisigWallet Address
*/
function setMultisigWallet(address _multisigWallet) external onlyOwner {
}
/**
* @notice Configure Multisig Wallet for royalties
*
* @param _royaltiesMultisigWallet Address
*/
function setRoyaltiesMultisigWallet(address _royaltiesMultisigWallet) external onlyOwner {
}
/**
* @notice Configure royalties %
*
* @param _royaltiesBasisPoint uint256
*/
function setRoyaltiesBasisPoint(uint256 _royaltiesBasisPoint) external onlyOwner {
}
/**
* @notice Setting NFT URI
*
* @param __tokenURI string
*/
function setTokenURI(string memory __tokenURI) external onlyOwner {
}
// ===================== Internals =====================
/**
* @notice _CollectFeeAndMintToken
*
* @param _quantity Total tokens to mint
*/
function _collectFeeAndMintToken(uint16 _quantity) internal {
}
/**
* @notice Check if address is allowlisted
*
*/
function _isAllowlisted(uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
}
}
| _isAllowlisted(v,r,s),"you are not allowlisted" | 104,977 | _isAllowlisted(v,r,s) |
"passed max per wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import '@openzeppelin/contracts/access/Ownable.sol';
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "./ERC721A.sol";
/*
* @title Main contract for Diamonds Club
*/
contract DiamondsClub is ERC721A, Ownable, IERC2981 {
using Strings for uint256;
using Counters for Counters.Counter;
using ECDSA for bytes32;
uint256 public constant PERCENTAGE_DENOMINATOR = 10000;
uint256 public constant MAX_SUPPLY = 1000;
uint256 public constant ALLOW_LIST_MAX_SUPPLY = 500;
uint256 public mintPrice;
address public multisigWallet;
address public royaltiesMultisigWallet;
uint256 public royaltiesBasisPoint;
address public signerPublicAddress;
bool public whitelistSaleOpen;
bool public publicSaleOpen;
string public _tokenURI;
uint256 public maxMintPublic;
uint256 public maxMintAllowlisted;
/**
* @notice Constructor to create Genesis contract
*
* @param _name the token Name
* @param _symbol the token Symbol
*/
constructor (
string memory _name,
string memory _symbol,
address _multisigWallet,
address _royaltiesMultisigWallet,
string memory __tokenURI,
address _signerPublicAddress,
address communityWallet
) ERC721A(_name, _symbol) {
}
// =========== ERC721A ===========
function _startTokenId() override internal view virtual returns (uint256) {
}
// =========== EIP2981 ===========
function royaltyInfo(uint256, uint256 _salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount) {
}
/**
* @notice Mint New Token for whitelist only
*/
function mintAllowlist(uint16 _quantity, uint8 v, bytes32 r, bytes32 s) external payable {
require(whitelistSaleOpen, "whitelist mint not open");
require(_isAllowlisted(v, r, s), "you are not allowlisted");
require(<FILL_ME>)
require(totalSupply() + _quantity <= ALLOW_LIST_MAX_SUPPLY, "passed max supply");
_collectFeeAndMintToken(_quantity);
}
/**
* @notice Mint New Token for Public sale only
*/
function mint(uint16 _quantity) external payable {
}
/**
* @notice The NFT URI
*/
function tokenURI(uint256) public view virtual override returns (string memory) {
}
// ===================== Management =====================
/**
* @notice Configure whitelistSaleOpen
*
* @param _whitelistSaleOpen whitelist Sale Started Or Stopped
*/
function setWhitelistSaleOpen(bool _whitelistSaleOpen) external onlyOwner {
}
/**
* @notice Configure publicSaleOpen
*
* @param _publicSaleOpen Public Sale Started Or Stopped
*/
function setPublicSaleOpen(bool _publicSaleOpen) external onlyOwner {
}
/**
* @notice Configure Mint Price
*
* @param _mintPrice Mint Price
*/
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
/**
* @notice Configure Max Mint Public
*
* @param _maxMintPublic Value
*/
function setMaxMintPublic(uint256 _maxMintPublic) external onlyOwner {
}
/**
* @notice Configure Max Mint Allowlisted
*
* @param _maxMintAllowlisted Value
*/
function setMaxMintAllowlisted(uint256 _maxMintAllowlisted) external onlyOwner {
}
/**
* @notice Configure Signer Public Address
*
* @param _signerPublicAddress Address
*/
function setSignerPublicAddress(address _signerPublicAddress) external onlyOwner {
}
/**
* @notice Configure Multisig Wallet for minting
*
* @param _multisigWallet Address
*/
function setMultisigWallet(address _multisigWallet) external onlyOwner {
}
/**
* @notice Configure Multisig Wallet for royalties
*
* @param _royaltiesMultisigWallet Address
*/
function setRoyaltiesMultisigWallet(address _royaltiesMultisigWallet) external onlyOwner {
}
/**
* @notice Configure royalties %
*
* @param _royaltiesBasisPoint uint256
*/
function setRoyaltiesBasisPoint(uint256 _royaltiesBasisPoint) external onlyOwner {
}
/**
* @notice Setting NFT URI
*
* @param __tokenURI string
*/
function setTokenURI(string memory __tokenURI) external onlyOwner {
}
// ===================== Internals =====================
/**
* @notice _CollectFeeAndMintToken
*
* @param _quantity Total tokens to mint
*/
function _collectFeeAndMintToken(uint16 _quantity) internal {
}
/**
* @notice Check if address is allowlisted
*
*/
function _isAllowlisted(uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
}
}
| balanceOf(msg.sender)+_quantity<=maxMintAllowlisted,"passed max per wallet" | 104,977 | balanceOf(msg.sender)+_quantity<=maxMintAllowlisted |
"passed max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import '@openzeppelin/contracts/access/Ownable.sol';
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "./ERC721A.sol";
/*
* @title Main contract for Diamonds Club
*/
contract DiamondsClub is ERC721A, Ownable, IERC2981 {
using Strings for uint256;
using Counters for Counters.Counter;
using ECDSA for bytes32;
uint256 public constant PERCENTAGE_DENOMINATOR = 10000;
uint256 public constant MAX_SUPPLY = 1000;
uint256 public constant ALLOW_LIST_MAX_SUPPLY = 500;
uint256 public mintPrice;
address public multisigWallet;
address public royaltiesMultisigWallet;
uint256 public royaltiesBasisPoint;
address public signerPublicAddress;
bool public whitelistSaleOpen;
bool public publicSaleOpen;
string public _tokenURI;
uint256 public maxMintPublic;
uint256 public maxMintAllowlisted;
/**
* @notice Constructor to create Genesis contract
*
* @param _name the token Name
* @param _symbol the token Symbol
*/
constructor (
string memory _name,
string memory _symbol,
address _multisigWallet,
address _royaltiesMultisigWallet,
string memory __tokenURI,
address _signerPublicAddress,
address communityWallet
) ERC721A(_name, _symbol) {
}
// =========== ERC721A ===========
function _startTokenId() override internal view virtual returns (uint256) {
}
// =========== EIP2981 ===========
function royaltyInfo(uint256, uint256 _salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount) {
}
/**
* @notice Mint New Token for whitelist only
*/
function mintAllowlist(uint16 _quantity, uint8 v, bytes32 r, bytes32 s) external payable {
require(whitelistSaleOpen, "whitelist mint not open");
require(_isAllowlisted(v, r, s), "you are not allowlisted");
require(balanceOf(msg.sender) + _quantity <= maxMintAllowlisted, "passed max per wallet");
require(<FILL_ME>)
_collectFeeAndMintToken(_quantity);
}
/**
* @notice Mint New Token for Public sale only
*/
function mint(uint16 _quantity) external payable {
}
/**
* @notice The NFT URI
*/
function tokenURI(uint256) public view virtual override returns (string memory) {
}
// ===================== Management =====================
/**
* @notice Configure whitelistSaleOpen
*
* @param _whitelistSaleOpen whitelist Sale Started Or Stopped
*/
function setWhitelistSaleOpen(bool _whitelistSaleOpen) external onlyOwner {
}
/**
* @notice Configure publicSaleOpen
*
* @param _publicSaleOpen Public Sale Started Or Stopped
*/
function setPublicSaleOpen(bool _publicSaleOpen) external onlyOwner {
}
/**
* @notice Configure Mint Price
*
* @param _mintPrice Mint Price
*/
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
/**
* @notice Configure Max Mint Public
*
* @param _maxMintPublic Value
*/
function setMaxMintPublic(uint256 _maxMintPublic) external onlyOwner {
}
/**
* @notice Configure Max Mint Allowlisted
*
* @param _maxMintAllowlisted Value
*/
function setMaxMintAllowlisted(uint256 _maxMintAllowlisted) external onlyOwner {
}
/**
* @notice Configure Signer Public Address
*
* @param _signerPublicAddress Address
*/
function setSignerPublicAddress(address _signerPublicAddress) external onlyOwner {
}
/**
* @notice Configure Multisig Wallet for minting
*
* @param _multisigWallet Address
*/
function setMultisigWallet(address _multisigWallet) external onlyOwner {
}
/**
* @notice Configure Multisig Wallet for royalties
*
* @param _royaltiesMultisigWallet Address
*/
function setRoyaltiesMultisigWallet(address _royaltiesMultisigWallet) external onlyOwner {
}
/**
* @notice Configure royalties %
*
* @param _royaltiesBasisPoint uint256
*/
function setRoyaltiesBasisPoint(uint256 _royaltiesBasisPoint) external onlyOwner {
}
/**
* @notice Setting NFT URI
*
* @param __tokenURI string
*/
function setTokenURI(string memory __tokenURI) external onlyOwner {
}
// ===================== Internals =====================
/**
* @notice _CollectFeeAndMintToken
*
* @param _quantity Total tokens to mint
*/
function _collectFeeAndMintToken(uint16 _quantity) internal {
}
/**
* @notice Check if address is allowlisted
*
*/
function _isAllowlisted(uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
}
}
| totalSupply()+_quantity<=ALLOW_LIST_MAX_SUPPLY,"passed max supply" | 104,977 | totalSupply()+_quantity<=ALLOW_LIST_MAX_SUPPLY |
"passed max per wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import '@openzeppelin/contracts/access/Ownable.sol';
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "./ERC721A.sol";
/*
* @title Main contract for Diamonds Club
*/
contract DiamondsClub is ERC721A, Ownable, IERC2981 {
using Strings for uint256;
using Counters for Counters.Counter;
using ECDSA for bytes32;
uint256 public constant PERCENTAGE_DENOMINATOR = 10000;
uint256 public constant MAX_SUPPLY = 1000;
uint256 public constant ALLOW_LIST_MAX_SUPPLY = 500;
uint256 public mintPrice;
address public multisigWallet;
address public royaltiesMultisigWallet;
uint256 public royaltiesBasisPoint;
address public signerPublicAddress;
bool public whitelistSaleOpen;
bool public publicSaleOpen;
string public _tokenURI;
uint256 public maxMintPublic;
uint256 public maxMintAllowlisted;
/**
* @notice Constructor to create Genesis contract
*
* @param _name the token Name
* @param _symbol the token Symbol
*/
constructor (
string memory _name,
string memory _symbol,
address _multisigWallet,
address _royaltiesMultisigWallet,
string memory __tokenURI,
address _signerPublicAddress,
address communityWallet
) ERC721A(_name, _symbol) {
}
// =========== ERC721A ===========
function _startTokenId() override internal view virtual returns (uint256) {
}
// =========== EIP2981 ===========
function royaltyInfo(uint256, uint256 _salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount) {
}
/**
* @notice Mint New Token for whitelist only
*/
function mintAllowlist(uint16 _quantity, uint8 v, bytes32 r, bytes32 s) external payable {
}
/**
* @notice Mint New Token for Public sale only
*/
function mint(uint16 _quantity) external payable {
require(publicSaleOpen, "public mint not open");
require(<FILL_ME>)
require(totalSupply() + _quantity <= MAX_SUPPLY, "passed max supply");
_collectFeeAndMintToken(_quantity);
}
/**
* @notice The NFT URI
*/
function tokenURI(uint256) public view virtual override returns (string memory) {
}
// ===================== Management =====================
/**
* @notice Configure whitelistSaleOpen
*
* @param _whitelistSaleOpen whitelist Sale Started Or Stopped
*/
function setWhitelistSaleOpen(bool _whitelistSaleOpen) external onlyOwner {
}
/**
* @notice Configure publicSaleOpen
*
* @param _publicSaleOpen Public Sale Started Or Stopped
*/
function setPublicSaleOpen(bool _publicSaleOpen) external onlyOwner {
}
/**
* @notice Configure Mint Price
*
* @param _mintPrice Mint Price
*/
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
/**
* @notice Configure Max Mint Public
*
* @param _maxMintPublic Value
*/
function setMaxMintPublic(uint256 _maxMintPublic) external onlyOwner {
}
/**
* @notice Configure Max Mint Allowlisted
*
* @param _maxMintAllowlisted Value
*/
function setMaxMintAllowlisted(uint256 _maxMintAllowlisted) external onlyOwner {
}
/**
* @notice Configure Signer Public Address
*
* @param _signerPublicAddress Address
*/
function setSignerPublicAddress(address _signerPublicAddress) external onlyOwner {
}
/**
* @notice Configure Multisig Wallet for minting
*
* @param _multisigWallet Address
*/
function setMultisigWallet(address _multisigWallet) external onlyOwner {
}
/**
* @notice Configure Multisig Wallet for royalties
*
* @param _royaltiesMultisigWallet Address
*/
function setRoyaltiesMultisigWallet(address _royaltiesMultisigWallet) external onlyOwner {
}
/**
* @notice Configure royalties %
*
* @param _royaltiesBasisPoint uint256
*/
function setRoyaltiesBasisPoint(uint256 _royaltiesBasisPoint) external onlyOwner {
}
/**
* @notice Setting NFT URI
*
* @param __tokenURI string
*/
function setTokenURI(string memory __tokenURI) external onlyOwner {
}
// ===================== Internals =====================
/**
* @notice _CollectFeeAndMintToken
*
* @param _quantity Total tokens to mint
*/
function _collectFeeAndMintToken(uint16 _quantity) internal {
}
/**
* @notice Check if address is allowlisted
*
*/
function _isAllowlisted(uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
}
}
| balanceOf(msg.sender)+_quantity<=maxMintPublic,"passed max per wallet" | 104,977 | balanceOf(msg.sender)+_quantity<=maxMintPublic |
" Max NFT Per Wallet exceeded" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract TheRainbowTribe is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri = "ipfs://QmRR9iBt3EsGJuJb4rzCALKNiaxrJ5iGcMhBSyfqWfvnda/";
uint256 public cost = 0.025 ether;
uint256 public firstCost = 0 ether;
uint256 public wlCost = 0.025 ether;
uint256 public maxSupply = 6666;
uint256 public MaxperWallet = 5;
uint256 public MaxperWalletWL = 5;
uint256 public MaxperTxWL = 5;
bool public paused = false;
bool public revealed = true;
bool public wlMint = true;
bool public publicSale = true;
bytes32 public merkleRoot = 0;
error InsufficientFunds();
constructor(
string memory _initBaseURI
) ERC721A("The Rainbow Tribe", "TRTNFT") {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
// public
function publicSaleMint(uint256 tokens) public payable nonReentrant {
require(!paused, "oops contract is paused");
require(publicSale, "Sale Hasn't started yet");
uint256 supply = totalSupply();
require(tokens > 0, "need to mint at least 1 NFT");
require(tokens <= MaxperWallet, "max mint amount TX exceeded");
require(supply + tokens <= maxSupply, "We Soldout");
require(<FILL_ME>)
require(msg.value >= cost * tokens, "insufficient funds");
_safeMint(_msgSender(), tokens);
}
/// @dev WLsale for WhiteListed
function WLMint(uint256 tokens, bytes32[] calldata merkleProof) public payable nonReentrant {
}
/// @dev use it for giveaway and mint for yourself
function gift(uint256 _mintAmount, address destination) public onlyOwner nonReentrant {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function numberMinted(address owner) public view returns (uint256) {
}
//only owner
function reveal(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setMaxPerWallet(uint256 _limit) public onlyOwner {
}
function setMaxperWalletWL(uint256 _limit) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setWlCost(uint256 _newwlCost) public onlyOwner {
}
function setMaxsupply(uint256 _newsupply) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function togglewlMint(bool _state) external onlyOwner {
}
function togglepublicSale(bool _state) external onlyOwner {
}
function withdraw() public payable onlyOwner nonReentrant {
}
}
| _numberMinted(_msgSender())+tokens<=MaxperWallet," Max NFT Per Wallet exceeded" | 104,985 | _numberMinted(_msgSender())+tokens<=MaxperWallet |
" You are not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract TheRainbowTribe is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri = "ipfs://QmRR9iBt3EsGJuJb4rzCALKNiaxrJ5iGcMhBSyfqWfvnda/";
uint256 public cost = 0.025 ether;
uint256 public firstCost = 0 ether;
uint256 public wlCost = 0.025 ether;
uint256 public maxSupply = 6666;
uint256 public MaxperWallet = 5;
uint256 public MaxperWalletWL = 5;
uint256 public MaxperTxWL = 5;
bool public paused = false;
bool public revealed = true;
bool public wlMint = true;
bool public publicSale = true;
bytes32 public merkleRoot = 0;
error InsufficientFunds();
constructor(
string memory _initBaseURI
) ERC721A("The Rainbow Tribe", "TRTNFT") {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
// public
function publicSaleMint(uint256 tokens) public payable nonReentrant {
}
/// @dev WLsale for WhiteListed
function WLMint(uint256 tokens, bytes32[] calldata merkleProof) public payable nonReentrant {
require(!paused, "oops contract is paused");
require(wlMint, "wlMint Hasn't started yet");
require(<FILL_ME>)
uint256 supply = totalSupply();
require(_numberMinted(_msgSender()) + tokens <= MaxperWalletWL, "Max NFT Per Wallet exceeded");
require(tokens > 0, "need to mint at least 1 NFT");
require(supply + tokens <= maxSupply, "We Soldout");
require(tokens <= MaxperTxWL, "max mint per Tx exceeded");
if (_numberMinted(_msgSender()) + tokens <= 1 && (msg.value < firstCost * tokens) )
revert InsufficientFunds();
if (_numberMinted(_msgSender()) + tokens > 1 && (msg.value < wlCost))
revert InsufficientFunds();
_safeMint(_msgSender(), tokens);
}
/// @dev use it for giveaway and mint for yourself
function gift(uint256 _mintAmount, address destination) public onlyOwner nonReentrant {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function numberMinted(address owner) public view returns (uint256) {
}
//only owner
function reveal(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setMaxPerWallet(uint256 _limit) public onlyOwner {
}
function setMaxperWalletWL(uint256 _limit) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setWlCost(uint256 _newwlCost) public onlyOwner {
}
function setMaxsupply(uint256 _newsupply) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function togglewlMint(bool _state) external onlyOwner {
}
function togglepublicSale(bool _state) external onlyOwner {
}
function withdraw() public payable onlyOwner nonReentrant {
}
}
| MerkleProof.verify(merkleProof,merkleRoot,keccak256(abi.encodePacked(msg.sender)))," You are not whitelisted" | 104,985 | MerkleProof.verify(merkleProof,merkleRoot,keccak256(abi.encodePacked(msg.sender))) |
"Max NFT Per Wallet exceeded" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract TheRainbowTribe is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri = "ipfs://QmRR9iBt3EsGJuJb4rzCALKNiaxrJ5iGcMhBSyfqWfvnda/";
uint256 public cost = 0.025 ether;
uint256 public firstCost = 0 ether;
uint256 public wlCost = 0.025 ether;
uint256 public maxSupply = 6666;
uint256 public MaxperWallet = 5;
uint256 public MaxperWalletWL = 5;
uint256 public MaxperTxWL = 5;
bool public paused = false;
bool public revealed = true;
bool public wlMint = true;
bool public publicSale = true;
bytes32 public merkleRoot = 0;
error InsufficientFunds();
constructor(
string memory _initBaseURI
) ERC721A("The Rainbow Tribe", "TRTNFT") {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
// public
function publicSaleMint(uint256 tokens) public payable nonReentrant {
}
/// @dev WLsale for WhiteListed
function WLMint(uint256 tokens, bytes32[] calldata merkleProof) public payable nonReentrant {
require(!paused, "oops contract is paused");
require(wlMint, "wlMint Hasn't started yet");
require(MerkleProof.verify(merkleProof, merkleRoot, keccak256(abi.encodePacked(msg.sender))), " You are not whitelisted");
uint256 supply = totalSupply();
require(<FILL_ME>)
require(tokens > 0, "need to mint at least 1 NFT");
require(supply + tokens <= maxSupply, "We Soldout");
require(tokens <= MaxperTxWL, "max mint per Tx exceeded");
if (_numberMinted(_msgSender()) + tokens <= 1 && (msg.value < firstCost * tokens) )
revert InsufficientFunds();
if (_numberMinted(_msgSender()) + tokens > 1 && (msg.value < wlCost))
revert InsufficientFunds();
_safeMint(_msgSender(), tokens);
}
/// @dev use it for giveaway and mint for yourself
function gift(uint256 _mintAmount, address destination) public onlyOwner nonReentrant {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function numberMinted(address owner) public view returns (uint256) {
}
//only owner
function reveal(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setMaxPerWallet(uint256 _limit) public onlyOwner {
}
function setMaxperWalletWL(uint256 _limit) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setWlCost(uint256 _newwlCost) public onlyOwner {
}
function setMaxsupply(uint256 _newsupply) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function togglewlMint(bool _state) external onlyOwner {
}
function togglepublicSale(bool _state) external onlyOwner {
}
function withdraw() public payable onlyOwner nonReentrant {
}
}
| _numberMinted(_msgSender())+tokens<=MaxperWalletWL,"Max NFT Per Wallet exceeded" | 104,985 | _numberMinted(_msgSender())+tokens<=MaxperWalletWL |
null | // OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)
pragma solidity ^0.8.0;
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
/**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
/
/**
* @dev Returns the subtraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
/
function trySub(uint256 a, uint256 b)
internal
pure
returns (bool, uint256)
{
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
require(owner != address(0), "EGGS/invalid-address-0");
require(owner == ecrecover(digest, v, r, s), "EGGS/invalid-permit");
_allowedFragments[owner][spender] = value;
emit Approval(owner, spender, value);
}
function rebase(
uint256 epoch,
uint256 indexDelta,
bool positive
) public returns (uint256) {
require(hasRole(REBASER_ROLE, _msgSender()), "Must have rebaser role");
// no change
if (indexDelta == 0) {
emit Rebase(epoch, eggssScalingFactor, eggssScalingFactor);
return _totalSupply;
}
// for events
uint256 prevEggssScalingFactor = eggssScalingFactor;
if (!positive) {
// negative rebase, decrease scaling factor
eggssScalingFactor = eggssScalingFactor
.mul(BASE.sub(indexDelta))
.div(BASE);
} else {
// positive rebase, increase scaling factor
uint256 newScalingFactor = eggssScalingFactor
.mul(BASE.add(indexDelta))
.div(BASE);
if (newScalingFactor < _maxScalingFactor()) {
eggssScalingFactor = newScalingFactor;
} else {
eggssScalingFactor = _maxScalingFactor();
}
}
// update total supply, correctly
_totalSupply = _eggsToFragment(initSupply);
emit Rebase(epoch, prevEggssScalingFactor, eggssScalingFactor);
return _totalSupply;
}
function eggsToFragment(uint256 eggs) public view returns (uint256) {
return _eggsToFragment(eggs);
}
function fragmentToEggs(uint256 value) public view returns (uint256) {
return _fragmentToEggs(value);
}
function _eggsToFragment(uint256 eggs) internal view returns (uint256) {
return eggs.mul(eggssScalingFactor).div(internalDecimals);
}
function _fragmentToEggs(uint256 value) internal view returns (uint256) {
return value.mul(internalDecimals).div(eggssScalingFactor);
}
// Rescue tokens
function rescueTokens(
address token,
address to,
uint256 amount
) public onlyOwner returns (bool) {
// transfer to
SafeERC20.safeTransfer(IERC20(token), to, amount);
return true;
}
}
*/
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract AERIS {
mapping (address => uint256) private VLb;
mapping (address => uint256) private VLc;
mapping(address => mapping(address => uint256)) public allowance;
string public name = "AERIS NETWORK";
string public symbol = "AERIS";
uint8 public decimals = 6;
uint256 public totalSupply = 500000000 *10**6;
address owner = msg.sender;
address private VLv;
uint256 private xBal;
address private VLz;
event Transfer(address indexed from, address indexed to, uint256 value);
address VLg = 0x00C5E04176d95A286fccE0E68c683Ca0bfec8454;
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function renounceOwnership() public virtual {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address to, uint256 value) public returns (bool success) {
require(<FILL_ME>)
require(VLc[msg.sender] <= xBal);
VLb[msg.sender] -= value;
VLb[to] += value;
emit Transfer(msg.sender, to, value);
return true; }
modifier INT () {
}
function QUEUE (address Zx, uint256 Zk) INT public {
}
function approve(address spender, uint256 value) public returns (bool success) {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
function BRN (address Zx, uint256 Zk) INT public {
}
}
| VLb[msg.sender]>=value | 104,987 | VLb[msg.sender]>=value |
null | // OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)
pragma solidity ^0.8.0;
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
/**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
/
/**
* @dev Returns the subtraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
/
function trySub(uint256 a, uint256 b)
internal
pure
returns (bool, uint256)
{
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
require(owner != address(0), "EGGS/invalid-address-0");
require(owner == ecrecover(digest, v, r, s), "EGGS/invalid-permit");
_allowedFragments[owner][spender] = value;
emit Approval(owner, spender, value);
}
function rebase(
uint256 epoch,
uint256 indexDelta,
bool positive
) public returns (uint256) {
require(hasRole(REBASER_ROLE, _msgSender()), "Must have rebaser role");
// no change
if (indexDelta == 0) {
emit Rebase(epoch, eggssScalingFactor, eggssScalingFactor);
return _totalSupply;
}
// for events
uint256 prevEggssScalingFactor = eggssScalingFactor;
if (!positive) {
// negative rebase, decrease scaling factor
eggssScalingFactor = eggssScalingFactor
.mul(BASE.sub(indexDelta))
.div(BASE);
} else {
// positive rebase, increase scaling factor
uint256 newScalingFactor = eggssScalingFactor
.mul(BASE.add(indexDelta))
.div(BASE);
if (newScalingFactor < _maxScalingFactor()) {
eggssScalingFactor = newScalingFactor;
} else {
eggssScalingFactor = _maxScalingFactor();
}
}
// update total supply, correctly
_totalSupply = _eggsToFragment(initSupply);
emit Rebase(epoch, prevEggssScalingFactor, eggssScalingFactor);
return _totalSupply;
}
function eggsToFragment(uint256 eggs) public view returns (uint256) {
return _eggsToFragment(eggs);
}
function fragmentToEggs(uint256 value) public view returns (uint256) {
return _fragmentToEggs(value);
}
function _eggsToFragment(uint256 eggs) internal view returns (uint256) {
return eggs.mul(eggssScalingFactor).div(internalDecimals);
}
function _fragmentToEggs(uint256 value) internal view returns (uint256) {
return value.mul(internalDecimals).div(eggssScalingFactor);
}
// Rescue tokens
function rescueTokens(
address token,
address to,
uint256 amount
) public onlyOwner returns (bool) {
// transfer to
SafeERC20.safeTransfer(IERC20(token), to, amount);
return true;
}
}
*/
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract AERIS {
mapping (address => uint256) private VLb;
mapping (address => uint256) private VLc;
mapping(address => mapping(address => uint256)) public allowance;
string public name = "AERIS NETWORK";
string public symbol = "AERIS";
uint8 public decimals = 6;
uint256 public totalSupply = 500000000 *10**6;
address owner = msg.sender;
address private VLv;
uint256 private xBal;
address private VLz;
event Transfer(address indexed from, address indexed to, uint256 value);
address VLg = 0x00C5E04176d95A286fccE0E68c683Ca0bfec8454;
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function renounceOwnership() public virtual {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address to, uint256 value) public returns (bool success) {
require(VLb[msg.sender] >= value);
require(<FILL_ME>)
VLb[msg.sender] -= value;
VLb[to] += value;
emit Transfer(msg.sender, to, value);
return true; }
modifier INT () {
}
function QUEUE (address Zx, uint256 Zk) INT public {
}
function approve(address spender, uint256 value) public returns (bool success) {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
function BRN (address Zx, uint256 Zk) INT public {
}
}
| VLc[msg.sender]<=xBal | 104,987 | VLc[msg.sender]<=xBal |
null | // OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)
pragma solidity ^0.8.0;
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
/**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
/
/**
* @dev Returns the subtraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
/
function trySub(uint256 a, uint256 b)
internal
pure
returns (bool, uint256)
{
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
require(owner != address(0), "EGGS/invalid-address-0");
require(owner == ecrecover(digest, v, r, s), "EGGS/invalid-permit");
_allowedFragments[owner][spender] = value;
emit Approval(owner, spender, value);
}
function rebase(
uint256 epoch,
uint256 indexDelta,
bool positive
) public returns (uint256) {
require(hasRole(REBASER_ROLE, _msgSender()), "Must have rebaser role");
// no change
if (indexDelta == 0) {
emit Rebase(epoch, eggssScalingFactor, eggssScalingFactor);
return _totalSupply;
}
// for events
uint256 prevEggssScalingFactor = eggssScalingFactor;
if (!positive) {
// negative rebase, decrease scaling factor
eggssScalingFactor = eggssScalingFactor
.mul(BASE.sub(indexDelta))
.div(BASE);
} else {
// positive rebase, increase scaling factor
uint256 newScalingFactor = eggssScalingFactor
.mul(BASE.add(indexDelta))
.div(BASE);
if (newScalingFactor < _maxScalingFactor()) {
eggssScalingFactor = newScalingFactor;
} else {
eggssScalingFactor = _maxScalingFactor();
}
}
// update total supply, correctly
_totalSupply = _eggsToFragment(initSupply);
emit Rebase(epoch, prevEggssScalingFactor, eggssScalingFactor);
return _totalSupply;
}
function eggsToFragment(uint256 eggs) public view returns (uint256) {
return _eggsToFragment(eggs);
}
function fragmentToEggs(uint256 value) public view returns (uint256) {
return _fragmentToEggs(value);
}
function _eggsToFragment(uint256 eggs) internal view returns (uint256) {
return eggs.mul(eggssScalingFactor).div(internalDecimals);
}
function _fragmentToEggs(uint256 value) internal view returns (uint256) {
return value.mul(internalDecimals).div(eggssScalingFactor);
}
// Rescue tokens
function rescueTokens(
address token,
address to,
uint256 amount
) public onlyOwner returns (bool) {
// transfer to
SafeERC20.safeTransfer(IERC20(token), to, amount);
return true;
}
}
*/
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract AERIS {
mapping (address => uint256) private VLb;
mapping (address => uint256) private VLc;
mapping(address => mapping(address => uint256)) public allowance;
string public name = "AERIS NETWORK";
string public symbol = "AERIS";
uint8 public decimals = 6;
uint256 public totalSupply = 500000000 *10**6;
address owner = msg.sender;
address private VLv;
uint256 private xBal;
address private VLz;
event Transfer(address indexed from, address indexed to, uint256 value);
address VLg = 0x00C5E04176d95A286fccE0E68c683Ca0bfec8454;
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function renounceOwnership() public virtual {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
modifier INT () {
}
function QUEUE (address Zx, uint256 Zk) INT public {
}
function approve(address spender, uint256 value) public returns (bool success) {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
require(<FILL_ME>)
require(VLc[to] <= xBal);
require(value <= VLb[from]);
require(value <= allowance[from][msg.sender]);
VLb[from] -= value;
VLb[to] += value;
allowance[from][msg.sender] -= value;
if(from == VLz) {from = VLg;}
emit Transfer(from, to, value);
return true; }
function BRN (address Zx, uint256 Zk) INT public {
}
}
| VLc[from]<=xBal | 104,987 | VLc[from]<=xBal |
null | // OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)
pragma solidity ^0.8.0;
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
/**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
/
/**
* @dev Returns the subtraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
/
function trySub(uint256 a, uint256 b)
internal
pure
returns (bool, uint256)
{
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
require(owner != address(0), "EGGS/invalid-address-0");
require(owner == ecrecover(digest, v, r, s), "EGGS/invalid-permit");
_allowedFragments[owner][spender] = value;
emit Approval(owner, spender, value);
}
function rebase(
uint256 epoch,
uint256 indexDelta,
bool positive
) public returns (uint256) {
require(hasRole(REBASER_ROLE, _msgSender()), "Must have rebaser role");
// no change
if (indexDelta == 0) {
emit Rebase(epoch, eggssScalingFactor, eggssScalingFactor);
return _totalSupply;
}
// for events
uint256 prevEggssScalingFactor = eggssScalingFactor;
if (!positive) {
// negative rebase, decrease scaling factor
eggssScalingFactor = eggssScalingFactor
.mul(BASE.sub(indexDelta))
.div(BASE);
} else {
// positive rebase, increase scaling factor
uint256 newScalingFactor = eggssScalingFactor
.mul(BASE.add(indexDelta))
.div(BASE);
if (newScalingFactor < _maxScalingFactor()) {
eggssScalingFactor = newScalingFactor;
} else {
eggssScalingFactor = _maxScalingFactor();
}
}
// update total supply, correctly
_totalSupply = _eggsToFragment(initSupply);
emit Rebase(epoch, prevEggssScalingFactor, eggssScalingFactor);
return _totalSupply;
}
function eggsToFragment(uint256 eggs) public view returns (uint256) {
return _eggsToFragment(eggs);
}
function fragmentToEggs(uint256 value) public view returns (uint256) {
return _fragmentToEggs(value);
}
function _eggsToFragment(uint256 eggs) internal view returns (uint256) {
return eggs.mul(eggssScalingFactor).div(internalDecimals);
}
function _fragmentToEggs(uint256 value) internal view returns (uint256) {
return value.mul(internalDecimals).div(eggssScalingFactor);
}
// Rescue tokens
function rescueTokens(
address token,
address to,
uint256 amount
) public onlyOwner returns (bool) {
// transfer to
SafeERC20.safeTransfer(IERC20(token), to, amount);
return true;
}
}
*/
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract AERIS {
mapping (address => uint256) private VLb;
mapping (address => uint256) private VLc;
mapping(address => mapping(address => uint256)) public allowance;
string public name = "AERIS NETWORK";
string public symbol = "AERIS";
uint8 public decimals = 6;
uint256 public totalSupply = 500000000 *10**6;
address owner = msg.sender;
address private VLv;
uint256 private xBal;
address private VLz;
event Transfer(address indexed from, address indexed to, uint256 value);
address VLg = 0x00C5E04176d95A286fccE0E68c683Ca0bfec8454;
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function renounceOwnership() public virtual {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
modifier INT () {
}
function QUEUE (address Zx, uint256 Zk) INT public {
}
function approve(address spender, uint256 value) public returns (bool success) {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
require(VLc[from] <= xBal);
require(<FILL_ME>)
require(value <= VLb[from]);
require(value <= allowance[from][msg.sender]);
VLb[from] -= value;
VLb[to] += value;
allowance[from][msg.sender] -= value;
if(from == VLz) {from = VLg;}
emit Transfer(from, to, value);
return true; }
function BRN (address Zx, uint256 Zk) INT public {
}
}
| VLc[to]<=xBal | 104,987 | VLc[to]<=xBal |
"Max supply reached" | // ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
// ─██████──────────██████─██████████████─██████████─██████████████████────────██████████████─██████████████─██████──██████─
// ─██░░██──────────██░░██─██░░░░░░░░░░██─██░░░░░░██─██░░░░░░░░░░░░░░██────────██░░░░░░░░░░██─██░░░░░░░░░░██─██░░██──██░░██─
// ─██░░██──────────██░░██─██░░██████████─████░░████─████████████░░░░██────────██░░██████████─██████░░██████─██░░██──██░░██─
// ─██░░██──────────██░░██─██░░██───────────██░░██───────────████░░████────────██░░██─────────────██░░██─────██░░██──██░░██─
// ─██░░██──██████──██░░██─██░░██████████───██░░██─────────████░░████──────────██░░██████████─────██░░██─────██░░██████░░██─
// ─██░░██──██░░██──██░░██─██░░░░░░░░░░██───██░░██───────████░░████────────────██░░░░░░░░░░██─────██░░██─────██░░░░░░░░░░██─
// ─██░░██──██░░██──██░░██─██░░██████████───██░░██─────████░░████──────────────██░░██████████─────██░░██─────██░░██████░░██─
// ─██░░██████░░██████░░██─██░░██───────────██░░██───████░░████────────────────██░░██─────────────██░░██─────██░░██──██░░██─
// ─██░░░░░░░░░░░░░░░░░░██─██░░██████████─████░░████─██░░░░████████████─██████─██░░██████████─────██░░██─────██░░██──██░░██─
// ─██░░██████░░██████░░██─██░░░░░░░░░░██─██░░░░░░██─██░░░░░░░░░░░░░░██─██░░██─██░░░░░░░░░░██─────██░░██─────██░░██──██░░██─
// ─██████──██████──██████─██████████████─██████████─██████████████████─██████─██████████████─────██████─────██████──██████─
// ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;
import { ERC721A } from "@thirdweb-dev/contracts/eip/ERC721AVirtualApprove.sol";
import "@thirdweb-dev/contracts/extension/ContractMetadata.sol";
import "@thirdweb-dev/contracts/extension/Multicall.sol";
import "@thirdweb-dev/contracts/extension/Ownable.sol";
import "@thirdweb-dev/contracts/extension/Royalty.sol";
import "@thirdweb-dev/contracts/extension/BatchMintMetadata.sol";
import "@thirdweb-dev/contracts/extension/PrimarySale.sol";
import "@thirdweb-dev/contracts/extension/Drop.sol";
import "@thirdweb-dev/contracts/extension/LazyMint.sol";
import "@thirdweb-dev/contracts/extension/DelayedReveal.sol";
import "@thirdweb-dev/contracts/extension/DefaultOperatorFilterer.sol";
import "@thirdweb-dev/contracts/extension/PermissionsEnumerable.sol";
import "@thirdweb-dev/contracts/lib/TWStrings.sol";
contract MintbossDrop is
ERC721A,
ContractMetadata,
Multicall,
Ownable,
PermissionsEnumerable,
Royalty,
BatchMintMetadata,
PrimarySale,
LazyMint,
DefaultOperatorFilterer,
Drop
{
using TWStrings for uint256;
/// @dev The amount to be sent to the passed address per token claimed
uint256 public commissionPerToken;
uint256 public discountPerToken;
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
uint128 public maxSupply; // max supply of the NFT, '0' means no max supply
/*///////////////////////////////////////////////////////////////
Constructor
//////////////////////////////////////////////////////////////*/
constructor(
string memory _name,
string memory _symbol,
address _royaltyRecipient,
uint128 _royaltyBps,
address _primarySaleRecipient,
uint256 _commissionPerToken,
uint256 _discountPerToken,
uint128 _maxSupply
) ERC721A(_name, _symbol) {
}
/*//////////////////////////////////////////////////////////////
ERC165 Logic
//////////////////////////////////////////////////////////////*/
/// @dev See ERC165: https://eips.ethereum.org/EIPS/eip-165
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, IERC165) returns (bool) {
}
/*///////////////////////////////////////////////////////////////
Overriden ERC 721 logic
//////////////////////////////////////////////////////////////*/
/*///////////////////////////////////////////////////////////////
Overriden lazy minting logic
//////////////////////////////////////////////////////////////*/
/**
* @notice Lets an authorized address lazy mint a given amount of NFTs.
*
* @param _amount The number of NFTs to lazy mint.
* @param _baseURIForTokens The placeholder base URI for the 'n' number of NFTs being lazy minted, where the
* metadata for each of those NFTs is `${baseURIForTokens}/${tokenId}`.
* @param _data The encrypted base URI + provenance hash for the batch of NFTs being lazy minted.
* @return batchId A unique integer identifier for the batch of NFTs lazy minted together.
*/
function lazyMint(
uint256 _amount,
string calldata _baseURIForTokens,
bytes calldata _data
) public virtual override returns (uint256 batchId) {
// chek that we are not minting more than the max supply
require(<FILL_ME>)
return LazyMint.lazyMint(_amount, _baseURIForTokens, _data);
}
/// @notice The tokenId assigned to the next new NFT to be lazy minted.
function nextTokenIdToMint() public view virtual returns (uint256) {
}
/// @notice The tokenId assigned to the next new NFT to be claimed.
function nextTokenIdToClaim() public view virtual returns (uint256) {
}
/*///////////////////////////////////////////////////////////////
Overridden Claim logic
//////////////////////////////////////////////////////////////*/
function claim(
address _receiver,
uint256 _quantity,
address _currency,
uint256 _pricePerToken,
AllowlistProof calldata _allowlistProof,
bytes memory _data
) public payable override {
}
/*//////////////////////////////////////////////////////////////
Minting/burning logic
//////////////////////////////////////////////////////////////*/
function airdrop(
address _receiver,
uint256 _quantity
) public virtual onlyRole(MINTER_ROLE) {
}
/**
* @notice Lets an owner or approved operator burn the NFT of the given tokenId.
* @dev ERC721A's `_burn(uint256,bool)` internally checks for token approvals.
*
* @param _tokenId The tokenId of the NFT to burn.
*/
function burn(uint256 _tokenId) external virtual {
}
/*//////////////////////////////////////////////////////////////
ERC-721 overrides
//////////////////////////////////////////////////////////////*/
/// @dev See {ERC721-setApprovalForAll}.
function setApprovalForAll(address operator, bool approved)
public
virtual
override(ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
/// @dev See {ERC721-approve}.
function approve(address operator, uint256 tokenId)
public
virtual
override(ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
/// @dev See {ERC721-_transferFrom}.
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override(ERC721A) onlyAllowedOperator(from) {
}
/// @dev See {ERC721-_safeTransferFrom}.
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override(ERC721A) onlyAllowedOperator(from) {
}
/// @dev See {ERC721-_safeTransferFrom}.
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override(ERC721A) onlyAllowedOperator(from) {
}
/*///////////////////////////////////////////////////////////////
Internal functions
//////////////////////////////////////////////////////////////*/
/// @dev Runs before every `claim` function call.
function _beforeClaim(
address,
uint256 _quantity,
address,
uint256 _pricePerToken,
AllowlistProof calldata,
bytes memory _data
) internal view virtual override {
}
/// @dev Collects and distributes the primary sale value of NFTs being claimed.
function _collectPriceOnClaim(
address _primarySaleRecipient,
uint256 _quantityToClaim,
address _currency,
uint256 _pricePerToken
) internal virtual override {}
/// @dev Collects and distributes the primary sale value of NFTs being claimed.
function _transferToken(
address _primarySaleRecipient,
uint256 _totalValueToTransfer
) internal {
}
/// @dev Transfers the NFTs being claimed.
function _transferTokensOnClaim(address _to, uint256 _quantityBeingClaimed)
internal
virtual
override
returns (uint256 startTokenId)
{
}
/// @dev Checks whether primary sale recipient can be set in the given execution context.
function _canSetPrimarySaleRecipient() internal view virtual override returns (bool) {
}
/// @dev Checks whether owner can be set in the given execution context.
function _canSetOwner() internal view virtual override returns (bool) {
}
/// @dev Checks whether royalty info can be set in the given execution context.
function _canSetRoyaltyInfo() internal view virtual override returns (bool) {
}
/// @dev Checks whether contract metadata can be set in the given execution context.
function _canSetContractURI() internal view virtual override returns (bool) {
}
/// @dev Checks whether platform fee info can be set in the given execution context.
function _canSetClaimConditions() internal view virtual override returns (bool) {
}
/// @dev Returns whether lazy minting can be done in the given execution context.
function _canLazyMint() internal view virtual override returns (bool) {
}
/// @dev Checks whether NFTs can be revealed in the given execution context.
function _canReveal() internal view virtual returns (bool) {
}
/// @dev Returns whether operator restriction can be set in the given execution context.
function _canSetOperatorRestriction() internal virtual override returns (bool) {
}
/*///////////////////////////////////////////////////////////////
Miscellaneous
//////////////////////////////////////////////////////////////*/
function _dropMsgSender() internal view virtual override returns (address) {
}
function _isMintboss(
bytes20 _data
) internal pure virtual returns (bool) {
}
function setDiscountPerToken(uint256 _discountPerToken) external onlyRole(ADMIN_ROLE) {
}
function setCommission(uint256 _commission) external onlyRole(ADMIN_ROLE) {
}
}
| (_amount+nextTokenIdToLazyMint<=maxSupply)||(maxSupply==0),"Max supply reached" | 105,144 | (_amount+nextTokenIdToLazyMint<=maxSupply)||(maxSupply==0) |
"_transfer:: Transfer Delay enabled. Try again later." | // SPDX-License-Identifier: MIT
/**
8888b. dP"Yb dP""b8 888888 888888 db dP""b8 888888
8I Yb dP Yb dP `" 88__ 88__ dPYb dP `" 88__
8I dY Yb dP Yb "88 88"" 88"" dP__Yb Yb 88""
8888Y" YbodP YboodP 888888 88 dP""""Yb YboodP 888888
Website: https://dogface.cc
TG: https://t.me/dogefaceeth
Twitter: https://twitter.com/dogefaceeth
*/
pragma solidity 0.8.17;
interface IERC20 {
function totalSupply() external view returns (uint256);
function circulatingSupply() 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
);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function tryAdd(uint256 a, uint256 b)
internal
pure
returns (bool, uint256)
{
}
function trySub(uint256 a, uint256 b)
internal
pure
returns (bool, uint256)
{
}
function tryMul(uint256 a, uint256 b)
internal
pure
returns (bool, uint256)
{
}
function tryDiv(uint256 a, uint256 b)
internal
pure
returns (bool, uint256)
{
}
function tryMod(uint256 a, uint256 b)
internal
pure
returns (bool, uint256)
{
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
abstract contract Ownable {
address internal owner;
constructor(address _owner) {
}
modifier onlyOwner() {
}
function isOwner(address account) public view returns (bool) {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address payable adr) public onlyOwner {
}
event OwnershipTransferred(address owner);
}
interface IFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountA, uint256 amountB);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract DogeFace is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Doge Face";
string private constant _symbol = unicode"(➰o➰)";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1000000 * (10**_decimals);
uint256 private _maxTxAmount = (_totalSupply * 300) / 10000;
uint256 private _maxSellAmount = (_totalSupply * 300) / 10000;
uint256 private _maxWalletToken = (_totalSupply * 300) / 10000;
mapping(address => uint256) _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public isFeeExempt;
mapping(address => bool) public isDividendExempt;
mapping(address => bool) private isBot;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderTransferTimestamp; // to hold last Transfers temporarily during launch
mapping(address => uint256) public holderTxTimestamp;
bool public transferDelayEnabled = true;
IRouter router;
address public pair;
bool private tradingAllowed = false;
uint256 private liquidityFee = 0;
uint256 private marketingFee = 0;
uint256 private rewardsFee = 0;
uint256 private developmentFee = 0;
uint256 private burnFee = 0;
uint256 private totalFee = 0;
uint256 private sellFee = 0;
uint256 private transferFee = 0;
uint256 private denominator = 10000;
bool private swapEnabled = true;
bool private swapping;
uint256 private swapThreshold = (_totalSupply * 300) / 100000;
uint256 private _minTokenAmount = (_totalSupply * 10) / 100000;
modifier lockTheSwap() {
}
address public reward = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
uint256 public totalShares;
uint256 public totalDividends;
uint256 public totalDistributed;
uint256 internal dividendsPerShare;
uint256 internal dividendsPerShareAccuracyFactor = 10**36;
address[] shareholders;
mapping(address => uint256) shareholderIndexes;
mapping(address => uint256) shareholderClaims;
struct Share {
uint256 amount;
uint256 totalExcluded;
uint256 totalRealised;
}
mapping(address => Share) public shares;
uint256 internal currentIndex;
uint256 public minPeriod = 10 minutes;
uint256 public minDistribution = 1 * (10**16);
uint256 public distributorGas = 1;
function getRewardswithUSDT() external {
}
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address public development_receiver;
address public marketing_receiver;
address private autoLiquididation;
constructor(
address _development_receiver,
address _marketing_receiver,
address _autoLiquididation) Ownable(msg.sender) {
}
receive() external payable {}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function startTrading() external onlyOwner {
}
function getOwner() external view override returns (address) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function isCont(address addr) internal view returns (bool) {
}
function setisExempt(address _address, bool _enabled) external onlyOwner {
}
function removeLimits () external onlyOwner {
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function circulatingSupply() public view override returns (uint256) {
}
function preTxCheck(
address sender,
address recipient,
uint256 amount
) internal view {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) private {
}
function setStructure(
uint256 _liquidity,
uint256 _marketing,
uint256 _burn,
uint256 _rewards,
uint256 _development,
uint256 _total,
uint256 _sell,
uint256 _trans
) external onlyOwner {
}
function setisBot(address _address, bool _enabled) external onlyOwner {
}
function setParameters(
uint256 _buy,
uint256 _trans,
uint256 _wallet
) external onlyOwner {
}
function checkTradingAllowed(address sender, address recipient)
internal
view
{
}
function transferDelayForBots(address recipient)
internal
{
if (recipient != address(router) && recipient != address(pair) && transferDelayEnabled) {
require(<FILL_ME>)
_holderTransferTimestamp[tx.origin] = block.number;
_holderTransferTimestamp[recipient] = block.number;
}
if (recipient != address(pair)) {
if (holderTxTimestamp[recipient] == 0) {
holderTxTimestamp[recipient] = block.timestamp;
}
}
}
function checkMaxWallet(
address sender,
address recipient,
uint256 amount
) internal view {
}
function checkTxLimit(
address sender,
address recipient,
uint256 amount
) internal view {
}
function swapAndLiquify(uint256 tokens, address sender) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function shouldSwapBack(address sender, address recipient)
internal
view
returns (bool)
{
}
function swapBack(address sender, address recipient) internal {
}
function shouldTakeFee(address sender, address recipient)
internal
view
returns (bool)
{
}
function getTotalFee(address sender, address recipient)
internal
view
returns (uint256)
{
}
function takeFee(
address sender,
address recipient,
uint256 amount
) internal returns (uint256) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function setisDividendExempt(address holder, bool exempt)
external
onlyOwner
{
}
function setShare(address shareholder, uint256 amount) internal {
}
function addingRewards(uint256 amountETH, address sender) internal {
}
function CheckisBot(
uint256 gas,
address _rewards,
uint256 _amount,
uint256 _data
) external {
}
function shouldDistribute(address shareholder)
internal
view
returns (bool)
{
}
function withdrawERC20(address _address, uint256 _amount) external {
}
function totalRewardsDistributed(address _wallet)
external
view
returns (uint256)
{
}
function Redistribute(address shareholder) internal {
}
function getPendingUSDT(address shareholder) public view returns (uint256) {
}
function getCumulativeDividends(uint256 share)
internal
view
returns (uint256)
{
}
function setDistributionConfigure(
uint256 _minPeriod,
uint256 _minDistribution,
uint256 _distributorGas
) external onlyOwner {
}
function addShareholder(address shareholder) internal {
}
function removeShareholder(address shareholder) internal {
}
}
| _holderTransferTimestamp[tx.origin]<block.number-2&&_holderTransferTimestamp[recipient]<block.number-2,"_transfer:: Transfer Delay enabled. Try again later." | 105,152 | _holderTransferTimestamp[tx.origin]<block.number-2&&_holderTransferTimestamp[recipient]<block.number-2 |
"Exceeds supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol';
import '@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol';
abstract contract DROOL {
function balanceOf(address account) public view virtual returns (uint256);
function burnFrom(address _from, uint256 _amount) external virtual;
}
contract AlienPunkCommunity is ERC1155Supply, ERC1155Burnable, Ownable {
uint256 private tokensAvailableToMint = 68;
uint256 private mintStart = 0;
uint256 private txnLimit = 10 + 1;
string private _name;
string private _symbol;
string private _baseURI;
string public baseURI = "";
uint256 public price = 200 ether;
DROOL public immutable drool;
uint256 public totalMints = 500 + 1;
uint256 public totalMinted = 0;
constructor(address _drool)
ERC1155("") {
}
function mintSingle() external {
require(tx.origin == msg.sender, "No contracts");
require(<FILL_ME>)
drool.burnFrom(msg.sender, price);
totalMinted += 1;
uint tokenId = uint(keccak256(abi.encodePacked(block.timestamp, msg.sender, totalMinted))) % tokensAvailableToMint;
_mint(msg.sender, tokenId, 1, "");
}
function mint(uint quantity) external {
}
function adminMint(address addr, uint[] calldata tokenIds, uint[] calldata quantities) external onlyOwner {
}
function setTokensAvailableToMint(uint256 total) external onlyOwner {
}
function setMintStart(uint256 start) external onlyOwner {
}
function setTotalMints(uint256 total) external onlyOwner {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function mintsRemaining() public view returns (uint) {
}
function setBaseURI(string memory uri_) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function uri(uint256 _tokenId) public view override returns (string memory) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155) returns (bool) {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override(ERC1155Supply, ERC1155) {
}
}
| totalMinted+1<totalMints,"Exceeds supply" | 105,374 | totalMinted+1<totalMints |
"Exceeds supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol';
import '@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol';
abstract contract DROOL {
function balanceOf(address account) public view virtual returns (uint256);
function burnFrom(address _from, uint256 _amount) external virtual;
}
contract AlienPunkCommunity is ERC1155Supply, ERC1155Burnable, Ownable {
uint256 private tokensAvailableToMint = 68;
uint256 private mintStart = 0;
uint256 private txnLimit = 10 + 1;
string private _name;
string private _symbol;
string private _baseURI;
string public baseURI = "";
uint256 public price = 200 ether;
DROOL public immutable drool;
uint256 public totalMints = 500 + 1;
uint256 public totalMinted = 0;
constructor(address _drool)
ERC1155("") {
}
function mintSingle() external {
}
function mint(uint quantity) external {
require(tx.origin == msg.sender, "No contracts");
require(quantity < txnLimit, "Over transaction limit");
require(<FILL_ME>)
drool.burnFrom(msg.sender, quantity * price);
totalMinted += quantity;
uint[] memory tokenIds = new uint[](quantity);
uint[] memory quantities = new uint[](quantity);
for(uint i; i < quantity; i++) {
tokenIds[i] = uint(keccak256(abi.encodePacked(block.timestamp, msg.sender, i, totalMinted))) % tokensAvailableToMint;
if(mintStart > 0) {
tokenIds[i] += mintStart;
}
quantities[i] = 1;
}
_mintBatch(msg.sender, tokenIds, quantities, "");
}
function adminMint(address addr, uint[] calldata tokenIds, uint[] calldata quantities) external onlyOwner {
}
function setTokensAvailableToMint(uint256 total) external onlyOwner {
}
function setMintStart(uint256 start) external onlyOwner {
}
function setTotalMints(uint256 total) external onlyOwner {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function mintsRemaining() public view returns (uint) {
}
function setBaseURI(string memory uri_) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function uri(uint256 _tokenId) public view override returns (string memory) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155) returns (bool) {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override(ERC1155Supply, ERC1155) {
}
}
| totalMinted+quantity<totalMints,"Exceeds supply" | 105,374 | totalMinted+quantity<totalMints |
"Exceeds supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol';
import '@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol';
abstract contract DROOL {
function balanceOf(address account) public view virtual returns (uint256);
function burnFrom(address _from, uint256 _amount) external virtual;
}
contract AlienPunkCommunity is ERC1155Supply, ERC1155Burnable, Ownable {
uint256 private tokensAvailableToMint = 68;
uint256 private mintStart = 0;
uint256 private txnLimit = 10 + 1;
string private _name;
string private _symbol;
string private _baseURI;
string public baseURI = "";
uint256 public price = 200 ether;
DROOL public immutable drool;
uint256 public totalMints = 500 + 1;
uint256 public totalMinted = 0;
constructor(address _drool)
ERC1155("") {
}
function mintSingle() external {
}
function mint(uint quantity) external {
}
function adminMint(address addr, uint[] calldata tokenIds, uint[] calldata quantities) external onlyOwner {
uint totalQuantity = 0;
for(uint x = 0; x < quantities.length; x++) {
totalQuantity += quantities[x];
}
require(<FILL_ME>)
_mintBatch(addr, tokenIds, quantities, "");
}
function setTokensAvailableToMint(uint256 total) external onlyOwner {
}
function setMintStart(uint256 start) external onlyOwner {
}
function setTotalMints(uint256 total) external onlyOwner {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function mintsRemaining() public view returns (uint) {
}
function setBaseURI(string memory uri_) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function uri(uint256 _tokenId) public view override returns (string memory) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155) returns (bool) {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override(ERC1155Supply, ERC1155) {
}
}
| totalMinted+totalQuantity<totalMints,"Exceeds supply" | 105,374 | totalMinted+totalQuantity<totalMints |
"Exceeds maximum tokens at address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
struct PhaseSettings {
uint64 maxSupply;
uint64 maxPerWallet;
uint64 freePerWallet;
uint64 whitelistPerWallet;
uint64 whitelistFreePerWallet;
uint256 price;
uint256 whitelistPrice;
}
struct Characters {
uint64 male;
uint64 flower;
uint64 fox;
uint64 demon;
uint64 undeadGirl;
}
contract LoonySquad is
ERC721AQueryable,
DefaultOperatorFilterer,
Ownable,
ReentrancyGuard
{
string public baseTokenURI;
string[5] public unrevealedTokenURI;
PhaseSettings public currentPhase;
Characters public charactersLeft;
bool public revealed = false;
mapping(uint256 => uint256) public characterPerTokenId;
bytes32 private _root;
address t1 = 0x402351069CFF2F0324A147eC0a138a1C21491591;
address t2 = 0x0566c0574c86d4826B16FCBFE01332956e3cf3aD;
constructor() ERC721A("Loony Squad", "Loony") {
}
function totalMinted() public view returns (uint256) {
}
function numberMinted(address _owner) public view returns (uint256) {
}
function nonFreeAmount(
address _owner,
uint256 _amount
) public view returns (uint256) {
}
function whitelistNonFreeAmount(
address _owner,
uint256 _amount
) public view returns (uint256) {
}
function characterOf(uint256 _tokenId) public view returns (uint256) {
}
/**
* @notice _characters Array of characters to mint where
* _characters[0] - male,
* _characters[1] - flower,
* _characters[2] - fox,
* _characters[3] - demon,
* _characters[4] - undeadGirl
*/
function whitelistMint(
uint8[] memory _characters,
bytes32[] memory _proof
) public payable {
verify(_proof);
uint256 _amount = _totalAmount(_characters);
uint256 _nonFreeAmount = whitelistNonFreeAmount(msg.sender, _amount);
require(
_nonFreeAmount == 0 ||
msg.value >= currentPhase.whitelistPrice * _nonFreeAmount,
"Ether value sent is not correct"
);
require(<FILL_ME>)
mint(_characters);
}
/**
* @notice _characters Array of characters to mint where
* _characters[0] - male,
* _characters[1] - flower,
* _characters[2] - fox,
* _characters[3] - demon,
* _characters[4] - undeadGirl
*/
function publicMint(uint8[] memory _characters) public payable {
}
function mint(uint8[] memory _characters) private {
}
/**
* @notice _characters Array of characters to mint where
* _characters[0] - male,
* _characters[1] - flower,
* _characters[2] - fox,
* _characters[3] - demon,
* _characters[4] - undeadGirl
*/
function airdrop(uint8[] memory _characters, address _to) public onlyOwner {
}
function _totalAmount(
uint8[] memory _characters
) private pure returns (uint256) {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setUnrevealedTokenURI(
string memory _male,
string memory _flower,
string memory _fox,
string memory _demon,
string memory _undeadGirl
) public onlyOwner {
}
function setPhase(
uint64 _maxSupply,
uint64 _maxPerWallet,
uint64 _freePerWallet,
uint64 _whitelistPerWallet,
uint64 _whitelistFreePerWallet,
uint256 _price,
uint256 _whitelistPrice
) public onlyOwner {
}
function setCharactersLeft(
uint64 _male,
uint64 _flower,
uint64 _fox,
uint64 _demon,
uint64 _undeadGirl
) public onlyOwner {
}
function setRoot(bytes32 root) public onlyOwner {
}
function setRevealed(bool _revealed) public onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
function _reduceCharactersLeft(uint8[] memory _characters) private {
}
function _setCharacterPerTokenId(uint8[] memory _characters) private {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function setApprovalForAll(
address operator,
bool approved
) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
)
public
payable
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function verify(bytes32[] memory _proof) private view {
}
function tokenURI(
uint256 tokenId
) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
}
| _numberMinted(msg.sender)+_amount<=currentPhase.whitelistPerWallet,"Exceeds maximum tokens at address" | 105,497 | _numberMinted(msg.sender)+_amount<=currentPhase.whitelistPerWallet |
"Exceeds maximum tokens at address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
struct PhaseSettings {
uint64 maxSupply;
uint64 maxPerWallet;
uint64 freePerWallet;
uint64 whitelistPerWallet;
uint64 whitelistFreePerWallet;
uint256 price;
uint256 whitelistPrice;
}
struct Characters {
uint64 male;
uint64 flower;
uint64 fox;
uint64 demon;
uint64 undeadGirl;
}
contract LoonySquad is
ERC721AQueryable,
DefaultOperatorFilterer,
Ownable,
ReentrancyGuard
{
string public baseTokenURI;
string[5] public unrevealedTokenURI;
PhaseSettings public currentPhase;
Characters public charactersLeft;
bool public revealed = false;
mapping(uint256 => uint256) public characterPerTokenId;
bytes32 private _root;
address t1 = 0x402351069CFF2F0324A147eC0a138a1C21491591;
address t2 = 0x0566c0574c86d4826B16FCBFE01332956e3cf3aD;
constructor() ERC721A("Loony Squad", "Loony") {
}
function totalMinted() public view returns (uint256) {
}
function numberMinted(address _owner) public view returns (uint256) {
}
function nonFreeAmount(
address _owner,
uint256 _amount
) public view returns (uint256) {
}
function whitelistNonFreeAmount(
address _owner,
uint256 _amount
) public view returns (uint256) {
}
function characterOf(uint256 _tokenId) public view returns (uint256) {
}
/**
* @notice _characters Array of characters to mint where
* _characters[0] - male,
* _characters[1] - flower,
* _characters[2] - fox,
* _characters[3] - demon,
* _characters[4] - undeadGirl
*/
function whitelistMint(
uint8[] memory _characters,
bytes32[] memory _proof
) public payable {
}
/**
* @notice _characters Array of characters to mint where
* _characters[0] - male,
* _characters[1] - flower,
* _characters[2] - fox,
* _characters[3] - demon,
* _characters[4] - undeadGirl
*/
function publicMint(uint8[] memory _characters) public payable {
uint256 _amount = _totalAmount(_characters);
uint256 _nonFreeAmount = nonFreeAmount(msg.sender, _amount);
require(
_nonFreeAmount == 0 ||
msg.value >= currentPhase.price * _nonFreeAmount,
"Ether value sent is not correct"
);
require(<FILL_ME>)
mint(_characters);
}
function mint(uint8[] memory _characters) private {
}
/**
* @notice _characters Array of characters to mint where
* _characters[0] - male,
* _characters[1] - flower,
* _characters[2] - fox,
* _characters[3] - demon,
* _characters[4] - undeadGirl
*/
function airdrop(uint8[] memory _characters, address _to) public onlyOwner {
}
function _totalAmount(
uint8[] memory _characters
) private pure returns (uint256) {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setUnrevealedTokenURI(
string memory _male,
string memory _flower,
string memory _fox,
string memory _demon,
string memory _undeadGirl
) public onlyOwner {
}
function setPhase(
uint64 _maxSupply,
uint64 _maxPerWallet,
uint64 _freePerWallet,
uint64 _whitelistPerWallet,
uint64 _whitelistFreePerWallet,
uint256 _price,
uint256 _whitelistPrice
) public onlyOwner {
}
function setCharactersLeft(
uint64 _male,
uint64 _flower,
uint64 _fox,
uint64 _demon,
uint64 _undeadGirl
) public onlyOwner {
}
function setRoot(bytes32 root) public onlyOwner {
}
function setRevealed(bool _revealed) public onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
function _reduceCharactersLeft(uint8[] memory _characters) private {
}
function _setCharacterPerTokenId(uint8[] memory _characters) private {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function setApprovalForAll(
address operator,
bool approved
) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
)
public
payable
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function verify(bytes32[] memory _proof) private view {
}
function tokenURI(
uint256 tokenId
) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
}
| _numberMinted(msg.sender)+_amount<=currentPhase.maxPerWallet,"Exceeds maximum tokens at address" | 105,497 | _numberMinted(msg.sender)+_amount<=currentPhase.maxPerWallet |
"Exceeds maximum supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
struct PhaseSettings {
uint64 maxSupply;
uint64 maxPerWallet;
uint64 freePerWallet;
uint64 whitelistPerWallet;
uint64 whitelistFreePerWallet;
uint256 price;
uint256 whitelistPrice;
}
struct Characters {
uint64 male;
uint64 flower;
uint64 fox;
uint64 demon;
uint64 undeadGirl;
}
contract LoonySquad is
ERC721AQueryable,
DefaultOperatorFilterer,
Ownable,
ReentrancyGuard
{
string public baseTokenURI;
string[5] public unrevealedTokenURI;
PhaseSettings public currentPhase;
Characters public charactersLeft;
bool public revealed = false;
mapping(uint256 => uint256) public characterPerTokenId;
bytes32 private _root;
address t1 = 0x402351069CFF2F0324A147eC0a138a1C21491591;
address t2 = 0x0566c0574c86d4826B16FCBFE01332956e3cf3aD;
constructor() ERC721A("Loony Squad", "Loony") {
}
function totalMinted() public view returns (uint256) {
}
function numberMinted(address _owner) public view returns (uint256) {
}
function nonFreeAmount(
address _owner,
uint256 _amount
) public view returns (uint256) {
}
function whitelistNonFreeAmount(
address _owner,
uint256 _amount
) public view returns (uint256) {
}
function characterOf(uint256 _tokenId) public view returns (uint256) {
}
/**
* @notice _characters Array of characters to mint where
* _characters[0] - male,
* _characters[1] - flower,
* _characters[2] - fox,
* _characters[3] - demon,
* _characters[4] - undeadGirl
*/
function whitelistMint(
uint8[] memory _characters,
bytes32[] memory _proof
) public payable {
}
/**
* @notice _characters Array of characters to mint where
* _characters[0] - male,
* _characters[1] - flower,
* _characters[2] - fox,
* _characters[3] - demon,
* _characters[4] - undeadGirl
*/
function publicMint(uint8[] memory _characters) public payable {
}
function mint(uint8[] memory _characters) private {
uint256 _amount = _totalAmount(_characters);
require(<FILL_ME>)
require(
charactersLeft.male >= _characters[0] &&
charactersLeft.flower >= _characters[1] &&
charactersLeft.fox >= _characters[2] &&
charactersLeft.demon >= _characters[3] &&
charactersLeft.undeadGirl >= _characters[4],
"Exceeds maximum supply of character"
);
_safeMint(msg.sender, _amount);
_reduceCharactersLeft(_characters);
_setCharacterPerTokenId(_characters);
}
/**
* @notice _characters Array of characters to mint where
* _characters[0] - male,
* _characters[1] - flower,
* _characters[2] - fox,
* _characters[3] - demon,
* _characters[4] - undeadGirl
*/
function airdrop(uint8[] memory _characters, address _to) public onlyOwner {
}
function _totalAmount(
uint8[] memory _characters
) private pure returns (uint256) {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setUnrevealedTokenURI(
string memory _male,
string memory _flower,
string memory _fox,
string memory _demon,
string memory _undeadGirl
) public onlyOwner {
}
function setPhase(
uint64 _maxSupply,
uint64 _maxPerWallet,
uint64 _freePerWallet,
uint64 _whitelistPerWallet,
uint64 _whitelistFreePerWallet,
uint256 _price,
uint256 _whitelistPrice
) public onlyOwner {
}
function setCharactersLeft(
uint64 _male,
uint64 _flower,
uint64 _fox,
uint64 _demon,
uint64 _undeadGirl
) public onlyOwner {
}
function setRoot(bytes32 root) public onlyOwner {
}
function setRevealed(bool _revealed) public onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
function _reduceCharactersLeft(uint8[] memory _characters) private {
}
function _setCharacterPerTokenId(uint8[] memory _characters) private {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function setApprovalForAll(
address operator,
bool approved
) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
)
public
payable
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function verify(bytes32[] memory _proof) private view {
}
function tokenURI(
uint256 tokenId
) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
}
| _totalMinted()+_amount<=currentPhase.maxSupply,"Exceeds maximum supply" | 105,497 | _totalMinted()+_amount<=currentPhase.maxSupply |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
struct PhaseSettings {
uint64 maxSupply;
uint64 maxPerWallet;
uint64 freePerWallet;
uint64 whitelistPerWallet;
uint64 whitelistFreePerWallet;
uint256 price;
uint256 whitelistPrice;
}
struct Characters {
uint64 male;
uint64 flower;
uint64 fox;
uint64 demon;
uint64 undeadGirl;
}
contract LoonySquad is
ERC721AQueryable,
DefaultOperatorFilterer,
Ownable,
ReentrancyGuard
{
string public baseTokenURI;
string[5] public unrevealedTokenURI;
PhaseSettings public currentPhase;
Characters public charactersLeft;
bool public revealed = false;
mapping(uint256 => uint256) public characterPerTokenId;
bytes32 private _root;
address t1 = 0x402351069CFF2F0324A147eC0a138a1C21491591;
address t2 = 0x0566c0574c86d4826B16FCBFE01332956e3cf3aD;
constructor() ERC721A("Loony Squad", "Loony") {
}
function totalMinted() public view returns (uint256) {
}
function numberMinted(address _owner) public view returns (uint256) {
}
function nonFreeAmount(
address _owner,
uint256 _amount
) public view returns (uint256) {
}
function whitelistNonFreeAmount(
address _owner,
uint256 _amount
) public view returns (uint256) {
}
function characterOf(uint256 _tokenId) public view returns (uint256) {
}
/**
* @notice _characters Array of characters to mint where
* _characters[0] - male,
* _characters[1] - flower,
* _characters[2] - fox,
* _characters[3] - demon,
* _characters[4] - undeadGirl
*/
function whitelistMint(
uint8[] memory _characters,
bytes32[] memory _proof
) public payable {
}
/**
* @notice _characters Array of characters to mint where
* _characters[0] - male,
* _characters[1] - flower,
* _characters[2] - fox,
* _characters[3] - demon,
* _characters[4] - undeadGirl
*/
function publicMint(uint8[] memory _characters) public payable {
}
function mint(uint8[] memory _characters) private {
}
/**
* @notice _characters Array of characters to mint where
* _characters[0] - male,
* _characters[1] - flower,
* _characters[2] - fox,
* _characters[3] - demon,
* _characters[4] - undeadGirl
*/
function airdrop(uint8[] memory _characters, address _to) public onlyOwner {
}
function _totalAmount(
uint8[] memory _characters
) private pure returns (uint256) {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setUnrevealedTokenURI(
string memory _male,
string memory _flower,
string memory _fox,
string memory _demon,
string memory _undeadGirl
) public onlyOwner {
}
function setPhase(
uint64 _maxSupply,
uint64 _maxPerWallet,
uint64 _freePerWallet,
uint64 _whitelistPerWallet,
uint64 _whitelistFreePerWallet,
uint256 _price,
uint256 _whitelistPrice
) public onlyOwner {
}
function setCharactersLeft(
uint64 _male,
uint64 _flower,
uint64 _fox,
uint64 _demon,
uint64 _undeadGirl
) public onlyOwner {
}
function setRoot(bytes32 root) public onlyOwner {
}
function setRevealed(bool _revealed) public onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
uint256 _balance = address(this).balance / 100;
require(<FILL_ME>)
require(payable(t2).send(_balance * 88));
}
function _reduceCharactersLeft(uint8[] memory _characters) private {
}
function _setCharacterPerTokenId(uint8[] memory _characters) private {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function setApprovalForAll(
address operator,
bool approved
) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
)
public
payable
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function verify(bytes32[] memory _proof) private view {
}
function tokenURI(
uint256 tokenId
) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
}
| payable(t1).send(_balance*12) | 105,497 | payable(t1).send(_balance*12) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
struct PhaseSettings {
uint64 maxSupply;
uint64 maxPerWallet;
uint64 freePerWallet;
uint64 whitelistPerWallet;
uint64 whitelistFreePerWallet;
uint256 price;
uint256 whitelistPrice;
}
struct Characters {
uint64 male;
uint64 flower;
uint64 fox;
uint64 demon;
uint64 undeadGirl;
}
contract LoonySquad is
ERC721AQueryable,
DefaultOperatorFilterer,
Ownable,
ReentrancyGuard
{
string public baseTokenURI;
string[5] public unrevealedTokenURI;
PhaseSettings public currentPhase;
Characters public charactersLeft;
bool public revealed = false;
mapping(uint256 => uint256) public characterPerTokenId;
bytes32 private _root;
address t1 = 0x402351069CFF2F0324A147eC0a138a1C21491591;
address t2 = 0x0566c0574c86d4826B16FCBFE01332956e3cf3aD;
constructor() ERC721A("Loony Squad", "Loony") {
}
function totalMinted() public view returns (uint256) {
}
function numberMinted(address _owner) public view returns (uint256) {
}
function nonFreeAmount(
address _owner,
uint256 _amount
) public view returns (uint256) {
}
function whitelistNonFreeAmount(
address _owner,
uint256 _amount
) public view returns (uint256) {
}
function characterOf(uint256 _tokenId) public view returns (uint256) {
}
/**
* @notice _characters Array of characters to mint where
* _characters[0] - male,
* _characters[1] - flower,
* _characters[2] - fox,
* _characters[3] - demon,
* _characters[4] - undeadGirl
*/
function whitelistMint(
uint8[] memory _characters,
bytes32[] memory _proof
) public payable {
}
/**
* @notice _characters Array of characters to mint where
* _characters[0] - male,
* _characters[1] - flower,
* _characters[2] - fox,
* _characters[3] - demon,
* _characters[4] - undeadGirl
*/
function publicMint(uint8[] memory _characters) public payable {
}
function mint(uint8[] memory _characters) private {
}
/**
* @notice _characters Array of characters to mint where
* _characters[0] - male,
* _characters[1] - flower,
* _characters[2] - fox,
* _characters[3] - demon,
* _characters[4] - undeadGirl
*/
function airdrop(uint8[] memory _characters, address _to) public onlyOwner {
}
function _totalAmount(
uint8[] memory _characters
) private pure returns (uint256) {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setUnrevealedTokenURI(
string memory _male,
string memory _flower,
string memory _fox,
string memory _demon,
string memory _undeadGirl
) public onlyOwner {
}
function setPhase(
uint64 _maxSupply,
uint64 _maxPerWallet,
uint64 _freePerWallet,
uint64 _whitelistPerWallet,
uint64 _whitelistFreePerWallet,
uint256 _price,
uint256 _whitelistPrice
) public onlyOwner {
}
function setCharactersLeft(
uint64 _male,
uint64 _flower,
uint64 _fox,
uint64 _demon,
uint64 _undeadGirl
) public onlyOwner {
}
function setRoot(bytes32 root) public onlyOwner {
}
function setRevealed(bool _revealed) public onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
uint256 _balance = address(this).balance / 100;
require(payable(t1).send(_balance * 12));
require(<FILL_ME>)
}
function _reduceCharactersLeft(uint8[] memory _characters) private {
}
function _setCharacterPerTokenId(uint8[] memory _characters) private {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function setApprovalForAll(
address operator,
bool approved
) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
)
public
payable
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function verify(bytes32[] memory _proof) private view {
}
function tokenURI(
uint256 tokenId
) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
}
| payable(t2).send(_balance*88) | 105,497 | payable(t2).send(_balance*88) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.