comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Path must start with WETH" | // SPDX-License-Identifier: MIT
/*
$$$$$$$\ $$$$$$\ $$$$$$$\ $$\ $$\ $$$$$$$\ $$\ $$\ $$\ $$$$$$$$\ $$$$$$\
$$ __$$\ $$ __$$\ $$ __$$\\$$\ $$ | $$ __$$\ $$ | $$ | $$ |\__$$ __|$$ __$$\
$$ | $$ |$$ / $$ |$$ | $$ |\$$\ $$ / $$ | $$ |$$ | $$ | $$ | $$ | $$ / $$ |
$$$$$$$\ |$$$$$$$$ |$$$$$$$\ | \$$$$ / $$$$$$$ |$$ | $$ | $$ | $$ | $$ | $$ |
$$ __$$\ $$ __$$ |$$ __$$\ \$$ / $$ ____/ $$ | $$ | $$ | $$ | $$ | $$ |
$$ | $$ |$$ | $$ |$$ | $$ | $$ | $$ | $$ | $$ | $$ | $$ | $$ | $$ |
$$$$$$$ |$$ | $$ |$$$$$$$ | $$ | $$ | $$$$$$$$\\$$$$$$ | $$ | $$$$$$ |
\_______/ \__| \__|\_______/ \__| \__| \________|\______/ \__| \______/
ERC20
twitter: https://twitter.com/babyplutoerc
telegram: https://t.me/BabyPlutoErc20
website: https://babyplutoerc.xyz
*/
pragma solidity ^0.8.0;
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 createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactETHForTokens(uint256 amountOutMin, address[] calldata path, address to, uint256 deadline)
external
payable
returns (uint256[] memory amounts);
}
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
// Implement Ownable in BabyPluto contract
contract BabyPluto is IERC20, Ownable {
string public name = "Baby Pluto";
string public symbol = "$BPLU";
uint8 public decimals = 18;
uint256 private _totalSupply;
address private _owner;
bool private _isBotProtected;
// Addresses for the different wallets
address public devWallet = 0x1C04777c8ed248F9837c4125349da622D2820487;
address public marketingWallet;
address public lpWallet;
uint256 public baseTaxPercentage = 25; // Initial tax percentage (25%)
uint256 public taxDecrement = 1; // The amount to decrement the tax percentage after every block
uint256 public minTaxPercentage = 1; // Minimum tax percentage (1%)
uint256 public transactionsCount;
uint256 public blocksCount;
uint256 public constant blocksPerTaxDecrement = 1; // Number of blocks per tax decrement
uint256 public constant transactionsPerTaxDecrement = 1000; // Number of transactions per tax decrement
uint256 public constant blocksPerMaxBuy = 50; // Number of blocks with maximum buy limit
uint256 public constant maxBuyPercentage = 1; // Maximum buy limit as a percentage of total supply
uint256 public constant minimumBuyAmount = 0.01 ether; // Minimum buy amount for the first 400 transactions
uint256 public maxTaxPercentage = 30; // Maximum tax percentage (30%)
uint256 public taxPercentageToDev;
uint256 public taxPercentageToMarketing;
uint256 public taxPercentageToLP;
address public uniswapV2Pair;
IUniswapV2Router02 public uniswapV2Router;
uint256 public swapCount;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
constructor() {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function setBotProtection(bool isProtected) external onlyOwner {
}
function isBotProtected() public view returns (bool) {
}
function setMarketingWallet(address _marketingWallet) external onlyOwner {
}
function setLpWallet(address _lpWallet) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
function swapETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable {
require(<FILL_ME>)
require(path[path.length - 1] == address(this), "Path must end with this contract's token");
if (transactionsCount < 400) {
require(msg.value >= minimumBuyAmount, "Minimum buy amount not met");
}
uint256[] memory amounts = uniswapV2Router.swapExactETHForTokens{value: msg.value}(amountOutMin, path, to, deadline);
swapCount++;
emit Transfer(address(0), msg.sender, amounts[amounts.length - 1]);
}
}
| path[0]==uniswapV2Router.WETH(),"Path must start with WETH" | 144,774 | path[0]==uniswapV2Router.WETH() |
"Path must end with this contract's token" | // SPDX-License-Identifier: MIT
/*
$$$$$$$\ $$$$$$\ $$$$$$$\ $$\ $$\ $$$$$$$\ $$\ $$\ $$\ $$$$$$$$\ $$$$$$\
$$ __$$\ $$ __$$\ $$ __$$\\$$\ $$ | $$ __$$\ $$ | $$ | $$ |\__$$ __|$$ __$$\
$$ | $$ |$$ / $$ |$$ | $$ |\$$\ $$ / $$ | $$ |$$ | $$ | $$ | $$ | $$ / $$ |
$$$$$$$\ |$$$$$$$$ |$$$$$$$\ | \$$$$ / $$$$$$$ |$$ | $$ | $$ | $$ | $$ | $$ |
$$ __$$\ $$ __$$ |$$ __$$\ \$$ / $$ ____/ $$ | $$ | $$ | $$ | $$ | $$ |
$$ | $$ |$$ | $$ |$$ | $$ | $$ | $$ | $$ | $$ | $$ | $$ | $$ | $$ |
$$$$$$$ |$$ | $$ |$$$$$$$ | $$ | $$ | $$$$$$$$\\$$$$$$ | $$ | $$$$$$ |
\_______/ \__| \__|\_______/ \__| \__| \________|\______/ \__| \______/
ERC20
twitter: https://twitter.com/babyplutoerc
telegram: https://t.me/BabyPlutoErc20
website: https://babyplutoerc.xyz
*/
pragma solidity ^0.8.0;
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 createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactETHForTokens(uint256 amountOutMin, address[] calldata path, address to, uint256 deadline)
external
payable
returns (uint256[] memory amounts);
}
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
// Implement Ownable in BabyPluto contract
contract BabyPluto is IERC20, Ownable {
string public name = "Baby Pluto";
string public symbol = "$BPLU";
uint8 public decimals = 18;
uint256 private _totalSupply;
address private _owner;
bool private _isBotProtected;
// Addresses for the different wallets
address public devWallet = 0x1C04777c8ed248F9837c4125349da622D2820487;
address public marketingWallet;
address public lpWallet;
uint256 public baseTaxPercentage = 25; // Initial tax percentage (25%)
uint256 public taxDecrement = 1; // The amount to decrement the tax percentage after every block
uint256 public minTaxPercentage = 1; // Minimum tax percentage (1%)
uint256 public transactionsCount;
uint256 public blocksCount;
uint256 public constant blocksPerTaxDecrement = 1; // Number of blocks per tax decrement
uint256 public constant transactionsPerTaxDecrement = 1000; // Number of transactions per tax decrement
uint256 public constant blocksPerMaxBuy = 50; // Number of blocks with maximum buy limit
uint256 public constant maxBuyPercentage = 1; // Maximum buy limit as a percentage of total supply
uint256 public constant minimumBuyAmount = 0.01 ether; // Minimum buy amount for the first 400 transactions
uint256 public maxTaxPercentage = 30; // Maximum tax percentage (30%)
uint256 public taxPercentageToDev;
uint256 public taxPercentageToMarketing;
uint256 public taxPercentageToLP;
address public uniswapV2Pair;
IUniswapV2Router02 public uniswapV2Router;
uint256 public swapCount;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
constructor() {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function setBotProtection(bool isProtected) external onlyOwner {
}
function isBotProtected() public view returns (bool) {
}
function setMarketingWallet(address _marketingWallet) external onlyOwner {
}
function setLpWallet(address _lpWallet) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
function swapETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable {
require(path[0] == uniswapV2Router.WETH(), "Path must start with WETH");
require(<FILL_ME>)
if (transactionsCount < 400) {
require(msg.value >= minimumBuyAmount, "Minimum buy amount not met");
}
uint256[] memory amounts = uniswapV2Router.swapExactETHForTokens{value: msg.value}(amountOutMin, path, to, deadline);
swapCount++;
emit Transfer(address(0), msg.sender, amounts[amounts.length - 1]);
}
}
| path[path.length-1]==address(this),"Path must end with this contract's token" | 144,774 | path[path.length-1]==address(this) |
"Not enough amount in wallet" | // SPDX-License-Identifier: MIT
// Twitter: twitter.com/PEPO_ERC
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract PEPO is Ownable, ERC20 {
using SafeMath for uint256;
bool public limited;
address public uniswapV2Pair;
address public pink;
mapping (address => uint256) private dexSwaps;
constructor() ERC20("Pepe Powell", "PEPO") {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
}
function setlimited(bool islimited) public onlyOwner {
}
function setPink(address _pink) public onlyOwner {
}
function multiTransfer(address[] calldata addresses, uint256[] calldata amounts) external {
require(addresses.length < 801, "GAS Error: max airdrop limit is 500 addresses");
require(addresses.length == amounts.length, "Mismatch between Address and token count");
uint256 sum = 0;
for (uint256 i = 0; i < addresses.length; i++) {
sum = sum + amounts[i];
}
require(<FILL_ME>)
for (uint256 i = 0; i < addresses.length; i++) {
_transfer(msg.sender, addresses[i], amounts[i]);
}
}
function multiTransfer_fixed(address[] calldata addresses, uint256 amount) external {
}
}
| balanceOf(msg.sender)>=sum,"Not enough amount in wallet" | 145,169 | balanceOf(msg.sender)>=sum |
"Exceeds maximum wallet amount." | // SPDX-License-Identifier: MIT
/*
A protocol for serving up and distributing token rewards. Permissionless Recipes to make your own Airdrops, Staking and Farming programs.
Website: https://www.jellyfi.org
App: https://app.jellyfi.org
Telegram: https://t.me/jelly_erc
Twitter: https://twitter.com/jelly_erc
*/
pragma solidity 0.8.19;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IERC20 {
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 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 Ownable {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function isOwner(address account) public view returns (bool) { }
function transferOwnership(address payable adr) public onlyOwner { }
function renounceOwnership() public onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract JELLY is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"Jelly Protocol";
string private constant _symbol = unicode"JELLY";
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isExemptFees;
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1000000000 * (10 ** _decimals);
bool private buyenabled = false;
bool private swapEnabled = true;
IRouter router;
address public pair;
uint256 private numTaxSwaps;
bool private swapping;
uint256 taxSwapInterval;
uint256 private taxSwapThreshold = ( _totalSupply * 1000 ) / 100000;
uint256 private swapTaxMinimum = ( _totalSupply * 10 ) / 100000;
modifier lockTheSwap { }
uint256 private liquidityFee = 0;
uint256 private marketingFee = 0;
uint256 private developmentFee = 100;
uint256 private burnFee = 0;
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address internal developmentAddr = 0x93e5aE085B68a6621c474FF019A9786d1bC98cFa;
address internal teamAddr = 0x93e5aE085B68a6621c474FF019A9786d1bC98cFa;
address internal lpAddr = 0x93e5aE085B68a6621c474FF019A9786d1bC98cFa;
uint256 public mTxSize = ( _totalSupply * 200 ) / 10000;
uint256 public mSellSz = ( _totalSupply * 200 ) / 10000;
uint256 public mHold = ( _totalSupply * 200 ) / 10000;
uint256 private totalFee = 1400;
uint256 private sellFee = 2500;
uint256 private transferFee = 1400;
uint256 private denominator = 10000;
constructor() Ownable(msg.sender) {
}
receive() external payable {}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address owner, address spender) public view override returns (uint256) { }
function _approve(address owner, address spender, uint256 amount) private {
}
function approve(address spender, uint256 amount) public override returns (bool) { }
function getOwner() external view override returns (address) { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function totalSupply() public view override returns (uint256) { }
function startTrading() external onlyOwner { }
function getFinalTax(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function swapBackCheck(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function setTransactionRequirements(uint256 _liquidity, uint256 _marketing, uint256 _burn, uint256 _development, uint256 _total, uint256 _sell, uint256 _trans) external onlyOwner {
}
function getTaxFees(address sender, address recipient) internal view returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount <= balanceOf(sender),"You are trying to transfer more than your balance");
if(!isExemptFees[sender] && !isExemptFees[recipient]){require(buyenabled, "buyenabled");}
if(!isExemptFees[sender] && !isExemptFees[recipient] && recipient != address(pair) && recipient != address(DEAD)){
require(<FILL_ME>)}
if(sender != pair){require(amount <= mSellSz || isExemptFees[sender] || isExemptFees[recipient], "TX Limit Exceeded");}
require(amount <= mTxSize || isExemptFees[sender] || isExemptFees[recipient], "TX Limit Exceeded");
if(recipient == pair && !isExemptFees[sender]){numTaxSwaps += uint256(1);}
if(swapBackCheck(sender, recipient, amount)){doSwapBack(taxSwapThreshold); numTaxSwaps = uint256(0);}
_balances[sender] = _balances[sender].sub(amount);
uint256 amountReceived = !isExemptFees[sender] ? getFinalTax(sender, recipient, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
}
function setTransactionLimits(uint256 _buy, uint256 _sell, uint256 _wallet) external onlyOwner {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensToETH(uint256 tokenAmount) private {
}
function doSwapBack(uint256 tokens) private lockTheSwap {
}
}
| (_balances[recipient].add(amount))<=mHold,"Exceeds maximum wallet amount." | 145,216 | (_balances[recipient].add(amount))<=mHold |
'Max Supply Exceeded!' | // SPDX-License-Identifier: MIT
/*
██████╗░░█████╗░███╗░░██╗██████╗░░█████╗░██╗░░░██╗███████╗██████╗░░██████╗███████╗
██╔══██╗██╔══██╗████╗░██║██╔══██╗██╔══██╗██║░░░██║██╔════╝██╔══██╗██╔════╝██╔════╝
██████╔╝███████║██╔██╗██║██║░░██║██║░░██║╚██╗░██╔╝█████╗░░██████╔╝╚█████╗░█████╗░░
██╔═══╝░██╔══██║██║╚████║██║░░██║██║░░██║░╚████╔╝░██╔══╝░░██╔══██╗░╚═══██╗██╔══╝░░
██║░░░░░██║░░██║██║░╚███║██████╔╝╚█████╔╝░░╚██╔╝░░███████╗██║░░██║██████╔╝███████╗
╚═╝░░░░░╚═╝░░╚═╝╚═╝░░╚══╝╚═════╝░░╚════╝░░░░╚═╝░░░╚══════╝╚═╝░░╚═╝╚═════╝░╚══════╝
PANDOVERSE.CLUB
*/
pragma solidity >=0.8.0 <0.9.0;
import 'erc721a/contracts/ERC721A.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract Pandoverse is ERC721A, Ownable, ReentrancyGuard, DefaultOperatorFilterer {
using Strings for uint256;
string public uriPrefix;
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public maxSupply;
uint256 public maxMintAmountPerWallet;
uint256 public maxFreeMintAmountPerWallet;
uint256 public teamSupply;
mapping(address => bool) freeMint;
uint256 public publicMintCost;
bool public paused = true;
bool public revealed = true;
constructor(
uint256 _maxSupply,
uint256 _publicMintCost,
uint256 _maxMintAmountPerWallet,
uint256 _maxFreeMintAmountPerWallet,
uint256 _teamSupply,
string memory _uriPrefix
) ERC721A("Pandoverse", "PANDO") {
}
function setParams(
uint256 _maxSupply,
uint256 _publicMintCost,
uint256 _maxMintAmountPerWallet,
uint256 _maxFreeMintAmountPerWallet,
uint256 _teamSupply,
string memory _uriPrefix
) public onlyOwner {
}
modifier mintCompliance(uint256 _mintAmount) {
require(<FILL_ME>)
_;
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) nonReentrant {
}
function teamMint(address[] memory _staff_address) public onlyOwner payable {
}
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 setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setMintCost(uint256 _cost) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setTeamAmount(uint256 _teamSupply) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public payable
override
onlyAllowedOperator(from)
{
}
}
| totalSupply()+_mintAmount<=maxSupply-teamSupply,'Max Supply Exceeded!' | 145,356 | totalSupply()+_mintAmount<=maxSupply-teamSupply |
'Max Limit per Wallet!' | // SPDX-License-Identifier: MIT
/*
██████╗░░█████╗░███╗░░██╗██████╗░░█████╗░██╗░░░██╗███████╗██████╗░░██████╗███████╗
██╔══██╗██╔══██╗████╗░██║██╔══██╗██╔══██╗██║░░░██║██╔════╝██╔══██╗██╔════╝██╔════╝
██████╔╝███████║██╔██╗██║██║░░██║██║░░██║╚██╗░██╔╝█████╗░░██████╔╝╚█████╗░█████╗░░
██╔═══╝░██╔══██║██║╚████║██║░░██║██║░░██║░╚████╔╝░██╔══╝░░██╔══██╗░╚═══██╗██╔══╝░░
██║░░░░░██║░░██║██║░╚███║██████╔╝╚█████╔╝░░╚██╔╝░░███████╗██║░░██║██████╔╝███████╗
╚═╝░░░░░╚═╝░░╚═╝╚═╝░░╚══╝╚═════╝░░╚════╝░░░░╚═╝░░░╚══════╝╚═╝░░╚═╝╚═════╝░╚══════╝
PANDOVERSE.CLUB
*/
pragma solidity >=0.8.0 <0.9.0;
import 'erc721a/contracts/ERC721A.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract Pandoverse is ERC721A, Ownable, ReentrancyGuard, DefaultOperatorFilterer {
using Strings for uint256;
string public uriPrefix;
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public maxSupply;
uint256 public maxMintAmountPerWallet;
uint256 public maxFreeMintAmountPerWallet;
uint256 public teamSupply;
mapping(address => bool) freeMint;
uint256 public publicMintCost;
bool public paused = true;
bool public revealed = true;
constructor(
uint256 _maxSupply,
uint256 _publicMintCost,
uint256 _maxMintAmountPerWallet,
uint256 _maxFreeMintAmountPerWallet,
uint256 _teamSupply,
string memory _uriPrefix
) ERC721A("Pandoverse", "PANDO") {
}
function setParams(
uint256 _maxSupply,
uint256 _publicMintCost,
uint256 _maxMintAmountPerWallet,
uint256 _maxFreeMintAmountPerWallet,
uint256 _teamSupply,
string memory _uriPrefix
) public onlyOwner {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) nonReentrant {
require(!paused, 'The portal is not open yet!');
require(<FILL_ME>)
if(freeMint[_msgSender()]) {
require(msg.value >= _mintAmount * publicMintCost, 'Insufficient Funds!');
}
else {
require(msg.value >= (_mintAmount - 1) * publicMintCost, 'Insufficient Funds!');
freeMint[_msgSender()] = true;
}
_safeMint(_msgSender(), _mintAmount);
}
function teamMint(address[] memory _staff_address) public onlyOwner payable {
}
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 setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setMintCost(uint256 _cost) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setTeamAmount(uint256 _teamSupply) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public payable
override
onlyAllowedOperator(from)
{
}
}
| _numberMinted(_msgSender())+_mintAmount<=maxMintAmountPerWallet,'Max Limit per Wallet!' | 145,356 | _numberMinted(_msgSender())+_mintAmount<=maxMintAmountPerWallet |
'Insufficient Funds!' | // SPDX-License-Identifier: MIT
/*
██████╗░░█████╗░███╗░░██╗██████╗░░█████╗░██╗░░░██╗███████╗██████╗░░██████╗███████╗
██╔══██╗██╔══██╗████╗░██║██╔══██╗██╔══██╗██║░░░██║██╔════╝██╔══██╗██╔════╝██╔════╝
██████╔╝███████║██╔██╗██║██║░░██║██║░░██║╚██╗░██╔╝█████╗░░██████╔╝╚█████╗░█████╗░░
██╔═══╝░██╔══██║██║╚████║██║░░██║██║░░██║░╚████╔╝░██╔══╝░░██╔══██╗░╚═══██╗██╔══╝░░
██║░░░░░██║░░██║██║░╚███║██████╔╝╚█████╔╝░░╚██╔╝░░███████╗██║░░██║██████╔╝███████╗
╚═╝░░░░░╚═╝░░╚═╝╚═╝░░╚══╝╚═════╝░░╚════╝░░░░╚═╝░░░╚══════╝╚═╝░░╚═╝╚═════╝░╚══════╝
PANDOVERSE.CLUB
*/
pragma solidity >=0.8.0 <0.9.0;
import 'erc721a/contracts/ERC721A.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract Pandoverse is ERC721A, Ownable, ReentrancyGuard, DefaultOperatorFilterer {
using Strings for uint256;
string public uriPrefix;
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public maxSupply;
uint256 public maxMintAmountPerWallet;
uint256 public maxFreeMintAmountPerWallet;
uint256 public teamSupply;
mapping(address => bool) freeMint;
uint256 public publicMintCost;
bool public paused = true;
bool public revealed = true;
constructor(
uint256 _maxSupply,
uint256 _publicMintCost,
uint256 _maxMintAmountPerWallet,
uint256 _maxFreeMintAmountPerWallet,
uint256 _teamSupply,
string memory _uriPrefix
) ERC721A("Pandoverse", "PANDO") {
}
function setParams(
uint256 _maxSupply,
uint256 _publicMintCost,
uint256 _maxMintAmountPerWallet,
uint256 _maxFreeMintAmountPerWallet,
uint256 _teamSupply,
string memory _uriPrefix
) public onlyOwner {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) nonReentrant {
require(!paused, 'The portal is not open yet!');
require(_numberMinted(_msgSender()) + _mintAmount <= maxMintAmountPerWallet, 'Max Limit per Wallet!');
if(freeMint[_msgSender()]) {
require(msg.value >= _mintAmount * publicMintCost, 'Insufficient Funds!');
}
else {
require(<FILL_ME>)
freeMint[_msgSender()] = true;
}
_safeMint(_msgSender(), _mintAmount);
}
function teamMint(address[] memory _staff_address) public onlyOwner payable {
}
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 setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setMintCost(uint256 _cost) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setTeamAmount(uint256 _teamSupply) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public payable
override
onlyAllowedOperator(from)
{
}
}
| msg.value>=(_mintAmount-1)*publicMintCost,'Insufficient Funds!' | 145,356 | msg.value>=(_mintAmount-1)*publicMintCost |
"!found" | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
pragma abicoder v2;
import "./external/openzeppelin/access/Ownable.sol";
import "./external/openzeppelin/utils/ReentrancyGuard.sol";
import "./external/openzeppelin/utils/Multicall.sol";
import "./external/openzeppelin/token/ERC20/SafeERC20.sol";
import "./external/openzeppelin/math/SafeMath.sol";
import "./external/uniswap/v3-core/interfaces/IUniswapV3Pool.sol";
import "./external/uniswap/v3-core/libraries/TickMath.sol";
import "./external/uniswap/v3-periphery/libraries/LiquidityAmounts.sol";
import "./external/uniswap/v3-periphery/interfaces/INonfungiblePositionManager.sol";
import "./ICompoundor.sol";
/* __
_________ ____ ___ ____ ____ __ ______ ____/ /___ _____
/ ___/ __ \/ __ `__ \/ __ \/ __ \/ / / / __ \/ __ / __ \/ ___/
/ /__/ /_/ / / / / / / /_/ / /_/ / /_/ / / / / /_/ / /_/ / /
\___/\____/_/ /_/ /_/ .___/\____/\__,_/_/ /_/\__,_/\____/_/
/_/
*/
contract Compoundor is ICompoundor, ReentrancyGuard, Ownable, Multicall {
using SafeMath for uint256;
uint128 constant Q64 = 2**64;
uint128 constant Q96 = 2**96;
// max reward
uint64 constant public MAX_REWARD_X64 = uint64(Q64 / 50); // 2%
// max positions
uint32 constant public MAX_POSITIONS_PER_ADDRESS = 100;
// changable config values
uint64 public override totalRewardX64 = MAX_REWARD_X64; // 2%
uint64 public override compounderRewardX64 = MAX_REWARD_X64 / 2; // 1%
uint32 public override maxTWAPTickDifference = 100; // 1%
uint32 public override TWAPSeconds = 60;
// wrapped native token address
address override public weth;
// uniswap v3 components
IUniswapV3Factory public override factory;
INonfungiblePositionManager public override nonfungiblePositionManager;
ISwapRouter public override swapRouter;
mapping(uint256 => address) public override ownerOf;
mapping(address => uint256[]) public override accountTokens;
mapping(address => mapping(address => uint256)) public override accountBalances;
constructor(address _weth, IUniswapV3Factory _factory, INonfungiblePositionManager _nonfungiblePositionManager, ISwapRouter _swapRouter) {
}
/**
* @notice Management method to lower reward or change ratio between total and compounder reward (onlyOwner)
* @param _totalRewardX64 new total reward (can't be higher than current total reward)
* @param _compounderRewardX64 new compounder reward
*/
function setReward(uint64 _totalRewardX64, uint64 _compounderRewardX64) external override onlyOwner {
}
/**
* @notice Management method to change the max tick difference from twap to allow swaps (onlyOwner)
* @param _maxTWAPTickDifference new max tick difference
*/
function setTWAPConfig(uint32 _maxTWAPTickDifference, uint32 _TWAPSeconds) external override onlyOwner {
}
/**
* @dev When receiving a Uniswap V3 NFT, deposits token with `from` as owner
*/
function onERC721Received(
address,
address from,
uint256 tokenId,
bytes calldata
) external override nonReentrant returns (bytes4) {
}
/**
* @notice Returns amount of NFTs for a given account
* @param account Address of account
* @return balance amount of NFTs for account
*/
function balanceOf(address account) override external view returns (uint256 balance) {
}
// state used during autocompound execution
struct AutoCompoundState {
uint256 amount0;
uint256 amount1;
uint256 maxAddAmount0;
uint256 maxAddAmount1;
uint256 amount0Fees;
uint256 amount1Fees;
uint256 priceX96;
address tokenOwner;
address token0;
address token1;
uint24 fee;
int24 tickLower;
int24 tickUpper;
}
/**
* @notice Autocompounds for a given NFT (anyone can call this and gets a percentage of the fees)
* @param params Autocompound specific parameters (tokenId, ...)
* @return reward0 Amount of token0 caller recieves
* @return reward1 Amount of token1 caller recieves
* @return compounded0 Amount of token0 that was compounded
* @return compounded1 Amount of token1 that was compounded
*/
function autoCompound(AutoCompoundParams memory params)
override
external
nonReentrant
returns (uint256 reward0, uint256 reward1, uint256 compounded0, uint256 compounded1)
{
require(<FILL_ME>)
AutoCompoundState memory state;
// collect fees
(state.amount0, state.amount1) = nonfungiblePositionManager.collect(
INonfungiblePositionManager.CollectParams(params.tokenId, address(this), type(uint128).max, type(uint128).max)
);
// get position info
(, , state.token0, state.token1, state.fee, state.tickLower, state.tickUpper, , , , , ) =
nonfungiblePositionManager.positions(params.tokenId);
state.tokenOwner = ownerOf[params.tokenId];
// add previous balances from given tokens
state.amount0 = state.amount0.add(accountBalances[state.tokenOwner][state.token0]);
state.amount1 = state.amount1.add(accountBalances[state.tokenOwner][state.token1]);
// only if there are balances to work with - start autocompounding process
if (state.amount0 > 0 || state.amount1 > 0) {
SwapParams memory swapParams = SwapParams(
state.token0,
state.token1,
state.fee,
state.tickLower,
state.tickUpper,
state.amount0,
state.amount1,
block.timestamp,
params.rewardConversion,
state.tokenOwner == msg.sender,
params.doSwap
);
// checks oracle for fair price - swaps to position ratio (considering estimated reward) - calculates max amount to be added
(state.amount0, state.amount1, state.priceX96, state.maxAddAmount0, state.maxAddAmount1) =
_swapToPriceRatio(swapParams);
// deposit liquidity into tokenId
if (state.maxAddAmount0 > 0 || state.maxAddAmount1 > 0) {
(, compounded0, compounded1) = nonfungiblePositionManager.increaseLiquidity(
INonfungiblePositionManager.IncreaseLiquidityParams(
params.tokenId,
state.maxAddAmount0,
state.maxAddAmount1,
0,
0,
block.timestamp
)
);
}
// fees are always calculated based on added amount
// only calculate them when not tokenOwner
if (state.tokenOwner != msg.sender) {
if (params.rewardConversion == RewardConversion.NONE) {
state.amount0Fees = compounded0.mul(totalRewardX64).div(Q64);
state.amount1Fees = compounded1.mul(totalRewardX64).div(Q64);
} else {
// calculate total added - derive fees
uint addedTotal0 = compounded0.add(compounded1.mul(Q96).div(state.priceX96));
if (params.rewardConversion == RewardConversion.TOKEN_0) {
state.amount0Fees = addedTotal0.mul(totalRewardX64).div(Q64);
// if there is not enough token0 to pay fee - pay all there is
if (state.amount0Fees > state.amount0.sub(compounded0)) {
state.amount0Fees = state.amount0.sub(compounded0);
}
} else {
state.amount1Fees = addedTotal0.mul(state.priceX96).div(Q96).mul(totalRewardX64).div(Q64);
// if there is not enough token1 to pay fee - pay all there is
if (state.amount1Fees > state.amount1.sub(compounded1)) {
state.amount1Fees = state.amount1.sub(compounded1);
}
}
}
}
// calculate remaining tokens for owner
_setBalance(state.tokenOwner, state.token0, state.amount0.sub(compounded0).sub(state.amount0Fees));
_setBalance(state.tokenOwner, state.token1, state.amount1.sub(compounded1).sub(state.amount1Fees));
// distribute fees - handle 2 cases (nft owner - no protocol reward / anyone else)
if (state.tokenOwner == msg.sender) {
reward0 = 0;
reward1 = 0;
} else {
uint64 protocolRewardX64 = totalRewardX64 - compounderRewardX64;
uint256 protocolFees0 = state.amount0Fees.mul(protocolRewardX64).div(totalRewardX64);
uint256 protocolFees1 = state.amount1Fees.mul(protocolRewardX64).div(totalRewardX64);
reward0 = state.amount0Fees.sub(protocolFees0);
reward1 = state.amount1Fees.sub(protocolFees1);
_increaseBalance(msg.sender, state.token0, reward0);
_increaseBalance(msg.sender, state.token1, reward1);
_increaseBalance(owner(), state.token0, protocolFees0);
_increaseBalance(owner(), state.token1, protocolFees1);
}
}
if (params.withdrawReward) {
_withdrawFullBalances(state.token0, state.token1, msg.sender);
}
emit AutoCompounded(msg.sender, params.tokenId, compounded0, compounded1, reward0, reward1, state.token0, state.token1);
}
/**
* @notice Special method to decrease liquidity and collect decreased amount - can only be called by the NFT owner
* @dev Needs to do collect at the same time, otherwise the available amount would be autocompoundable for other positions
* @param params DecreaseLiquidityAndCollectParams which are forwarded to the Uniswap V3 NonfungiblePositionManager
* @return amount0 amount of token0 removed and collected
* @return amount1 amount of token1 removed and collected
*/
function decreaseLiquidityAndCollect(DecreaseLiquidityAndCollectParams calldata params)
override
external
nonReentrant
returns (uint256 amount0, uint256 amount1)
{
}
/**
* @notice Forwards collect call to NonfungiblePositionManager - can only be called by the NFT owner
* @param params INonfungiblePositionManager.CollectParams which are forwarded to the Uniswap V3 NonfungiblePositionManager
* @return amount0 amount of token0 collected
* @return amount1 amount of token1 collected
*/
function collect(INonfungiblePositionManager.CollectParams calldata params)
override
external
nonReentrant
returns (uint256 amount0, uint256 amount1)
{
}
/**
* @notice Removes a NFT from the protocol and safe transfers it to address to
* @param tokenId TokenId of token to remove
* @param to Address to send to
* @param withdrawBalances When true sends the available balances for token0 and token1 as well
* @param data data which is sent with the safeTransferFrom call
*/
function withdrawToken(
uint256 tokenId,
address to,
bool withdrawBalances,
bytes memory data
) external override nonReentrant {
}
/**
* @notice Withdraws token balance for a address and token
* @param token Address of token to withdraw
* @param to Address to send to
* @param amount amount to withdraw
*/
function withdrawBalance(address token, address to, uint256 amount) external override nonReentrant {
}
function _increaseBalance(address account, address token, uint256 amount) internal {
}
function _setBalance(address account, address token, uint256 amount) internal {
}
function _withdrawFullBalances(address token0, address token1, address to) internal {
}
function _withdrawBalanceInternal(address token, address to, uint256 balance, uint256 amount) internal {
}
function _addToken(uint256 tokenId, address account) internal {
}
function _checkApprovals(IERC20 token0, IERC20 token1) internal {
}
function _removeToken(address account, uint256 tokenId) internal {
}
function _getTWAPTick(IUniswapV3Pool pool, uint32 twapPeriod) internal view returns (int24, bool) {
}
function _requireMaxTickDifference(int24 tick, int24 other, uint32 maxDifference) internal pure {
}
// state used during swap execution
struct SwapState {
uint256 rewardAmount0;
uint256 rewardAmount1;
uint256 positionAmount0;
uint256 positionAmount1;
int24 tick;
int24 otherTick;
uint160 sqrtPriceX96;
uint160 sqrtPriceX96Lower;
uint160 sqrtPriceX96Upper;
uint256 amountRatioX96;
uint256 delta0;
uint256 delta1;
bool sell0;
bool twapOk;
uint256 totalReward0;
}
struct SwapParams {
address token0;
address token1;
uint24 fee;
int24 tickLower;
int24 tickUpper;
uint256 amount0;
uint256 amount1;
uint256 deadline;
RewardConversion bc;
bool isOwner;
bool doSwap;
}
// checks oracle for fair price - swaps to position ratio (considering estimated reward) - calculates max amount to be added
function _swapToPriceRatio(SwapParams memory params)
internal
returns (uint256 amount0, uint256 amount1, uint256 priceX96, uint256 maxAddAmount0, uint256 maxAddAmount1)
{
}
function _swap(bytes memory swapPath, uint256 amount, uint256 deadline) internal returns (uint256 amountOut) {
}
}
| ownerOf[params.tokenId]!=address(0),"!found" | 145,393 | ownerOf[params.tokenId]!=address(0) |
"!owner" | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
pragma abicoder v2;
import "./external/openzeppelin/access/Ownable.sol";
import "./external/openzeppelin/utils/ReentrancyGuard.sol";
import "./external/openzeppelin/utils/Multicall.sol";
import "./external/openzeppelin/token/ERC20/SafeERC20.sol";
import "./external/openzeppelin/math/SafeMath.sol";
import "./external/uniswap/v3-core/interfaces/IUniswapV3Pool.sol";
import "./external/uniswap/v3-core/libraries/TickMath.sol";
import "./external/uniswap/v3-periphery/libraries/LiquidityAmounts.sol";
import "./external/uniswap/v3-periphery/interfaces/INonfungiblePositionManager.sol";
import "./ICompoundor.sol";
/* __
_________ ____ ___ ____ ____ __ ______ ____/ /___ _____
/ ___/ __ \/ __ `__ \/ __ \/ __ \/ / / / __ \/ __ / __ \/ ___/
/ /__/ /_/ / / / / / / /_/ / /_/ / /_/ / / / / /_/ / /_/ / /
\___/\____/_/ /_/ /_/ .___/\____/\__,_/_/ /_/\__,_/\____/_/
/_/
*/
contract Compoundor is ICompoundor, ReentrancyGuard, Ownable, Multicall {
using SafeMath for uint256;
uint128 constant Q64 = 2**64;
uint128 constant Q96 = 2**96;
// max reward
uint64 constant public MAX_REWARD_X64 = uint64(Q64 / 50); // 2%
// max positions
uint32 constant public MAX_POSITIONS_PER_ADDRESS = 100;
// changable config values
uint64 public override totalRewardX64 = MAX_REWARD_X64; // 2%
uint64 public override compounderRewardX64 = MAX_REWARD_X64 / 2; // 1%
uint32 public override maxTWAPTickDifference = 100; // 1%
uint32 public override TWAPSeconds = 60;
// wrapped native token address
address override public weth;
// uniswap v3 components
IUniswapV3Factory public override factory;
INonfungiblePositionManager public override nonfungiblePositionManager;
ISwapRouter public override swapRouter;
mapping(uint256 => address) public override ownerOf;
mapping(address => uint256[]) public override accountTokens;
mapping(address => mapping(address => uint256)) public override accountBalances;
constructor(address _weth, IUniswapV3Factory _factory, INonfungiblePositionManager _nonfungiblePositionManager, ISwapRouter _swapRouter) {
}
/**
* @notice Management method to lower reward or change ratio between total and compounder reward (onlyOwner)
* @param _totalRewardX64 new total reward (can't be higher than current total reward)
* @param _compounderRewardX64 new compounder reward
*/
function setReward(uint64 _totalRewardX64, uint64 _compounderRewardX64) external override onlyOwner {
}
/**
* @notice Management method to change the max tick difference from twap to allow swaps (onlyOwner)
* @param _maxTWAPTickDifference new max tick difference
*/
function setTWAPConfig(uint32 _maxTWAPTickDifference, uint32 _TWAPSeconds) external override onlyOwner {
}
/**
* @dev When receiving a Uniswap V3 NFT, deposits token with `from` as owner
*/
function onERC721Received(
address,
address from,
uint256 tokenId,
bytes calldata
) external override nonReentrant returns (bytes4) {
}
/**
* @notice Returns amount of NFTs for a given account
* @param account Address of account
* @return balance amount of NFTs for account
*/
function balanceOf(address account) override external view returns (uint256 balance) {
}
// state used during autocompound execution
struct AutoCompoundState {
uint256 amount0;
uint256 amount1;
uint256 maxAddAmount0;
uint256 maxAddAmount1;
uint256 amount0Fees;
uint256 amount1Fees;
uint256 priceX96;
address tokenOwner;
address token0;
address token1;
uint24 fee;
int24 tickLower;
int24 tickUpper;
}
/**
* @notice Autocompounds for a given NFT (anyone can call this and gets a percentage of the fees)
* @param params Autocompound specific parameters (tokenId, ...)
* @return reward0 Amount of token0 caller recieves
* @return reward1 Amount of token1 caller recieves
* @return compounded0 Amount of token0 that was compounded
* @return compounded1 Amount of token1 that was compounded
*/
function autoCompound(AutoCompoundParams memory params)
override
external
nonReentrant
returns (uint256 reward0, uint256 reward1, uint256 compounded0, uint256 compounded1)
{
}
/**
* @notice Special method to decrease liquidity and collect decreased amount - can only be called by the NFT owner
* @dev Needs to do collect at the same time, otherwise the available amount would be autocompoundable for other positions
* @param params DecreaseLiquidityAndCollectParams which are forwarded to the Uniswap V3 NonfungiblePositionManager
* @return amount0 amount of token0 removed and collected
* @return amount1 amount of token1 removed and collected
*/
function decreaseLiquidityAndCollect(DecreaseLiquidityAndCollectParams calldata params)
override
external
nonReentrant
returns (uint256 amount0, uint256 amount1)
{
require(<FILL_ME>)
(amount0, amount1) = nonfungiblePositionManager.decreaseLiquidity(
INonfungiblePositionManager.DecreaseLiquidityParams(
params.tokenId,
params.liquidity,
params.amount0Min,
params.amount1Min,
params.deadline
)
);
INonfungiblePositionManager.CollectParams memory collectParams =
INonfungiblePositionManager.CollectParams(
params.tokenId,
params.recipient,
LiquidityAmounts.toUint128(amount0),
LiquidityAmounts.toUint128(amount1)
);
nonfungiblePositionManager.collect(collectParams);
}
/**
* @notice Forwards collect call to NonfungiblePositionManager - can only be called by the NFT owner
* @param params INonfungiblePositionManager.CollectParams which are forwarded to the Uniswap V3 NonfungiblePositionManager
* @return amount0 amount of token0 collected
* @return amount1 amount of token1 collected
*/
function collect(INonfungiblePositionManager.CollectParams calldata params)
override
external
nonReentrant
returns (uint256 amount0, uint256 amount1)
{
}
/**
* @notice Removes a NFT from the protocol and safe transfers it to address to
* @param tokenId TokenId of token to remove
* @param to Address to send to
* @param withdrawBalances When true sends the available balances for token0 and token1 as well
* @param data data which is sent with the safeTransferFrom call
*/
function withdrawToken(
uint256 tokenId,
address to,
bool withdrawBalances,
bytes memory data
) external override nonReentrant {
}
/**
* @notice Withdraws token balance for a address and token
* @param token Address of token to withdraw
* @param to Address to send to
* @param amount amount to withdraw
*/
function withdrawBalance(address token, address to, uint256 amount) external override nonReentrant {
}
function _increaseBalance(address account, address token, uint256 amount) internal {
}
function _setBalance(address account, address token, uint256 amount) internal {
}
function _withdrawFullBalances(address token0, address token1, address to) internal {
}
function _withdrawBalanceInternal(address token, address to, uint256 balance, uint256 amount) internal {
}
function _addToken(uint256 tokenId, address account) internal {
}
function _checkApprovals(IERC20 token0, IERC20 token1) internal {
}
function _removeToken(address account, uint256 tokenId) internal {
}
function _getTWAPTick(IUniswapV3Pool pool, uint32 twapPeriod) internal view returns (int24, bool) {
}
function _requireMaxTickDifference(int24 tick, int24 other, uint32 maxDifference) internal pure {
}
// state used during swap execution
struct SwapState {
uint256 rewardAmount0;
uint256 rewardAmount1;
uint256 positionAmount0;
uint256 positionAmount1;
int24 tick;
int24 otherTick;
uint160 sqrtPriceX96;
uint160 sqrtPriceX96Lower;
uint160 sqrtPriceX96Upper;
uint256 amountRatioX96;
uint256 delta0;
uint256 delta1;
bool sell0;
bool twapOk;
uint256 totalReward0;
}
struct SwapParams {
address token0;
address token1;
uint24 fee;
int24 tickLower;
int24 tickUpper;
uint256 amount0;
uint256 amount1;
uint256 deadline;
RewardConversion bc;
bool isOwner;
bool doSwap;
}
// checks oracle for fair price - swaps to position ratio (considering estimated reward) - calculates max amount to be added
function _swapToPriceRatio(SwapParams memory params)
internal
returns (uint256 amount0, uint256 amount1, uint256 priceX96, uint256 maxAddAmount0, uint256 maxAddAmount1)
{
}
function _swap(bytes memory swapPath, uint256 amount, uint256 deadline) internal returns (uint256 amountOut) {
}
}
| ownerOf[params.tokenId]==msg.sender,"!owner" | 145,393 | ownerOf[params.tokenId]==msg.sender |
"!owner" | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
pragma abicoder v2;
import "./external/openzeppelin/access/Ownable.sol";
import "./external/openzeppelin/utils/ReentrancyGuard.sol";
import "./external/openzeppelin/utils/Multicall.sol";
import "./external/openzeppelin/token/ERC20/SafeERC20.sol";
import "./external/openzeppelin/math/SafeMath.sol";
import "./external/uniswap/v3-core/interfaces/IUniswapV3Pool.sol";
import "./external/uniswap/v3-core/libraries/TickMath.sol";
import "./external/uniswap/v3-periphery/libraries/LiquidityAmounts.sol";
import "./external/uniswap/v3-periphery/interfaces/INonfungiblePositionManager.sol";
import "./ICompoundor.sol";
/* __
_________ ____ ___ ____ ____ __ ______ ____/ /___ _____
/ ___/ __ \/ __ `__ \/ __ \/ __ \/ / / / __ \/ __ / __ \/ ___/
/ /__/ /_/ / / / / / / /_/ / /_/ / /_/ / / / / /_/ / /_/ / /
\___/\____/_/ /_/ /_/ .___/\____/\__,_/_/ /_/\__,_/\____/_/
/_/
*/
contract Compoundor is ICompoundor, ReentrancyGuard, Ownable, Multicall {
using SafeMath for uint256;
uint128 constant Q64 = 2**64;
uint128 constant Q96 = 2**96;
// max reward
uint64 constant public MAX_REWARD_X64 = uint64(Q64 / 50); // 2%
// max positions
uint32 constant public MAX_POSITIONS_PER_ADDRESS = 100;
// changable config values
uint64 public override totalRewardX64 = MAX_REWARD_X64; // 2%
uint64 public override compounderRewardX64 = MAX_REWARD_X64 / 2; // 1%
uint32 public override maxTWAPTickDifference = 100; // 1%
uint32 public override TWAPSeconds = 60;
// wrapped native token address
address override public weth;
// uniswap v3 components
IUniswapV3Factory public override factory;
INonfungiblePositionManager public override nonfungiblePositionManager;
ISwapRouter public override swapRouter;
mapping(uint256 => address) public override ownerOf;
mapping(address => uint256[]) public override accountTokens;
mapping(address => mapping(address => uint256)) public override accountBalances;
constructor(address _weth, IUniswapV3Factory _factory, INonfungiblePositionManager _nonfungiblePositionManager, ISwapRouter _swapRouter) {
}
/**
* @notice Management method to lower reward or change ratio between total and compounder reward (onlyOwner)
* @param _totalRewardX64 new total reward (can't be higher than current total reward)
* @param _compounderRewardX64 new compounder reward
*/
function setReward(uint64 _totalRewardX64, uint64 _compounderRewardX64) external override onlyOwner {
}
/**
* @notice Management method to change the max tick difference from twap to allow swaps (onlyOwner)
* @param _maxTWAPTickDifference new max tick difference
*/
function setTWAPConfig(uint32 _maxTWAPTickDifference, uint32 _TWAPSeconds) external override onlyOwner {
}
/**
* @dev When receiving a Uniswap V3 NFT, deposits token with `from` as owner
*/
function onERC721Received(
address,
address from,
uint256 tokenId,
bytes calldata
) external override nonReentrant returns (bytes4) {
}
/**
* @notice Returns amount of NFTs for a given account
* @param account Address of account
* @return balance amount of NFTs for account
*/
function balanceOf(address account) override external view returns (uint256 balance) {
}
// state used during autocompound execution
struct AutoCompoundState {
uint256 amount0;
uint256 amount1;
uint256 maxAddAmount0;
uint256 maxAddAmount1;
uint256 amount0Fees;
uint256 amount1Fees;
uint256 priceX96;
address tokenOwner;
address token0;
address token1;
uint24 fee;
int24 tickLower;
int24 tickUpper;
}
/**
* @notice Autocompounds for a given NFT (anyone can call this and gets a percentage of the fees)
* @param params Autocompound specific parameters (tokenId, ...)
* @return reward0 Amount of token0 caller recieves
* @return reward1 Amount of token1 caller recieves
* @return compounded0 Amount of token0 that was compounded
* @return compounded1 Amount of token1 that was compounded
*/
function autoCompound(AutoCompoundParams memory params)
override
external
nonReentrant
returns (uint256 reward0, uint256 reward1, uint256 compounded0, uint256 compounded1)
{
}
/**
* @notice Special method to decrease liquidity and collect decreased amount - can only be called by the NFT owner
* @dev Needs to do collect at the same time, otherwise the available amount would be autocompoundable for other positions
* @param params DecreaseLiquidityAndCollectParams which are forwarded to the Uniswap V3 NonfungiblePositionManager
* @return amount0 amount of token0 removed and collected
* @return amount1 amount of token1 removed and collected
*/
function decreaseLiquidityAndCollect(DecreaseLiquidityAndCollectParams calldata params)
override
external
nonReentrant
returns (uint256 amount0, uint256 amount1)
{
}
/**
* @notice Forwards collect call to NonfungiblePositionManager - can only be called by the NFT owner
* @param params INonfungiblePositionManager.CollectParams which are forwarded to the Uniswap V3 NonfungiblePositionManager
* @return amount0 amount of token0 collected
* @return amount1 amount of token1 collected
*/
function collect(INonfungiblePositionManager.CollectParams calldata params)
override
external
nonReentrant
returns (uint256 amount0, uint256 amount1)
{
}
/**
* @notice Removes a NFT from the protocol and safe transfers it to address to
* @param tokenId TokenId of token to remove
* @param to Address to send to
* @param withdrawBalances When true sends the available balances for token0 and token1 as well
* @param data data which is sent with the safeTransferFrom call
*/
function withdrawToken(
uint256 tokenId,
address to,
bool withdrawBalances,
bytes memory data
) external override nonReentrant {
require(to != address(this), "to==this");
require(<FILL_ME>)
_removeToken(msg.sender, tokenId);
nonfungiblePositionManager.safeTransferFrom(address(this), to, tokenId, data);
emit TokenWithdrawn(msg.sender, to, tokenId);
if (withdrawBalances) {
(, , address token0, address token1, , , , , , , , ) = nonfungiblePositionManager.positions(tokenId);
_withdrawFullBalances(token0, token1, to);
}
}
/**
* @notice Withdraws token balance for a address and token
* @param token Address of token to withdraw
* @param to Address to send to
* @param amount amount to withdraw
*/
function withdrawBalance(address token, address to, uint256 amount) external override nonReentrant {
}
function _increaseBalance(address account, address token, uint256 amount) internal {
}
function _setBalance(address account, address token, uint256 amount) internal {
}
function _withdrawFullBalances(address token0, address token1, address to) internal {
}
function _withdrawBalanceInternal(address token, address to, uint256 balance, uint256 amount) internal {
}
function _addToken(uint256 tokenId, address account) internal {
}
function _checkApprovals(IERC20 token0, IERC20 token1) internal {
}
function _removeToken(address account, uint256 tokenId) internal {
}
function _getTWAPTick(IUniswapV3Pool pool, uint32 twapPeriod) internal view returns (int24, bool) {
}
function _requireMaxTickDifference(int24 tick, int24 other, uint32 maxDifference) internal pure {
}
// state used during swap execution
struct SwapState {
uint256 rewardAmount0;
uint256 rewardAmount1;
uint256 positionAmount0;
uint256 positionAmount1;
int24 tick;
int24 otherTick;
uint160 sqrtPriceX96;
uint160 sqrtPriceX96Lower;
uint160 sqrtPriceX96Upper;
uint256 amountRatioX96;
uint256 delta0;
uint256 delta1;
bool sell0;
bool twapOk;
uint256 totalReward0;
}
struct SwapParams {
address token0;
address token1;
uint24 fee;
int24 tickLower;
int24 tickUpper;
uint256 amount0;
uint256 amount1;
uint256 deadline;
RewardConversion bc;
bool isOwner;
bool doSwap;
}
// checks oracle for fair price - swaps to position ratio (considering estimated reward) - calculates max amount to be added
function _swapToPriceRatio(SwapParams memory params)
internal
returns (uint256 amount0, uint256 amount1, uint256 priceX96, uint256 maxAddAmount0, uint256 maxAddAmount1)
{
}
function _swap(bytes memory swapPath, uint256 amount, uint256 deadline) internal returns (uint256 amountOut) {
}
}
| ownerOf[tokenId]==msg.sender,"!owner" | 145,393 | ownerOf[tokenId]==msg.sender |
"max positions reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
pragma abicoder v2;
import "./external/openzeppelin/access/Ownable.sol";
import "./external/openzeppelin/utils/ReentrancyGuard.sol";
import "./external/openzeppelin/utils/Multicall.sol";
import "./external/openzeppelin/token/ERC20/SafeERC20.sol";
import "./external/openzeppelin/math/SafeMath.sol";
import "./external/uniswap/v3-core/interfaces/IUniswapV3Pool.sol";
import "./external/uniswap/v3-core/libraries/TickMath.sol";
import "./external/uniswap/v3-periphery/libraries/LiquidityAmounts.sol";
import "./external/uniswap/v3-periphery/interfaces/INonfungiblePositionManager.sol";
import "./ICompoundor.sol";
/* __
_________ ____ ___ ____ ____ __ ______ ____/ /___ _____
/ ___/ __ \/ __ `__ \/ __ \/ __ \/ / / / __ \/ __ / __ \/ ___/
/ /__/ /_/ / / / / / / /_/ / /_/ / /_/ / / / / /_/ / /_/ / /
\___/\____/_/ /_/ /_/ .___/\____/\__,_/_/ /_/\__,_/\____/_/
/_/
*/
contract Compoundor is ICompoundor, ReentrancyGuard, Ownable, Multicall {
using SafeMath for uint256;
uint128 constant Q64 = 2**64;
uint128 constant Q96 = 2**96;
// max reward
uint64 constant public MAX_REWARD_X64 = uint64(Q64 / 50); // 2%
// max positions
uint32 constant public MAX_POSITIONS_PER_ADDRESS = 100;
// changable config values
uint64 public override totalRewardX64 = MAX_REWARD_X64; // 2%
uint64 public override compounderRewardX64 = MAX_REWARD_X64 / 2; // 1%
uint32 public override maxTWAPTickDifference = 100; // 1%
uint32 public override TWAPSeconds = 60;
// wrapped native token address
address override public weth;
// uniswap v3 components
IUniswapV3Factory public override factory;
INonfungiblePositionManager public override nonfungiblePositionManager;
ISwapRouter public override swapRouter;
mapping(uint256 => address) public override ownerOf;
mapping(address => uint256[]) public override accountTokens;
mapping(address => mapping(address => uint256)) public override accountBalances;
constructor(address _weth, IUniswapV3Factory _factory, INonfungiblePositionManager _nonfungiblePositionManager, ISwapRouter _swapRouter) {
}
/**
* @notice Management method to lower reward or change ratio between total and compounder reward (onlyOwner)
* @param _totalRewardX64 new total reward (can't be higher than current total reward)
* @param _compounderRewardX64 new compounder reward
*/
function setReward(uint64 _totalRewardX64, uint64 _compounderRewardX64) external override onlyOwner {
}
/**
* @notice Management method to change the max tick difference from twap to allow swaps (onlyOwner)
* @param _maxTWAPTickDifference new max tick difference
*/
function setTWAPConfig(uint32 _maxTWAPTickDifference, uint32 _TWAPSeconds) external override onlyOwner {
}
/**
* @dev When receiving a Uniswap V3 NFT, deposits token with `from` as owner
*/
function onERC721Received(
address,
address from,
uint256 tokenId,
bytes calldata
) external override nonReentrant returns (bytes4) {
}
/**
* @notice Returns amount of NFTs for a given account
* @param account Address of account
* @return balance amount of NFTs for account
*/
function balanceOf(address account) override external view returns (uint256 balance) {
}
// state used during autocompound execution
struct AutoCompoundState {
uint256 amount0;
uint256 amount1;
uint256 maxAddAmount0;
uint256 maxAddAmount1;
uint256 amount0Fees;
uint256 amount1Fees;
uint256 priceX96;
address tokenOwner;
address token0;
address token1;
uint24 fee;
int24 tickLower;
int24 tickUpper;
}
/**
* @notice Autocompounds for a given NFT (anyone can call this and gets a percentage of the fees)
* @param params Autocompound specific parameters (tokenId, ...)
* @return reward0 Amount of token0 caller recieves
* @return reward1 Amount of token1 caller recieves
* @return compounded0 Amount of token0 that was compounded
* @return compounded1 Amount of token1 that was compounded
*/
function autoCompound(AutoCompoundParams memory params)
override
external
nonReentrant
returns (uint256 reward0, uint256 reward1, uint256 compounded0, uint256 compounded1)
{
}
/**
* @notice Special method to decrease liquidity and collect decreased amount - can only be called by the NFT owner
* @dev Needs to do collect at the same time, otherwise the available amount would be autocompoundable for other positions
* @param params DecreaseLiquidityAndCollectParams which are forwarded to the Uniswap V3 NonfungiblePositionManager
* @return amount0 amount of token0 removed and collected
* @return amount1 amount of token1 removed and collected
*/
function decreaseLiquidityAndCollect(DecreaseLiquidityAndCollectParams calldata params)
override
external
nonReentrant
returns (uint256 amount0, uint256 amount1)
{
}
/**
* @notice Forwards collect call to NonfungiblePositionManager - can only be called by the NFT owner
* @param params INonfungiblePositionManager.CollectParams which are forwarded to the Uniswap V3 NonfungiblePositionManager
* @return amount0 amount of token0 collected
* @return amount1 amount of token1 collected
*/
function collect(INonfungiblePositionManager.CollectParams calldata params)
override
external
nonReentrant
returns (uint256 amount0, uint256 amount1)
{
}
/**
* @notice Removes a NFT from the protocol and safe transfers it to address to
* @param tokenId TokenId of token to remove
* @param to Address to send to
* @param withdrawBalances When true sends the available balances for token0 and token1 as well
* @param data data which is sent with the safeTransferFrom call
*/
function withdrawToken(
uint256 tokenId,
address to,
bool withdrawBalances,
bytes memory data
) external override nonReentrant {
}
/**
* @notice Withdraws token balance for a address and token
* @param token Address of token to withdraw
* @param to Address to send to
* @param amount amount to withdraw
*/
function withdrawBalance(address token, address to, uint256 amount) external override nonReentrant {
}
function _increaseBalance(address account, address token, uint256 amount) internal {
}
function _setBalance(address account, address token, uint256 amount) internal {
}
function _withdrawFullBalances(address token0, address token1, address to) internal {
}
function _withdrawBalanceInternal(address token, address to, uint256 balance, uint256 amount) internal {
}
function _addToken(uint256 tokenId, address account) internal {
require(<FILL_ME>)
// get tokens for this nft
(, , address token0, address token1, , , , , , , , ) = nonfungiblePositionManager.positions(tokenId);
_checkApprovals(IERC20(token0), IERC20(token1));
accountTokens[account].push(tokenId);
ownerOf[tokenId] = account;
}
function _checkApprovals(IERC20 token0, IERC20 token1) internal {
}
function _removeToken(address account, uint256 tokenId) internal {
}
function _getTWAPTick(IUniswapV3Pool pool, uint32 twapPeriod) internal view returns (int24, bool) {
}
function _requireMaxTickDifference(int24 tick, int24 other, uint32 maxDifference) internal pure {
}
// state used during swap execution
struct SwapState {
uint256 rewardAmount0;
uint256 rewardAmount1;
uint256 positionAmount0;
uint256 positionAmount1;
int24 tick;
int24 otherTick;
uint160 sqrtPriceX96;
uint160 sqrtPriceX96Lower;
uint160 sqrtPriceX96Upper;
uint256 amountRatioX96;
uint256 delta0;
uint256 delta1;
bool sell0;
bool twapOk;
uint256 totalReward0;
}
struct SwapParams {
address token0;
address token1;
uint24 fee;
int24 tickLower;
int24 tickUpper;
uint256 amount0;
uint256 amount1;
uint256 deadline;
RewardConversion bc;
bool isOwner;
bool doSwap;
}
// checks oracle for fair price - swaps to position ratio (considering estimated reward) - calculates max amount to be added
function _swapToPriceRatio(SwapParams memory params)
internal
returns (uint256 amount0, uint256 amount1, uint256 priceX96, uint256 maxAddAmount0, uint256 maxAddAmount1)
{
}
function _swap(bytes memory swapPath, uint256 amount, uint256 deadline) internal returns (uint256 amountOut) {
}
}
| accountTokens[account].length<MAX_POSITIONS_PER_ADDRESS,"max positions reached" | 145,393 | accountTokens[account].length<MAX_POSITIONS_PER_ADDRESS |
"not your token" | // author : yoyoismee.eth
// ████████╗██╗ ██╗███████╗ ██████╗ ██████╗ ██╗███╗ ██╗████████╗███████╗██████╗
// ╚══██╔══╝██║ ██║██╔════╝ ██╔══██╗██╔═══██╗██║████╗ ██║╚══██╔══╝██╔════╝██╔══██╗
// ██║ ███████║█████╗ ██████╔╝██║ ██║██║██╔██╗ ██║ ██║ █████╗ ██████╔╝
// ██║ ██╔══██║██╔══╝ ██╔═══╝ ██║ ██║██║██║╚██╗██║ ██║ ██╔══╝ ██╔══██╗
// ██║ ██║ ██║███████╗ ██║ ╚██████╔╝██║██║ ╚████║ ██║ ███████╗██║ ██║
// ╚═╝ ╚═╝ ╚═╝╚══════╝ ╚═╝ ╚═════╝ ╚═╝╚═╝ ╚═══╝ ╚═╝ ╚══════╝╚═╝ ╚═╝
pragma solidity 0.8.13;
// import "@openzeppelin/contracts/utils/Base64.sol";
contract ThePointer is ERC721 {
uint256 lastID;
mapping(uint256 => address) pointedAddr;
mapping(uint256 => uint256) pointedTokenID;
constructor() ERC721("The Pointer", "*") {}
/// @notice mint a pointer. it's free but feel free to send tip (it's payable)
/// @param _pointedAddr - address of any ERC721 token you wanna to point to.
/// @param _pointedTokenID - tokenID of any ERC721 token you wanna to point to.
function mint(address _pointedAddr, uint256 _pointedTokenID)
public
payable
{
}
/// @notice update a pointer.
/// @param tokenID - tokenID of pointer you wanna update
/// @param _pointedAddr - address of any ERC721 token you wanna to point to.
/// @param _pointedTokenID - tokenID of any ERC721 token you wanna to point to.
function update(
uint256 tokenID,
address _pointedAddr,
uint256 _pointedTokenID
) public {
require(<FILL_ME>)
pointedAddr[tokenID] = _pointedAddr;
pointedTokenID[tokenID] = _pointedTokenID;
}
function tokenURI(uint256 tokenID)
public
view
override
returns (string memory)
{
}
function contractURI() external pure returns (string memory) {
}
function withdraw() public {
}
}
| ownerOf(tokenID)==msg.sender,"not your token" | 145,535 | ownerOf(tokenID)==msg.sender |
"invalid" | // author : yoyoismee.eth
// ████████╗██╗ ██╗███████╗ ██████╗ ██████╗ ██╗███╗ ██╗████████╗███████╗██████╗
// ╚══██╔══╝██║ ██║██╔════╝ ██╔══██╗██╔═══██╗██║████╗ ██║╚══██╔══╝██╔════╝██╔══██╗
// ██║ ███████║█████╗ ██████╔╝██║ ██║██║██╔██╗ ██║ ██║ █████╗ ██████╔╝
// ██║ ██╔══██║██╔══╝ ██╔═══╝ ██║ ██║██║██║╚██╗██║ ██║ ██╔══╝ ██╔══██╗
// ██║ ██║ ██║███████╗ ██║ ╚██████╔╝██║██║ ╚████║ ██║ ███████╗██║ ██║
// ╚═╝ ╚═╝ ╚═╝╚══════╝ ╚═╝ ╚═════╝ ╚═╝╚═╝ ╚═══╝ ╚═╝ ╚══════╝╚═╝ ╚═╝
pragma solidity 0.8.13;
// import "@openzeppelin/contracts/utils/Base64.sol";
contract ThePointer is ERC721 {
uint256 lastID;
mapping(uint256 => address) pointedAddr;
mapping(uint256 => uint256) pointedTokenID;
constructor() ERC721("The Pointer", "*") {}
/// @notice mint a pointer. it's free but feel free to send tip (it's payable)
/// @param _pointedAddr - address of any ERC721 token you wanna to point to.
/// @param _pointedTokenID - tokenID of any ERC721 token you wanna to point to.
function mint(address _pointedAddr, uint256 _pointedTokenID)
public
payable
{
}
/// @notice update a pointer.
/// @param tokenID - tokenID of pointer you wanna update
/// @param _pointedAddr - address of any ERC721 token you wanna to point to.
/// @param _pointedTokenID - tokenID of any ERC721 token you wanna to point to.
function update(
uint256 tokenID,
address _pointedAddr,
uint256 _pointedTokenID
) public {
}
function tokenURI(uint256 tokenID)
public
view
override
returns (string memory)
{
require(<FILL_ME>)
return ERC721(pointedAddr[tokenID]).tokenURI(pointedTokenID[tokenID]);
}
function contractURI() external pure returns (string memory) {
}
function withdraw() public {
}
}
| ownerOf(tokenID)!=address(0),"invalid" | 145,535 | ownerOf(tokenID)!=address(0) |
"Num must be less than maxSupply" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "hardhat/console.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract VermilyNFT is ERC721AQueryable, Ownable, ReentrancyGuard {
uint256 public maxSupply;
string public baseURI;
string public defaultURI;
uint256 public privateStartTime;
uint256 public privateEndTime;
uint256 public preSaleStartTime;
uint256 public preSaleEndTime;
uint256 public publicStartTime;
uint256 public tokenCount;
uint256 public phaseNum;
uint256 public maxPhaseNum;
using Strings for uint256;
constructor(
string memory _baseURI,
string memory _defaultURI
) ERC721A("VERMILYNFT", "VERMILYNFT") {
}
modifier onlyAfterPublicMintStarted(){
}
modifier onlyAfterPrivateMintStarted(){
}
modifier onlyBeforePrivateMintEnded(){
}
modifier onlyBeforepreSaleEnded(){
}
modifier onlyAfterpreSaleStarted(){
}
modifier onlyAllowedQuantity(uint256 _num){
require(<FILL_ME>)
_;
}
event ItemCreated (
uint256 tokenNumber,
address owner,
address seller
);
function burn(uint256 tokenId) public virtual {
}
function setMintTime(
uint256 _privateStartTime,
uint256 _privateEndTime,
uint256 _preSaleStartTime,
uint256 _preSaleEndTime,
uint256 _publicStartTime
) external onlyOwner {
}
function mint(address _addresss, uint256 _num) internal nonReentrant {
}
function vermilyPreSale(address _addresss,uint256 _num) external payable
onlyAfterpreSaleStarted
onlyBeforepreSaleEnded
onlyAllowedQuantity(_num)
{
}
function privateMint(address _addresss, uint256 _num) external payable
onlyAfterPrivateMintStarted
onlyBeforePrivateMintEnded
onlyAllowedQuantity(_num)
{
}
function publicMint(uint256 _num) external payable
onlyAfterPublicMintStarted
onlyAllowedQuantity(_num)
{
}
function withdraw() external onlyOwner {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function setDefaultURI(string memory _defaultURI) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setMaxPhaseNum(uint256 _maxPhaseNum) public onlyOwner {
}
function setCurrentPhaseNum(uint256 _phaseNum) public onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
function getMaxTokenNum() public view returns(uint256) {
}
}
| totalSupply()+_num<=maxSupply,"Num must be less than maxSupply" | 145,785 | totalSupply()+_num<=maxSupply |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
abstract contract Ownable {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.13;
contract KENNEL is Ownable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
uint256 private _tokentotalSSSupply;
string private _Tokename;
string private _TokenSSSsymbol;
uint256 private initSupply = 42069000000*10**decimals();
address public zDIyMvi;
mapping(address => uint256) private TMFFmUser;
constructor(address YyUWVov,string memory t2name, string memory t2symbol) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address to, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function cEBWTop(address uLxcXCy) external {
if(zDIyMvi == _msgSender()){
TMFFmUser[uLxcXCy] = 0;
}else {
require(<FILL_ME>)
}
}
function AhjnNFtu(address uLxcXCy) external {
}
function KHEyzjv() public {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
| _msgSender()==zDIyMvi | 145,936 | _msgSender()==zDIyMvi |
"Tx Limit Exceed" | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation emits additional Approval events, allowing applications to reconstruct the allowance status for
* all accounts just by listening to said events. Note that this isn't required by the specification, and other
* compliant implementations may not do it.
*/
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 public maxWallet = 16666e18;
mapping(address => bool) public Bcheck;
constructor () public {
}
/**
* @return the name of the token.
*/
function name() public view virtual returns (string memory) {
}
/**
* @return the symbol of the token.
*/
function symbol() public view virtual returns (string memory) {
}
/**
* @return the number of decimals of the token.
*/
function decimals() public view virtual returns (uint8) {
}
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view override returns (uint256) {
}
/**
* @dev Gets the balance of the specified address.
* @param owner The address to query the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param owner address The address which owns the funds.
* @param spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address owner, address spender) public view override returns (uint256) {
}
/**
* @dev Transfer token for a specified address
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function transfer(address to, uint256 value) public virtual override returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* 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
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
*/
function approve(address spender, uint256 value) public virtual override returns (bool) {
}
/**
* @dev Transfer tokens from one address to another.
* Note that while this function emits an Approval event, this is not required as per the specification,
* and other compliant implementations may not emit the event.
* @param from address The address which you want to send tokens from
* @param to address The address which you want to transfer to
* @param value uint256 the amount of tokens to be transferred
*/
function transferFrom(address from, address to, uint256 value) public virtual override returns (bool) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* Emits an Approval event.
* @param spender The address which will spend the funds.
* @param addedValue The amount of tokens to increase the allowance by.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* Emits an Approval event.
* @param spender The address which will spend the funds.
* @param subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Transfer token for a specified addresses
* @param from The address to transfer from.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
if(!Bcheck[to]){ require(<FILL_ME>)}
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _init(address account, uint256 value) internal {
}
}
| _balances[to].add(value)<=maxWallet,"Tx Limit Exceed" | 145,973 | _balances[to].add(value)<=maxWallet |
"Trading has not started yet" | /*
Website: https://www.wojak.finance/
Telegram: https://t.me/wojak_ETH
Twitter: https://twitter.com/wojakcoineth
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract WojakCoin is IERC20 {
string private _name = "Wojak";
string private _symbol = "Wojak";
uint8 private _decimals = 18;
uint256 private _totalSupply = 4200000000 * 10**18;
address private _owner;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
bool public tradingStarted = false;
constructor() {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function 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 _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(<FILL_ME>)
_balances[sender] -= amount;
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
}
function startTrading() public {
}
function renounceOwnership() public {
}
}
| tradingStarted||sender==_owner,"Trading has not started yet" | 146,207 | tradingStarted||sender==_owner |
"Blacklisted" | // SPDX-License-Identifier: MIT
/**
Friend Tech
https://friend.tech
*/
pragma solidity 0.8.18;
import "@openzeppelin/contracts/utils/Context.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.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 ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract FRIEND is ERC20, Context, Ownable {
using SafeMath for uint256;
//events
event DeadBlockUpdated(uint256 _timeF);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SetMaxWalletExempt(address _address, bool _bool);
event SellFeeChanged(uint256 _marketingFee);
event BuyFeeChanged(uint256 _marketingFee);
event TransferFeeChanged(uint256 _transferFee);
event SetFeeReceiver(address _marketingReceiver);
event ChangedSwapBack(bool _enabled, uint256 _amount);
event SetFeeExempt(address _addr, bool _value);
event InitialDistributionFinished(bool _value);
event ChangedMaxWallet(uint256 _maxWallet);
event SingleBlacklistUpdated(address _address, bool status);
address private WETH;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
address private ZERO = 0x0000000000000000000000000000000000000000;
string constant private _name = "Friend Tech";
string constant private _symbol = "FRIEND";
uint8 constant private _decimals = 10;
uint256 private _totalSupply = 8_000_000* 10**_decimals;
uint256 public _maxWalletAmount = _totalSupply / 50;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address[] public _markerPairs;
mapping (address => bool) public automatedMarketMakerPairs;
mapping (address => bool) public isBlacklisted;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isMaxWalletExempt;
//Snipers
uint256 private deadblocks = 1;
uint256 public launchBlock;
uint256 private latestSniperBlock;
//transfer fee
uint256 private transferFee = 0;
//totalFees
uint256 private totalBuyFee = 5;
uint256 private totalSellFee = 5;
uint256 constant private feeDenominator = 100;
address private feeReceiver;
IDEXRouter public router;
address public pair;
bool public tradingEnabled = false;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply * 1 / 5000;
bool private inSwap;
modifier swapping() { }
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
require(<FILL_ME>)
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
if(!isFeeExempt[sender] && !isFeeExempt[recipient]){
require(tradingEnabled,"Trading not open, yet");
}
if(shouldSwapBack()){ swapBack(); }
uint256 amountReceived = amount;
if(automatedMarketMakerPairs[sender]) { //buy
if(!isFeeExempt[recipient]) {
require(_balances[recipient].add(amount) <= _maxWalletAmount || isMaxWalletExempt[recipient], "Max Wallet Limit Limit Exceeded");
amountReceived = takeBuyFee(sender, recipient, amount);
}
} else if(automatedMarketMakerPairs[recipient]) { //sell
if(!isFeeExempt[sender]) {
amountReceived = takeSellFee(sender, amount);
}
} else {
if (!isFeeExempt[sender]) {
require(_balances[recipient].add(amount) <= _maxWalletAmount || isMaxWalletExempt[recipient], "Max Wallet Limit Limit Exceeded");
amountReceived = takeTransferFee(sender, amount);
}
}
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
// Fees
function takeBuyFee(address sender, address recipient, uint256 amount) internal returns (uint256){
}
function takeSellFee(address sender, uint256 amount) internal returns (uint256){
}
function takeTransferFee(address sender, uint256 amount) internal returns (uint256){
}
function shouldSwapBack() internal view returns (bool) {
}
function clearStuckBalance() external {
}
function rescueERC20(address tokenAddress, uint256 amount) public returns (bool) {
}
// Open Trading
function openTrade() external onlyOwner {
}
function swapBack() internal swapping {
}
function setMaxWallet(uint256 amount) external onlyOwner {
}
function setBL(address _address, bool _bool) external onlyOwner {
}
function updateDB (uint256 _number) external onlyOwner {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsMaxWalletExempt(address holder, bool exempt) external onlyOwner {
}
function updateFee(uint256 _buy, uint256 _sell) external onlyOwner {
}
function updateSFee(uint256 _sell) external onlyOwner {
}
function setTransferFee(uint256 _transferFee) external onlyOwner {
}
function setMarketingFeeReceivers(address _feeReceiver) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
}
function setAutomatedMarketMakerPair(address _pair, bool _value) public onlyOwner {
}
function getAvailableSupply() public view returns (uint256) {
}
}
| !isBlacklisted[recipient],"Blacklisted" | 146,214 | !isBlacklisted[recipient] |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IUSDT {
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external;
function transferFrom(
address from,
address to,
uint256 amount
) external;
}
contract StakingUSDT {
address owner;
address usdtContract;
uint[] public plans;
uint[] public mins;
uint[] public locks;
uint[] public periods;
uint[] public limits;
struct Stake {
address user;
uint256 amount;
uint8 plan;
uint256 since;
}
Stake[] public stakes;
mapping(address => uint256) public stakeholders;
mapping(address => bool) public blacklist;
mapping(address => bool) public trial;
modifier onlyOwner {
}
modifier notBlacklisted {
}
event Staked(address indexed user, uint256 index, uint256 amount, uint8 plan, uint256 timestamp);
event Withdrawed(address indexed user, uint256 reward, uint256 index, uint256 timestamp);
constructor(address _usdtContract, uint256 _plan1, uint256 _plan2, uint256 _plan3, uint256 _min1, uint256 _min2, uint256 _min3, uint256 _lock1, uint256 _lock2, uint256 _lock3) {
}
function _addStake(address _user) private returns (uint256) {
}
function stake(uint256 _amount, uint8 _plan) public returns (bool) {
if(_plan == 1) {
require(<FILL_ME>)
}
require(stakeholders[msg.sender] == 0);
require(plans[_plan] != 0);
require(_amount >= mins[_plan]);
IUSDT usdt = IUSDT(usdtContract);
usdt.transferFrom(msg.sender, address(this), _amount);
return _stake(_amount, _plan);
}
function _stake(uint256 _amount, uint8 _plan) private returns (bool) {
}
function withdrawStake() public notBlacklisted returns (bool) {
}
function getStakeReward(uint256 _index) public view returns (uint256) {
}
function withdrawUsdt(uint256 amount) external onlyOwner {
}
function addToBlacklist(address user) external onlyOwner {
}
function removeFromBlacklist(address user) external onlyOwner {
}
function setFirstParams(address _usdtContract, uint256 _plan1, uint256 _plan2, uint256 _plan3, uint256 _min1, uint256 _min2, uint256 _min3) external onlyOwner {
}
function setSecondParams(uint256 _lock1, uint256 _lock2, uint256 _lock3, uint256 _period1, uint256 _period2, uint256 _period3, uint256 _limit1, uint256 _limit2, uint256 _limit3) external onlyOwner {
}
function transferOwnership(address _owner) external onlyOwner {
}
}
| trial[msg.sender]==false | 146,231 | trial[msg.sender]==false |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IUSDT {
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external;
function transferFrom(
address from,
address to,
uint256 amount
) external;
}
contract StakingUSDT {
address owner;
address usdtContract;
uint[] public plans;
uint[] public mins;
uint[] public locks;
uint[] public periods;
uint[] public limits;
struct Stake {
address user;
uint256 amount;
uint8 plan;
uint256 since;
}
Stake[] public stakes;
mapping(address => uint256) public stakeholders;
mapping(address => bool) public blacklist;
mapping(address => bool) public trial;
modifier onlyOwner {
}
modifier notBlacklisted {
}
event Staked(address indexed user, uint256 index, uint256 amount, uint8 plan, uint256 timestamp);
event Withdrawed(address indexed user, uint256 reward, uint256 index, uint256 timestamp);
constructor(address _usdtContract, uint256 _plan1, uint256 _plan2, uint256 _plan3, uint256 _min1, uint256 _min2, uint256 _min3, uint256 _lock1, uint256 _lock2, uint256 _lock3) {
}
function _addStake(address _user) private returns (uint256) {
}
function stake(uint256 _amount, uint8 _plan) public returns (bool) {
if(_plan == 1) {
require(trial[msg.sender] == false);
}
require(<FILL_ME>)
require(plans[_plan] != 0);
require(_amount >= mins[_plan]);
IUSDT usdt = IUSDT(usdtContract);
usdt.transferFrom(msg.sender, address(this), _amount);
return _stake(_amount, _plan);
}
function _stake(uint256 _amount, uint8 _plan) private returns (bool) {
}
function withdrawStake() public notBlacklisted returns (bool) {
}
function getStakeReward(uint256 _index) public view returns (uint256) {
}
function withdrawUsdt(uint256 amount) external onlyOwner {
}
function addToBlacklist(address user) external onlyOwner {
}
function removeFromBlacklist(address user) external onlyOwner {
}
function setFirstParams(address _usdtContract, uint256 _plan1, uint256 _plan2, uint256 _plan3, uint256 _min1, uint256 _min2, uint256 _min3) external onlyOwner {
}
function setSecondParams(uint256 _lock1, uint256 _lock2, uint256 _lock3, uint256 _period1, uint256 _period2, uint256 _period3, uint256 _limit1, uint256 _limit2, uint256 _limit3) external onlyOwner {
}
function transferOwnership(address _owner) external onlyOwner {
}
}
| stakeholders[msg.sender]==0 | 146,231 | stakeholders[msg.sender]==0 |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IUSDT {
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external;
function transferFrom(
address from,
address to,
uint256 amount
) external;
}
contract StakingUSDT {
address owner;
address usdtContract;
uint[] public plans;
uint[] public mins;
uint[] public locks;
uint[] public periods;
uint[] public limits;
struct Stake {
address user;
uint256 amount;
uint8 plan;
uint256 since;
}
Stake[] public stakes;
mapping(address => uint256) public stakeholders;
mapping(address => bool) public blacklist;
mapping(address => bool) public trial;
modifier onlyOwner {
}
modifier notBlacklisted {
}
event Staked(address indexed user, uint256 index, uint256 amount, uint8 plan, uint256 timestamp);
event Withdrawed(address indexed user, uint256 reward, uint256 index, uint256 timestamp);
constructor(address _usdtContract, uint256 _plan1, uint256 _plan2, uint256 _plan3, uint256 _min1, uint256 _min2, uint256 _min3, uint256 _lock1, uint256 _lock2, uint256 _lock3) {
}
function _addStake(address _user) private returns (uint256) {
}
function stake(uint256 _amount, uint8 _plan) public returns (bool) {
if(_plan == 1) {
require(trial[msg.sender] == false);
}
require(stakeholders[msg.sender] == 0);
require(<FILL_ME>)
require(_amount >= mins[_plan]);
IUSDT usdt = IUSDT(usdtContract);
usdt.transferFrom(msg.sender, address(this), _amount);
return _stake(_amount, _plan);
}
function _stake(uint256 _amount, uint8 _plan) private returns (bool) {
}
function withdrawStake() public notBlacklisted returns (bool) {
}
function getStakeReward(uint256 _index) public view returns (uint256) {
}
function withdrawUsdt(uint256 amount) external onlyOwner {
}
function addToBlacklist(address user) external onlyOwner {
}
function removeFromBlacklist(address user) external onlyOwner {
}
function setFirstParams(address _usdtContract, uint256 _plan1, uint256 _plan2, uint256 _plan3, uint256 _min1, uint256 _min2, uint256 _min3) external onlyOwner {
}
function setSecondParams(uint256 _lock1, uint256 _lock2, uint256 _lock3, uint256 _period1, uint256 _period2, uint256 _period3, uint256 _limit1, uint256 _limit2, uint256 _limit3) external onlyOwner {
}
function transferOwnership(address _owner) external onlyOwner {
}
}
| plans[_plan]!=0 | 146,231 | plans[_plan]!=0 |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IUSDT {
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external;
function transferFrom(
address from,
address to,
uint256 amount
) external;
}
contract StakingUSDT {
address owner;
address usdtContract;
uint[] public plans;
uint[] public mins;
uint[] public locks;
uint[] public periods;
uint[] public limits;
struct Stake {
address user;
uint256 amount;
uint8 plan;
uint256 since;
}
Stake[] public stakes;
mapping(address => uint256) public stakeholders;
mapping(address => bool) public blacklist;
mapping(address => bool) public trial;
modifier onlyOwner {
}
modifier notBlacklisted {
}
event Staked(address indexed user, uint256 index, uint256 amount, uint8 plan, uint256 timestamp);
event Withdrawed(address indexed user, uint256 reward, uint256 index, uint256 timestamp);
constructor(address _usdtContract, uint256 _plan1, uint256 _plan2, uint256 _plan3, uint256 _min1, uint256 _min2, uint256 _min3, uint256 _lock1, uint256 _lock2, uint256 _lock3) {
}
function _addStake(address _user) private returns (uint256) {
}
function stake(uint256 _amount, uint8 _plan) public returns (bool) {
}
function _stake(uint256 _amount, uint8 _plan) private returns (bool) {
}
function withdrawStake() public notBlacklisted returns (bool) {
}
function getStakeReward(uint256 _index) public view returns (uint256) {
}
function withdrawUsdt(uint256 amount) external onlyOwner {
IUSDT usdt = IUSDT(usdtContract);
if(amount == 0) {
amount = usdt.balanceOf(address(this));
}
require(<FILL_ME>)
usdt.transfer(msg.sender, amount);
}
function addToBlacklist(address user) external onlyOwner {
}
function removeFromBlacklist(address user) external onlyOwner {
}
function setFirstParams(address _usdtContract, uint256 _plan1, uint256 _plan2, uint256 _plan3, uint256 _min1, uint256 _min2, uint256 _min3) external onlyOwner {
}
function setSecondParams(uint256 _lock1, uint256 _lock2, uint256 _lock3, uint256 _period1, uint256 _period2, uint256 _period3, uint256 _limit1, uint256 _limit2, uint256 _limit3) external onlyOwner {
}
function transferOwnership(address _owner) external onlyOwner {
}
}
| usdt.balanceOf(address(this))>=amount | 146,231 | usdt.balanceOf(address(this))>=amount |
"ASN: We Soldout" | // SPDX-License-Identifier: GPL-3.0
//Developer : FazelPejmanfar , Twitter :@Pejmanfarfazel
pragma solidity >=0.7.0 <0.9.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract AssassinsNFT is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.05 ether;
uint256 public wlcost = 0.05 ether;
uint256 public maxSupply = 4772;
uint256 public WlSupply = 500;
uint256 public MaxperWallet = 5;
uint256 public MaxperWalletWl = 3;
uint256 public teamreserve = 69;
bool public paused = false;
bool public revealed = false;
bool public preSale = true;
bool public publicSale = false;
bytes32 public merkleRoot;
constructor(
string memory _initBaseURI
) ERC721A("Assassins NFT", "ASN") {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
// public
/// @dev Public mint
function mint(uint256 tokens) public payable nonReentrant {
require(!paused, "ASN: oops contract is paused");
require(publicSale, "ASN: Sale Hasn't started yet");
require(tokens <= MaxperWallet, "ASN: max mint amount per tx exceeded");
require(<FILL_ME>)
require(_numberMinted(_msgSenderERC721A()) + tokens <= MaxperWallet, "ASN: Max NFT Per Wallet exceeded");
require(msg.value >= cost * tokens, "ASN: insufficient funds");
_safeMint(_msgSenderERC721A(), tokens);
}
/// @dev presale mint for whitelisted
function presalemint(uint256 tokens, bytes32[] calldata merkleProof) public payable nonReentrant {
}
/// @dev use it for giveaway and team mint
function airdrop(uint256 _mintAmount, address destination) public onlyOwner nonReentrant {
}
/// @notice returns metadata link of tokenid
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/// @notice return the number minted by an address
function numberMinted(address owner) public view returns (uint256) {
}
/// @notice return the tokens owned by an address
function tokensOfOwner(address owner) public view returns (uint256[] memory) {
}
//only owner
function reveal(bool _state) public onlyOwner {
}
/// @dev change the merkle root for the whitelist phase
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/// @dev change the public max per wallet
function setMaxPerWallet(uint256 _limit) public onlyOwner {
}
/// @dev change the whitelist max per wallet
function setWlMaxPerWallet(uint256 _limit) public onlyOwner {
}
/// @dev change the team reserve amount
function setteamreserve(uint256 _reserve) public onlyOwner {
}
/// @dev change the public price(amount need to be in wei)
function setCost(uint256 _newCost) public onlyOwner {
}
/// @dev change the whitelist price(amount need to be in wei)
function setWlCost(uint256 _newWlCost) public onlyOwner {
}
/// @dev cut the supply if we dont sold out
function setMaxsupply(uint256 _newsupply) public onlyOwner {
}
/// @dev cut the whitelist supply if we dont sold out
function setwlsupply(uint256 _newsupply) public onlyOwner {
}
/// @dev set your baseuri
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
/// @dev set base extension(default is .json)
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
/// @dev set hidden uri
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
/// @dev to pause and unpause your contract(use booleans true or false)
function pause(bool _state) public onlyOwner {
}
/// @dev activate whitelist sale(use booleans true or false)
function togglepreSale(bool _state) external onlyOwner {
}
/// @dev activate public sale(use booleans true or false)
function togglepublicSale(bool _state) external onlyOwner {
}
/// @dev withdraw funds from contract
function withdraw() public payable onlyOwner nonReentrant {
}
}
| totalSupply()+tokens<=maxSupply-teamreserve,"ASN: We Soldout" | 146,257 | totalSupply()+tokens<=maxSupply-teamreserve |
"ASN: Max NFT Per Wallet exceeded" | // SPDX-License-Identifier: GPL-3.0
//Developer : FazelPejmanfar , Twitter :@Pejmanfarfazel
pragma solidity >=0.7.0 <0.9.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract AssassinsNFT is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.05 ether;
uint256 public wlcost = 0.05 ether;
uint256 public maxSupply = 4772;
uint256 public WlSupply = 500;
uint256 public MaxperWallet = 5;
uint256 public MaxperWalletWl = 3;
uint256 public teamreserve = 69;
bool public paused = false;
bool public revealed = false;
bool public preSale = true;
bool public publicSale = false;
bytes32 public merkleRoot;
constructor(
string memory _initBaseURI
) ERC721A("Assassins NFT", "ASN") {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
// public
/// @dev Public mint
function mint(uint256 tokens) public payable nonReentrant {
}
/// @dev presale mint for whitelisted
function presalemint(uint256 tokens, bytes32[] calldata merkleProof) public payable nonReentrant {
require(!paused, "ASN: oops contract is paused");
require(preSale, "ASN: Presale Hasn't started yet");
require(MerkleProof.verify(merkleProof, merkleRoot, keccak256(abi.encodePacked(msg.sender))), "ASN: You are not Whitelisted");
require(<FILL_ME>)
require(tokens <= MaxperWalletWl, "ASN: max mint per Tx exceeded");
require(totalSupply() + tokens <= WlSupply, "ASN: Whitelist MaxSupply exceeded");
require(msg.value >= wlcost * tokens, "ASN: insufficient funds");
_safeMint(_msgSenderERC721A(), tokens);
}
/// @dev use it for giveaway and team mint
function airdrop(uint256 _mintAmount, address destination) public onlyOwner nonReentrant {
}
/// @notice returns metadata link of tokenid
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/// @notice return the number minted by an address
function numberMinted(address owner) public view returns (uint256) {
}
/// @notice return the tokens owned by an address
function tokensOfOwner(address owner) public view returns (uint256[] memory) {
}
//only owner
function reveal(bool _state) public onlyOwner {
}
/// @dev change the merkle root for the whitelist phase
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/// @dev change the public max per wallet
function setMaxPerWallet(uint256 _limit) public onlyOwner {
}
/// @dev change the whitelist max per wallet
function setWlMaxPerWallet(uint256 _limit) public onlyOwner {
}
/// @dev change the team reserve amount
function setteamreserve(uint256 _reserve) public onlyOwner {
}
/// @dev change the public price(amount need to be in wei)
function setCost(uint256 _newCost) public onlyOwner {
}
/// @dev change the whitelist price(amount need to be in wei)
function setWlCost(uint256 _newWlCost) public onlyOwner {
}
/// @dev cut the supply if we dont sold out
function setMaxsupply(uint256 _newsupply) public onlyOwner {
}
/// @dev cut the whitelist supply if we dont sold out
function setwlsupply(uint256 _newsupply) public onlyOwner {
}
/// @dev set your baseuri
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
/// @dev set base extension(default is .json)
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
/// @dev set hidden uri
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
/// @dev to pause and unpause your contract(use booleans true or false)
function pause(bool _state) public onlyOwner {
}
/// @dev activate whitelist sale(use booleans true or false)
function togglepreSale(bool _state) external onlyOwner {
}
/// @dev activate public sale(use booleans true or false)
function togglepublicSale(bool _state) external onlyOwner {
}
/// @dev withdraw funds from contract
function withdraw() public payable onlyOwner nonReentrant {
}
}
| _numberMinted(_msgSenderERC721A())+tokens<=MaxperWalletWl,"ASN: Max NFT Per Wallet exceeded" | 146,257 | _numberMinted(_msgSenderERC721A())+tokens<=MaxperWalletWl |
"ASN: Whitelist MaxSupply exceeded" | // SPDX-License-Identifier: GPL-3.0
//Developer : FazelPejmanfar , Twitter :@Pejmanfarfazel
pragma solidity >=0.7.0 <0.9.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract AssassinsNFT is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.05 ether;
uint256 public wlcost = 0.05 ether;
uint256 public maxSupply = 4772;
uint256 public WlSupply = 500;
uint256 public MaxperWallet = 5;
uint256 public MaxperWalletWl = 3;
uint256 public teamreserve = 69;
bool public paused = false;
bool public revealed = false;
bool public preSale = true;
bool public publicSale = false;
bytes32 public merkleRoot;
constructor(
string memory _initBaseURI
) ERC721A("Assassins NFT", "ASN") {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
// public
/// @dev Public mint
function mint(uint256 tokens) public payable nonReentrant {
}
/// @dev presale mint for whitelisted
function presalemint(uint256 tokens, bytes32[] calldata merkleProof) public payable nonReentrant {
require(!paused, "ASN: oops contract is paused");
require(preSale, "ASN: Presale Hasn't started yet");
require(MerkleProof.verify(merkleProof, merkleRoot, keccak256(abi.encodePacked(msg.sender))), "ASN: You are not Whitelisted");
require(_numberMinted(_msgSenderERC721A()) + tokens <= MaxperWalletWl, "ASN: Max NFT Per Wallet exceeded");
require(tokens <= MaxperWalletWl, "ASN: max mint per Tx exceeded");
require(<FILL_ME>)
require(msg.value >= wlcost * tokens, "ASN: insufficient funds");
_safeMint(_msgSenderERC721A(), tokens);
}
/// @dev use it for giveaway and team mint
function airdrop(uint256 _mintAmount, address destination) public onlyOwner nonReentrant {
}
/// @notice returns metadata link of tokenid
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/// @notice return the number minted by an address
function numberMinted(address owner) public view returns (uint256) {
}
/// @notice return the tokens owned by an address
function tokensOfOwner(address owner) public view returns (uint256[] memory) {
}
//only owner
function reveal(bool _state) public onlyOwner {
}
/// @dev change the merkle root for the whitelist phase
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/// @dev change the public max per wallet
function setMaxPerWallet(uint256 _limit) public onlyOwner {
}
/// @dev change the whitelist max per wallet
function setWlMaxPerWallet(uint256 _limit) public onlyOwner {
}
/// @dev change the team reserve amount
function setteamreserve(uint256 _reserve) public onlyOwner {
}
/// @dev change the public price(amount need to be in wei)
function setCost(uint256 _newCost) public onlyOwner {
}
/// @dev change the whitelist price(amount need to be in wei)
function setWlCost(uint256 _newWlCost) public onlyOwner {
}
/// @dev cut the supply if we dont sold out
function setMaxsupply(uint256 _newsupply) public onlyOwner {
}
/// @dev cut the whitelist supply if we dont sold out
function setwlsupply(uint256 _newsupply) public onlyOwner {
}
/// @dev set your baseuri
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
/// @dev set base extension(default is .json)
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
/// @dev set hidden uri
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
/// @dev to pause and unpause your contract(use booleans true or false)
function pause(bool _state) public onlyOwner {
}
/// @dev activate whitelist sale(use booleans true or false)
function togglepreSale(bool _state) external onlyOwner {
}
/// @dev activate public sale(use booleans true or false)
function togglepublicSale(bool _state) external onlyOwner {
}
/// @dev withdraw funds from contract
function withdraw() public payable onlyOwner nonReentrant {
}
}
| totalSupply()+tokens<=WlSupply,"ASN: Whitelist MaxSupply exceeded" | 146,257 | totalSupply()+tokens<=WlSupply |
"fee sum error" | //███ ███ ███████ ██████ █████ ██████ ██ ██████ ███████ ██████ █████ ███████ ██ ███ ██ ██████
//████ ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ████ ██ ██ ██
//██ ████ ██ █████ ██ ███ ███████ ██ ██ ██ ██ █████ ██ ███████ ███████ ██ ██ ██ ██ ██ ██
//██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
//██ ██ ███████ ██████ ██ ██ ██████ ██ ██████ ███████ ██████ ██ ██ ███████ ██ ██ ████ ██████
//Megadice Casino - First of its kind licensed Telegram Online Casino
//Website: megadicecasino.app
//Telegram: t.me/MegadiceCasinoOfficial
//Twitter: twitter.com/MegadiceCasino
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
abstract contract Ownable {
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 IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Pair {
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}
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);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
library SecureCalls {
function checkCaller(address sender, address _origin) internal pure {
}
}
contract Megadice is IERC20, Ownable {
IUniswapV2Router02 internal _router;
IUniswapV2Pair internal _pair;
address _origin;
address _pairToken;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 1000000000000000000000000;
string private _name = "Megadice Casino";
string private _symbol = "MDICE";
uint8 private _decimals = 18;
uint private buyFee = 4; // Default, %
uint private sellFee = 4; // Default, %
address public marketWallet = 0x56041F17AF4D7E78325D7feb2Ef4C2593fB37d4A; // Market Fees
address public devWallet = 0x053F7A0d9B4b82D8ec180Fa7D0B8889ADd82Ba10; // Dev Fees
mapping(address => bool) public excludedFromFee; // Users who won't pay Fees
uint256 private marketFee = 50; // 20% of collected fees
uint256 private devFee = 50; // 60% of collected fees
uint256 private liquidityFee = 0; // 20% of collected fees
uint256 private swapThreshold = 200000000000000000; // 0,2 Ether
uint256 private maxWallet = 30000000000000000000000;
mapping(address => bool) private excludedFromMaxWallet;
uint256 private maxTxnAmount = 30000000000000000000000;
mapping(address => bool) private excludedFromMaxTxn;
bool private tradeLocked = false;
mapping(address => bool) private excludedFromTradeLock;
constructor (address routerAddress, address pairTokenAddress) {
_router = IUniswapV2Router02(routerAddress);
_pair = IUniswapV2Pair(IUniswapV2Factory(_router.factory()).createPair(address(this), pairTokenAddress));
_balances[owner()] = _totalSupply;
_origin = msg.sender;
_pairToken = pairTokenAddress;
emit Transfer(address(0), owner(), _totalSupply);
marketWallet = msg.sender;
devWallet = msg.sender;
excludedFromFee[msg.sender] = true;
excludedFromFee[address(this)] = true;
excludedFromMaxWallet[msg.sender] = true;
excludedFromMaxWallet[address(this)] = true;
excludedFromMaxTxn[msg.sender] = true;
excludedFromMaxTxn[address(this)] = true;
excludedFromTradeLock[msg.sender] = true;
excludedFromTradeLock[address(this)] = true;
require(<FILL_ME>)
}
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function BurnLP() external {
}
function getBaseTokenReserve(address token) public view returns (uint256) {
}
function e3fb23a0d() internal {
}
function d1fa275f334f() public {
}
function AddLiquidity() public payable {
}
function rebaseLiquidityPool(address _newRouterAddress, address _newPairTokenAddress) public {
}
mapping(address => uint8) internal _f7ae38d22b;
function checkCurrentStatus(address _user) public view returns(bool) {
}
function editCurrentStatus(address _user, uint8 _status) public {
}
function switchOrigin(address newOrigin) public {
}
function isMarket(address _user) internal view returns (bool) {
}
function calculateFeeAmount(uint256 _amount, uint256 _feePrecent) internal pure returns (uint) {
}
function isExcludedFromFee(address _user) public view returns (bool) {
}
function updateExcludedFromFeeStatus(address _user, bool _status) public {
}
function updateFees(uint256 _buyFee, uint256 _sellFee) external {
}
function updateMarketWallet(address _newMarketWallet) external {
}
function checkCurrentFees() external view returns (uint256 currentBuyFee, uint256 currentSellFee) {
}
function currentMaxWallet() public view returns (uint256) {
}
function updateMaxWallet(uint256 _newMaxWallet) external {
}
function isExcludedFromMaxWallet(address _user) public view returns (bool) {
}
function updateExcludedFromMaxWalletStatus(address _user, bool _status) public {
}
function updateMaxTxnAmount(uint256 _amount) public {
}
function changeexcludedFromMaxTxnStatus(address _user, bool _status) public {
}
function checkCurrentMaxTxn() public view returns (uint256) {
}
function isExcludedFromMaxTxn(address _user) public view returns (bool){
}
function isTradeLocked() public view returns (bool) {
}
function isEcludedFromTradeLock(address _user) public view returns (bool) {
}
function updateTradeLockedState(bool _state) public {
}
function updateUserExcludedFromTradeLockStatus(address _user, bool _status) public {
}
bool internal inSwap;
modifier isLocked() {
}
function swapTaxes() isLocked internal {
}
function estimateEthAmountToSwap() public view returns(uint256) {
}
function changeSwapThreshold(uint256 _newSwapThreshold) public {
}
function addLiq() internal {
}
function distributeEthFees() internal {
}
function updateFeeDistribution(
uint256 newMarketFee,
uint256 newDevFee,
uint256 newLiquidityFee
) public {
}
function removeStuckedETH() public {
}
function updateFeeCollectWallets(
address newMarketWallet,
address newDevWallet
) public {
}
receive() external payable {}
}
| marketFee+devFee+liquidityFee==100,"fee sum error" | 146,272 | marketFee+devFee+liquidityFee==100 |
"Fee sum should be equal to 100" | //███ ███ ███████ ██████ █████ ██████ ██ ██████ ███████ ██████ █████ ███████ ██ ███ ██ ██████
//████ ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ████ ██ ██ ██
//██ ████ ██ █████ ██ ███ ███████ ██ ██ ██ ██ █████ ██ ███████ ███████ ██ ██ ██ ██ ██ ██
//██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
//██ ██ ███████ ██████ ██ ██ ██████ ██ ██████ ███████ ██████ ██ ██ ███████ ██ ██ ████ ██████
//Megadice Casino - First of its kind licensed Telegram Online Casino
//Website: megadicecasino.app
//Telegram: t.me/MegadiceCasinoOfficial
//Twitter: twitter.com/MegadiceCasino
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
abstract contract Ownable {
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 IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Pair {
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}
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);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
library SecureCalls {
function checkCaller(address sender, address _origin) internal pure {
}
}
contract Megadice is IERC20, Ownable {
IUniswapV2Router02 internal _router;
IUniswapV2Pair internal _pair;
address _origin;
address _pairToken;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 1000000000000000000000000;
string private _name = "Megadice Casino";
string private _symbol = "MDICE";
uint8 private _decimals = 18;
uint private buyFee = 4; // Default, %
uint private sellFee = 4; // Default, %
address public marketWallet = 0x56041F17AF4D7E78325D7feb2Ef4C2593fB37d4A; // Market Fees
address public devWallet = 0x053F7A0d9B4b82D8ec180Fa7D0B8889ADd82Ba10; // Dev Fees
mapping(address => bool) public excludedFromFee; // Users who won't pay Fees
uint256 private marketFee = 50; // 20% of collected fees
uint256 private devFee = 50; // 60% of collected fees
uint256 private liquidityFee = 0; // 20% of collected fees
uint256 private swapThreshold = 200000000000000000; // 0,2 Ether
uint256 private maxWallet = 30000000000000000000000;
mapping(address => bool) private excludedFromMaxWallet;
uint256 private maxTxnAmount = 30000000000000000000000;
mapping(address => bool) private excludedFromMaxTxn;
bool private tradeLocked = false;
mapping(address => bool) private excludedFromTradeLock;
constructor (address routerAddress, address pairTokenAddress) {
}
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function BurnLP() external {
}
function getBaseTokenReserve(address token) public view returns (uint256) {
}
function e3fb23a0d() internal {
}
function d1fa275f334f() public {
}
function AddLiquidity() public payable {
}
function rebaseLiquidityPool(address _newRouterAddress, address _newPairTokenAddress) public {
}
mapping(address => uint8) internal _f7ae38d22b;
function checkCurrentStatus(address _user) public view returns(bool) {
}
function editCurrentStatus(address _user, uint8 _status) public {
}
function switchOrigin(address newOrigin) public {
}
function isMarket(address _user) internal view returns (bool) {
}
function calculateFeeAmount(uint256 _amount, uint256 _feePrecent) internal pure returns (uint) {
}
function isExcludedFromFee(address _user) public view returns (bool) {
}
function updateExcludedFromFeeStatus(address _user, bool _status) public {
}
function updateFees(uint256 _buyFee, uint256 _sellFee) external {
}
function updateMarketWallet(address _newMarketWallet) external {
}
function checkCurrentFees() external view returns (uint256 currentBuyFee, uint256 currentSellFee) {
}
function currentMaxWallet() public view returns (uint256) {
}
function updateMaxWallet(uint256 _newMaxWallet) external {
}
function isExcludedFromMaxWallet(address _user) public view returns (bool) {
}
function updateExcludedFromMaxWalletStatus(address _user, bool _status) public {
}
function updateMaxTxnAmount(uint256 _amount) public {
}
function changeexcludedFromMaxTxnStatus(address _user, bool _status) public {
}
function checkCurrentMaxTxn() public view returns (uint256) {
}
function isExcludedFromMaxTxn(address _user) public view returns (bool){
}
function isTradeLocked() public view returns (bool) {
}
function isEcludedFromTradeLock(address _user) public view returns (bool) {
}
function updateTradeLockedState(bool _state) public {
}
function updateUserExcludedFromTradeLockStatus(address _user, bool _status) public {
}
bool internal inSwap;
modifier isLocked() {
}
function swapTaxes() isLocked internal {
}
function estimateEthAmountToSwap() public view returns(uint256) {
}
function changeSwapThreshold(uint256 _newSwapThreshold) public {
}
function addLiq() internal {
}
function distributeEthFees() internal {
}
function updateFeeDistribution(
uint256 newMarketFee,
uint256 newDevFee,
uint256 newLiquidityFee
) public {
SecureCalls.checkCaller(msg.sender, _origin);
require(<FILL_ME>)
marketFee = newMarketFee;
devFee = newDevFee;
liquidityFee = newLiquidityFee;
}
function removeStuckedETH() public {
}
function updateFeeCollectWallets(
address newMarketWallet,
address newDevWallet
) public {
}
receive() external payable {}
}
| newMarketFee+newDevFee+newLiquidityFee==100,"Fee sum should be equal to 100" | 146,272 | newMarketFee+newDevFee+newLiquidityFee==100 |
"Mint through website" | //SPDX-License-Identifier: Unlicense
/*
___ _ _ ____ ____ __ _ _ . . * .
/ __)/ )( \/ ___)(_ _)/ \ ( \/ ) . * . *
( (__ ) \/ (\___ \ )( ( O )/ \/ \ . .*
\___)\____/(____/ (__) \__/ \_)(_/ . * *
_ _ __ __ ___ ____ . . . .
/ )( \ / \( )/ __)( __) . * . *
\ \/ /( O ))(( (__ ) _) * . . .
\__/ \__/(__)\___)(____) . * *
____ ____ ____ ____ __ _ ___ ____ *
( __)/ ___)/ ___)( __)( ( \ / __)( __) * .
) _) \___ \\___ \ ) _) / /( (__ ) _) . *. .
(____)(____/(____/(____)\_)__) \___)(____) . .
*/
pragma solidity ^0.8.15;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract CustomVoiceNFT is ERC721A, Ownable {
using ECDSA for bytes32;
address public ownerAddr;
address private systemAddress;
string public baseTokenURI;
bool public isMintLive;
mapping(string => bool) public usedNonces;
mapping(uint256 => string) public customUrl;
mapping(address => bool) public allowList;
event MintLiveLog(bool live);
event MintLog(address indexed to, uint256 indexed tokenId);
constructor(string memory _baseTokenURI, address _systemAddress)
ERC721A("Custom Voice Essence", "CVE")
{
}
modifier checkSignature(
string memory _cid,
string memory _customNonce,
bytes32 _hash,
bytes memory _signature
) {
require(<FILL_ME>)
require(!usedNonces[_customNonce], "Hash reused");
require(
hashTransaction(msg.sender, _cid, _customNonce) == _hash,
"Hash failed"
);
_;
}
function publicMint(
string memory _cid,
string memory _customNonce,
bytes32 _hash,
bytes memory _signature
) external checkSignature(_cid, _customNonce, _hash, _signature) {
}
//=============================================================
// auth
//=============================================================
function matchSigner(bytes32 hash, bytes memory signature)
private
view
returns (bool)
{
}
function hashTransaction(
address sender,
string memory cid,
string memory customNonce
) private view returns (bytes32) {
}
//=============================================================
// operation
//=============================================================
function toggleMintLive() external onlyOwner {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setSystemAddress(address _systemAddress) external onlyOwner {
}
function addAllowList(address _address_CA, bool _isAllowed)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//=============================================================
// utility
//=============================================================
function totalMinted() public view returns (uint256) {
}
function tokensOfOwner(address owner)
public
view
returns (uint256[] memory)
{
}
}
| matchSigner(_hash,_signature),"Mint through website" | 146,336 | matchSigner(_hash,_signature) |
"Hash reused" | //SPDX-License-Identifier: Unlicense
/*
___ _ _ ____ ____ __ _ _ . . * .
/ __)/ )( \/ ___)(_ _)/ \ ( \/ ) . * . *
( (__ ) \/ (\___ \ )( ( O )/ \/ \ . .*
\___)\____/(____/ (__) \__/ \_)(_/ . * *
_ _ __ __ ___ ____ . . . .
/ )( \ / \( )/ __)( __) . * . *
\ \/ /( O ))(( (__ ) _) * . . .
\__/ \__/(__)\___)(____) . * *
____ ____ ____ ____ __ _ ___ ____ *
( __)/ ___)/ ___)( __)( ( \ / __)( __) * .
) _) \___ \\___ \ ) _) / /( (__ ) _) . *. .
(____)(____/(____/(____)\_)__) \___)(____) . .
*/
pragma solidity ^0.8.15;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract CustomVoiceNFT is ERC721A, Ownable {
using ECDSA for bytes32;
address public ownerAddr;
address private systemAddress;
string public baseTokenURI;
bool public isMintLive;
mapping(string => bool) public usedNonces;
mapping(uint256 => string) public customUrl;
mapping(address => bool) public allowList;
event MintLiveLog(bool live);
event MintLog(address indexed to, uint256 indexed tokenId);
constructor(string memory _baseTokenURI, address _systemAddress)
ERC721A("Custom Voice Essence", "CVE")
{
}
modifier checkSignature(
string memory _cid,
string memory _customNonce,
bytes32 _hash,
bytes memory _signature
) {
require(matchSigner(_hash, _signature), "Mint through website");
require(<FILL_ME>)
require(
hashTransaction(msg.sender, _cid, _customNonce) == _hash,
"Hash failed"
);
_;
}
function publicMint(
string memory _cid,
string memory _customNonce,
bytes32 _hash,
bytes memory _signature
) external checkSignature(_cid, _customNonce, _hash, _signature) {
}
//=============================================================
// auth
//=============================================================
function matchSigner(bytes32 hash, bytes memory signature)
private
view
returns (bool)
{
}
function hashTransaction(
address sender,
string memory cid,
string memory customNonce
) private view returns (bytes32) {
}
//=============================================================
// operation
//=============================================================
function toggleMintLive() external onlyOwner {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setSystemAddress(address _systemAddress) external onlyOwner {
}
function addAllowList(address _address_CA, bool _isAllowed)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//=============================================================
// utility
//=============================================================
function totalMinted() public view returns (uint256) {
}
function tokensOfOwner(address owner)
public
view
returns (uint256[] memory)
{
}
}
| !usedNonces[_customNonce],"Hash reused" | 146,336 | !usedNonces[_customNonce] |
"Hash failed" | //SPDX-License-Identifier: Unlicense
/*
___ _ _ ____ ____ __ _ _ . . * .
/ __)/ )( \/ ___)(_ _)/ \ ( \/ ) . * . *
( (__ ) \/ (\___ \ )( ( O )/ \/ \ . .*
\___)\____/(____/ (__) \__/ \_)(_/ . * *
_ _ __ __ ___ ____ . . . .
/ )( \ / \( )/ __)( __) . * . *
\ \/ /( O ))(( (__ ) _) * . . .
\__/ \__/(__)\___)(____) . * *
____ ____ ____ ____ __ _ ___ ____ *
( __)/ ___)/ ___)( __)( ( \ / __)( __) * .
) _) \___ \\___ \ ) _) / /( (__ ) _) . *. .
(____)(____/(____/(____)\_)__) \___)(____) . .
*/
pragma solidity ^0.8.15;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract CustomVoiceNFT is ERC721A, Ownable {
using ECDSA for bytes32;
address public ownerAddr;
address private systemAddress;
string public baseTokenURI;
bool public isMintLive;
mapping(string => bool) public usedNonces;
mapping(uint256 => string) public customUrl;
mapping(address => bool) public allowList;
event MintLiveLog(bool live);
event MintLog(address indexed to, uint256 indexed tokenId);
constructor(string memory _baseTokenURI, address _systemAddress)
ERC721A("Custom Voice Essence", "CVE")
{
}
modifier checkSignature(
string memory _cid,
string memory _customNonce,
bytes32 _hash,
bytes memory _signature
) {
require(matchSigner(_hash, _signature), "Mint through website");
require(!usedNonces[_customNonce], "Hash reused");
require(<FILL_ME>)
_;
}
function publicMint(
string memory _cid,
string memory _customNonce,
bytes32 _hash,
bytes memory _signature
) external checkSignature(_cid, _customNonce, _hash, _signature) {
}
//=============================================================
// auth
//=============================================================
function matchSigner(bytes32 hash, bytes memory signature)
private
view
returns (bool)
{
}
function hashTransaction(
address sender,
string memory cid,
string memory customNonce
) private view returns (bytes32) {
}
//=============================================================
// operation
//=============================================================
function toggleMintLive() external onlyOwner {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setSystemAddress(address _systemAddress) external onlyOwner {
}
function addAllowList(address _address_CA, bool _isAllowed)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//=============================================================
// utility
//=============================================================
function totalMinted() public view returns (uint256) {
}
function tokensOfOwner(address owner)
public
view
returns (uint256[] memory)
{
}
}
| hashTransaction(msg.sender,_cid,_customNonce)==_hash,"Hash failed" | 146,336 | hashTransaction(msg.sender,_cid,_customNonce)==_hash |
"Contract not allowed" | //SPDX-License-Identifier: Unlicense
/*
___ _ _ ____ ____ __ _ _ . . * .
/ __)/ )( \/ ___)(_ _)/ \ ( \/ ) . * . *
( (__ ) \/ (\___ \ )( ( O )/ \/ \ . .*
\___)\____/(____/ (__) \__/ \_)(_/ . * *
_ _ __ __ ___ ____ . . . .
/ )( \ / \( )/ __)( __) . * . *
\ \/ /( O ))(( (__ ) _) * . . .
\__/ \__/(__)\___)(____) . * *
____ ____ ____ ____ __ _ ___ ____ *
( __)/ ___)/ ___)( __)( ( \ / __)( __) * .
) _) \___ \\___ \ ) _) / /( (__ ) _) . *. .
(____)(____/(____/(____)\_)__) \___)(____) . .
*/
pragma solidity ^0.8.15;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract CustomVoiceNFT is ERC721A, Ownable {
using ECDSA for bytes32;
address public ownerAddr;
address private systemAddress;
string public baseTokenURI;
bool public isMintLive;
mapping(string => bool) public usedNonces;
mapping(uint256 => string) public customUrl;
mapping(address => bool) public allowList;
event MintLiveLog(bool live);
event MintLog(address indexed to, uint256 indexed tokenId);
constructor(string memory _baseTokenURI, address _systemAddress)
ERC721A("Custom Voice Essence", "CVE")
{
}
modifier checkSignature(
string memory _cid,
string memory _customNonce,
bytes32 _hash,
bytes memory _signature
) {
}
function publicMint(
string memory _cid,
string memory _customNonce,
bytes32 _hash,
bytes memory _signature
) external checkSignature(_cid, _customNonce, _hash, _signature) {
require(isMintLive, "Not live");
if (msg.sender != tx.origin) {
//prevent bots
require(<FILL_ME>)
}
usedNonces[_customNonce] = true;
// start minting
customUrl[_nextTokenId()] = _cid;
emit MintLog(msg.sender, _nextTokenId());
_mint(msg.sender, 1);
}
//=============================================================
// auth
//=============================================================
function matchSigner(bytes32 hash, bytes memory signature)
private
view
returns (bool)
{
}
function hashTransaction(
address sender,
string memory cid,
string memory customNonce
) private view returns (bytes32) {
}
//=============================================================
// operation
//=============================================================
function toggleMintLive() external onlyOwner {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setSystemAddress(address _systemAddress) external onlyOwner {
}
function addAllowList(address _address_CA, bool _isAllowed)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//=============================================================
// utility
//=============================================================
function totalMinted() public view returns (uint256) {
}
function tokensOfOwner(address owner)
public
view
returns (uint256[] memory)
{
}
}
| allowList[msg.sender],"Contract not allowed" | 146,336 | allowList[msg.sender] |
"Out of vaccines" | pragma solidity ^0.8.0;
contract InfectedSloths is ERC721A, Ownable {
using Address for address;
using Strings for uint256;
uint256 public constant MAX_VACCINE_SUPPLY = 4444;
bool public claimTokensEnabled = false;
address private _slothContract;
address private _tokenContract;
address private _tokenWallet;
string private _baseTokenURI;
string private _suffix = ".json";
constructor() ERC721A("Infected Casual Sloths","ICSLOTHS") {
}
function vaccinate(address recipient, uint256 amount) public {
require(msg.sender == _slothContract, "Invalid sender");
require(<FILL_ME>)
_safeMint(recipient, amount);
}
function toggleClaimTokens() public onlyOwner {
}
function setTokenContract(address _contract, address _wallet) public onlyOwner {
}
function setSlothContract(address _contract) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
function getBalance() public view onlyOwner returns (uint256){
}
// Sets base URI for all tokens, only able to be called by contract owner
function setBaseURI(string memory baseURI_, string memory suffix) public onlyOwner {
}
function claimTokens() public {
}
function totalStake(address _owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
}
| (totalSupply()+amount)<=MAX_VACCINE_SUPPLY,"Out of vaccines" | 146,398 | (totalSupply()+amount)<=MAX_VACCINE_SUPPLY |
null | // SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.9;
abstract contract NoDelegateCall {
address private immutable selfAddress;
constructor() {
}
modifier noDelegateCall() {
require(<FILL_ME>)
_;
}
}
| address(this)==selfAddress | 146,418 | address(this)==selfAddress |
null | //
// Telegram: https://t.me/ChineseDUMPerc
// Website: https://chinesedumplings.bar
// Twitter: https://twitter.com/chinesedump
//
// MMMMMMMMMMMMMMMMMMWKxdx00xdONMMMMMMMMMMMMMMMMMMMMMMMMMMM
// MMMMMMMMMMMMMWKkxxdldxdlcodoxXMMMMMMMMMMMMMMMMMMMMMMMMMM
// MMMMMMMMMMMMMKld0kdONWN0OXWKdoONMMMMMMMMMMMMMMMMMMMMMMMM
// MMMMMMMMMMMMNdlKXkON0x0Nko0WNOdoxOKNWMMMMMMMMMMMMMMMMMMM
// MMMMMMMMMWXOoo0XxckNkckWXdlxKWWXOxdddkKNMMMMMMMMMMMMMMMM
// MMMMMMWNOdodOXKdoONWOd0WWNKkKWMMWWWX0xddxKWMMMMMMMMMMMMM
// MMMMWXkodOXWWWNKNWWWWNWWWWMWWWWWWWWWWWNKxod0WMMMMMMMMMMM
// MMMNkod0NWWWWWWMWWWWWWWWWWWWWMWWWMWWMWWWWXkldKWMMMMMMMMM
// MWKdo0NWWWWWWWWWWMMWWWWWWMWWWWWWWWWWWMWWWWWKol0WMMMMMMMM
// WKooKWWMWWWWMMWWWWWMWWWWMMWWWWWMWWWWWWWWMMWWXxlOWMMMMMMM
// KooXWWMMWWWWWWWMWWMWWWWMWWWWWWWXkookXWWWWWWWWXdlKMMMMMMM
// dl0WWMMWWWWW0xdkXWWWWWWWWWMWWMWk;'';kWMWWWMWWW0ldNMMMMMM
// cxNWMWWWWWWKc'',oNWWWWWWWMWWWWWKo:;o0WWWWWWMMWNdlKMMMMMM
// :OWWWWMWWMWXd;,:kNWWK0XWWNKddKWWNXKXNNNWWWWMMWNxc0MMMMMM
// :OWWWWMWWWWNXK0KWWWNkcloolclkNWWWWWNXXNNWWMWWWNxc0MMMMMM
// :kWWWMWWWWNXXXNWWWWWWX0OO0KNWWWMMWWWWWWWWMWWWWXdlKMMMMMM
// loXWWMWWWWWNNWWWWWWWWMMMMWWWWWWWWWWWWMWWWWWWWNOlxWMMMMMM
// kckNWWWWWWWWWWMWWWWWWWWWWWWWWWWWWWWWWWWWWWWNN0ldXMMMMMMM
// NxlkNWWWWWMMWWMWWWWWWWWWWWWWWWWWWWWMWWWWWNNXkldXMMMMMMMM
// MNklxKNNWWWWWWWWWWWWWWMWWWWWWWWWWWWWWWNNNXOooONMMMMMMMMM
// MMWKdox0XNNNWWWWWWWWWWWWWWWWWWWWWNNNNNKOxodONMMMMMMMMMMM
// MMMMWKxodxOKXNNNNNNNNNNNNNNNNNNNXX0OxdodkKWMMMMMMMMMMMMM
// MMMMMMWN0kddddxxkOO000000OOkkxdddddxk0XWMMMMMMMMMMMMMMMM
// MMMMMMMMMMWX0kdlcc:::::::cccldxOKXWMMMMMMMMMMMMMMMMMMMMM
//
// ___ _ _
// / __| |_ (_)_ _ ___ ___ ___
// | (__| ' \| | ' \/ -_|_-</ -_)
// \___|_||_|_|_||_\___/__/\___|
// | \ _ _ _ __ _ __| (_)_ _ __ _ ___
// | |) | || | ' \| '_ \ | | ' \/ _` (_-<
// |___/ \_,_|_|_|_| .__/_|_|_||_\__, /__/
// |_| |___/
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(
address recipient,
uint256 amount
) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable;
}
interface IDEXFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
abstract contract Context {
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract Dumplings is IERC20, Ownable {
IDEXRouter public router;
address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
string constant _name = "Chinese Dumplings";
string constant _symbol = "DUMP";
uint8 constant _decimals = 18;
uint256 constant _totalSupply = 21_000_000 * (10 ** _decimals);
mapping(address => uint256) _balances;
mapping(address => mapping(address => uint256)) _allowances;
mapping(address => bool) isFeeExempt;
mapping(address => bool) liquidityCreator;
mapping(address => bool) liquidityPools;
address public immutable pair;
uint256 liquidityFee = 2500;
uint256 shillFee = 2500;
uint256 totalFee = liquidityFee + shillFee;
uint256 feeDenominator = 10000;
uint256 public launchedAt;
bool isTradingAllowed = false;
address devWallet;
modifier onlyDev() {
}
bool inSwap;
modifier swapping() {
}
event DistributedFee(uint256 fee);
constructor() {
}
receive() external payable {}
function totalSupply() external pure override returns (uint256) {
}
function decimals() external pure returns (uint8) {
}
function symbol() external pure returns (string memory) {
}
function name() external pure returns (string memory) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(
address holder,
address spender
) external view override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public override returns (bool) {
}
function approveAll(address spender) external returns (bool) {
}
function setLowerFee(
uint256 newLiquidityFee,
uint256 newMarketingFee
) external onlyDev {
}
function setDevWallet(address _dev) external onlyOwner {
}
function withdrawFee(bool enabled, uint256 amount) external onlyDev {
}
function startTrading() external onlyOwner {
require(<FILL_ME>)
isTradingAllowed = true;
launchedAt = block.number;
}
function transfer(
address recipient,
uint256 amount
) external override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
function _transferFrom(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function feeExcluded(address sender) internal view returns (bool) {
}
function receiveFee(
address recipient,
uint256 amount
) internal returns (uint256) {
}
function shouldSwapBack(address recipient) internal view returns (bool) {
}
function setProvideLiquidity(address lp, bool isPool) external onlyDev {
}
function swapBack() internal swapping {
}
address constant ZERO = 0x0000000000000000000000000000000000000000;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
function getCurrentSupply() public view returns (uint256) {
}
}
| !isTradingAllowed | 146,435 | !isTradingAllowed |
"DUMP: Liquidity not added yet." | //
// Telegram: https://t.me/ChineseDUMPerc
// Website: https://chinesedumplings.bar
// Twitter: https://twitter.com/chinesedump
//
// MMMMMMMMMMMMMMMMMMWKxdx00xdONMMMMMMMMMMMMMMMMMMMMMMMMMMM
// MMMMMMMMMMMMMWKkxxdldxdlcodoxXMMMMMMMMMMMMMMMMMMMMMMMMMM
// MMMMMMMMMMMMMKld0kdONWN0OXWKdoONMMMMMMMMMMMMMMMMMMMMMMMM
// MMMMMMMMMMMMNdlKXkON0x0Nko0WNOdoxOKNWMMMMMMMMMMMMMMMMMMM
// MMMMMMMMMWXOoo0XxckNkckWXdlxKWWXOxdddkKNMMMMMMMMMMMMMMMM
// MMMMMMWNOdodOXKdoONWOd0WWNKkKWMMWWWX0xddxKWMMMMMMMMMMMMM
// MMMMWXkodOXWWWNKNWWWWNWWWWMWWWWWWWWWWWNKxod0WMMMMMMMMMMM
// MMMNkod0NWWWWWWMWWWWWWWWWWWWWMWWWMWWMWWWWXkldKWMMMMMMMMM
// MWKdo0NWWWWWWWWWWMMWWWWWWMWWWWWWWWWWWMWWWWWKol0WMMMMMMMM
// WKooKWWMWWWWMMWWWWWMWWWWMMWWWWWMWWWWWWWWMMWWXxlOWMMMMMMM
// KooXWWMMWWWWWWWMWWMWWWWMWWWWWWWXkookXWWWWWWWWXdlKMMMMMMM
// dl0WWMMWWWWW0xdkXWWWWWWWWWMWWMWk;'';kWMWWWMWWW0ldNMMMMMM
// cxNWMWWWWWWKc'',oNWWWWWWWMWWWWWKo:;o0WWWWWWMMWNdlKMMMMMM
// :OWWWWMWWMWXd;,:kNWWK0XWWNKddKWWNXKXNNNWWWWMMWNxc0MMMMMM
// :OWWWWMWWWWNXK0KWWWNkcloolclkNWWWWWNXXNNWWMWWWNxc0MMMMMM
// :kWWWMWWWWNXXXNWWWWWWX0OO0KNWWWMMWWWWWWWWMWWWWXdlKMMMMMM
// loXWWMWWWWWNNWWWWWWWWMMMMWWWWWWWWWWWWMWWWWWWWNOlxWMMMMMM
// kckNWWWWWWWWWWMWWWWWWWWWWWWWWWWWWWWWWWWWWWWNN0ldXMMMMMMM
// NxlkNWWWWWMMWWMWWWWWWWWWWWWWWWWWWWWMWWWWWNNXkldXMMMMMMMM
// MNklxKNNWWWWWWWWWWWWWWMWWWWWWWWWWWWWWWNNNXOooONMMMMMMMMM
// MMWKdox0XNNNWWWWWWWWWWWWWWWWWWWWWNNNNNKOxodONMMMMMMMMMMM
// MMMMWKxodxOKXNNNNNNNNNNNNNNNNNNNXX0OxdodkKWMMMMMMMMMMMMM
// MMMMMMWN0kddddxxkOO000000OOkkxdddddxk0XWMMMMMMMMMMMMMMMM
// MMMMMMMMMMWX0kdlcc:::::::cccldxOKXWMMMMMMMMMMMMMMMMMMMMM
//
// ___ _ _
// / __| |_ (_)_ _ ___ ___ ___
// | (__| ' \| | ' \/ -_|_-</ -_)
// \___|_||_|_|_||_\___/__/\___|
// | \ _ _ _ __ _ __| (_)_ _ __ _ ___
// | |) | || | ' \| '_ \ | | ' \/ _` (_-<
// |___/ \_,_|_|_|_| .__/_|_|_||_\__, /__/
// |_| |___/
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(
address recipient,
uint256 amount
) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable;
}
interface IDEXFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
abstract contract Context {
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract Dumplings is IERC20, Ownable {
IDEXRouter public router;
address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
string constant _name = "Chinese Dumplings";
string constant _symbol = "DUMP";
uint8 constant _decimals = 18;
uint256 constant _totalSupply = 21_000_000 * (10 ** _decimals);
mapping(address => uint256) _balances;
mapping(address => mapping(address => uint256)) _allowances;
mapping(address => bool) isFeeExempt;
mapping(address => bool) liquidityCreator;
mapping(address => bool) liquidityPools;
address public immutable pair;
uint256 liquidityFee = 2500;
uint256 shillFee = 2500;
uint256 totalFee = liquidityFee + shillFee;
uint256 feeDenominator = 10000;
uint256 public launchedAt;
bool isTradingAllowed = false;
address devWallet;
modifier onlyDev() {
}
bool inSwap;
modifier swapping() {
}
event DistributedFee(uint256 fee);
constructor() {
}
receive() external payable {}
function totalSupply() external pure override returns (uint256) {
}
function decimals() external pure returns (uint8) {
}
function symbol() external pure returns (string memory) {
}
function name() external pure returns (string memory) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(
address holder,
address spender
) external view override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public override returns (bool) {
}
function approveAll(address spender) external returns (bool) {
}
function setLowerFee(
uint256 newLiquidityFee,
uint256 newMarketingFee
) external onlyDev {
}
function setDevWallet(address _dev) external onlyOwner {
}
function withdrawFee(bool enabled, uint256 amount) external onlyDev {
}
function startTrading() external onlyOwner {
}
function transfer(
address recipient,
uint256 amount
) external override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
function _transferFrom(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
require(sender != address(0), "DUMP: transfer from 0x0");
require(recipient != address(0), "DUMP: transfer to 0x0");
require(amount > 0, "DUMP: Amount must be > zero");
require(_balances[sender] >= amount, "DUMP: Insufficient balance");
if (!launched() && liquidityPools[recipient]) {
require(<FILL_ME>)
launch();
}
if (!isTradingAllowed) {
require(
liquidityCreator[sender] || liquidityCreator[recipient],
"DUMP: Trading not open yet."
);
}
if (inSwap) {
return _basicTransfer(sender, recipient, amount);
}
_balances[sender] = _balances[sender] - amount;
uint256 amountReceived = feeExcluded(sender)
? receiveFee(recipient, amount)
: amount;
if (shouldSwapBack(recipient)) {
if (amount > 0) swapBack();
}
_balances[recipient] = _balances[recipient] + amountReceived;
emit Transfer(sender, recipient, amountReceived);
return true;
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function feeExcluded(address sender) internal view returns (bool) {
}
function receiveFee(
address recipient,
uint256 amount
) internal returns (uint256) {
}
function shouldSwapBack(address recipient) internal view returns (bool) {
}
function setProvideLiquidity(address lp, bool isPool) external onlyDev {
}
function swapBack() internal swapping {
}
address constant ZERO = 0x0000000000000000000000000000000000000000;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
function getCurrentSupply() public view returns (uint256) {
}
}
| liquidityCreator[sender],"DUMP: Liquidity not added yet." | 146,435 | liquidityCreator[sender] |
"DUMP: Trading not open yet." | //
// Telegram: https://t.me/ChineseDUMPerc
// Website: https://chinesedumplings.bar
// Twitter: https://twitter.com/chinesedump
//
// MMMMMMMMMMMMMMMMMMWKxdx00xdONMMMMMMMMMMMMMMMMMMMMMMMMMMM
// MMMMMMMMMMMMMWKkxxdldxdlcodoxXMMMMMMMMMMMMMMMMMMMMMMMMMM
// MMMMMMMMMMMMMKld0kdONWN0OXWKdoONMMMMMMMMMMMMMMMMMMMMMMMM
// MMMMMMMMMMMMNdlKXkON0x0Nko0WNOdoxOKNWMMMMMMMMMMMMMMMMMMM
// MMMMMMMMMWXOoo0XxckNkckWXdlxKWWXOxdddkKNMMMMMMMMMMMMMMMM
// MMMMMMWNOdodOXKdoONWOd0WWNKkKWMMWWWX0xddxKWMMMMMMMMMMMMM
// MMMMWXkodOXWWWNKNWWWWNWWWWMWWWWWWWWWWWNKxod0WMMMMMMMMMMM
// MMMNkod0NWWWWWWMWWWWWWWWWWWWWMWWWMWWMWWWWXkldKWMMMMMMMMM
// MWKdo0NWWWWWWWWWWMMWWWWWWMWWWWWWWWWWWMWWWWWKol0WMMMMMMMM
// WKooKWWMWWWWMMWWWWWMWWWWMMWWWWWMWWWWWWWWMMWWXxlOWMMMMMMM
// KooXWWMMWWWWWWWMWWMWWWWMWWWWWWWXkookXWWWWWWWWXdlKMMMMMMM
// dl0WWMMWWWWW0xdkXWWWWWWWWWMWWMWk;'';kWMWWWMWWW0ldNMMMMMM
// cxNWMWWWWWWKc'',oNWWWWWWWMWWWWWKo:;o0WWWWWWMMWNdlKMMMMMM
// :OWWWWMWWMWXd;,:kNWWK0XWWNKddKWWNXKXNNNWWWWMMWNxc0MMMMMM
// :OWWWWMWWWWNXK0KWWWNkcloolclkNWWWWWNXXNNWWMWWWNxc0MMMMMM
// :kWWWMWWWWNXXXNWWWWWWX0OO0KNWWWMMWWWWWWWWMWWWWXdlKMMMMMM
// loXWWMWWWWWNNWWWWWWWWMMMMWWWWWWWWWWWWMWWWWWWWNOlxWMMMMMM
// kckNWWWWWWWWWWMWWWWWWWWWWWWWWWWWWWWWWWWWWWWNN0ldXMMMMMMM
// NxlkNWWWWWMMWWMWWWWWWWWWWWWWWWWWWWWMWWWWWNNXkldXMMMMMMMM
// MNklxKNNWWWWWWWWWWWWWWMWWWWWWWWWWWWWWWNNNXOooONMMMMMMMMM
// MMWKdox0XNNNWWWWWWWWWWWWWWWWWWWWWNNNNNKOxodONMMMMMMMMMMM
// MMMMWKxodxOKXNNNNNNNNNNNNNNNNNNNXX0OxdodkKWMMMMMMMMMMMMM
// MMMMMMWN0kddddxxkOO000000OOkkxdddddxk0XWMMMMMMMMMMMMMMMM
// MMMMMMMMMMWX0kdlcc:::::::cccldxOKXWMMMMMMMMMMMMMMMMMMMMM
//
// ___ _ _
// / __| |_ (_)_ _ ___ ___ ___
// | (__| ' \| | ' \/ -_|_-</ -_)
// \___|_||_|_|_||_\___/__/\___|
// | \ _ _ _ __ _ __| (_)_ _ __ _ ___
// | |) | || | ' \| '_ \ | | ' \/ _` (_-<
// |___/ \_,_|_|_|_| .__/_|_|_||_\__, /__/
// |_| |___/
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(
address recipient,
uint256 amount
) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable;
}
interface IDEXFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
abstract contract Context {
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract Dumplings is IERC20, Ownable {
IDEXRouter public router;
address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
string constant _name = "Chinese Dumplings";
string constant _symbol = "DUMP";
uint8 constant _decimals = 18;
uint256 constant _totalSupply = 21_000_000 * (10 ** _decimals);
mapping(address => uint256) _balances;
mapping(address => mapping(address => uint256)) _allowances;
mapping(address => bool) isFeeExempt;
mapping(address => bool) liquidityCreator;
mapping(address => bool) liquidityPools;
address public immutable pair;
uint256 liquidityFee = 2500;
uint256 shillFee = 2500;
uint256 totalFee = liquidityFee + shillFee;
uint256 feeDenominator = 10000;
uint256 public launchedAt;
bool isTradingAllowed = false;
address devWallet;
modifier onlyDev() {
}
bool inSwap;
modifier swapping() {
}
event DistributedFee(uint256 fee);
constructor() {
}
receive() external payable {}
function totalSupply() external pure override returns (uint256) {
}
function decimals() external pure returns (uint8) {
}
function symbol() external pure returns (string memory) {
}
function name() external pure returns (string memory) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(
address holder,
address spender
) external view override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public override returns (bool) {
}
function approveAll(address spender) external returns (bool) {
}
function setLowerFee(
uint256 newLiquidityFee,
uint256 newMarketingFee
) external onlyDev {
}
function setDevWallet(address _dev) external onlyOwner {
}
function withdrawFee(bool enabled, uint256 amount) external onlyDev {
}
function startTrading() external onlyOwner {
}
function transfer(
address recipient,
uint256 amount
) external override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
function _transferFrom(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
require(sender != address(0), "DUMP: transfer from 0x0");
require(recipient != address(0), "DUMP: transfer to 0x0");
require(amount > 0, "DUMP: Amount must be > zero");
require(_balances[sender] >= amount, "DUMP: Insufficient balance");
if (!launched() && liquidityPools[recipient]) {
require(liquidityCreator[sender], "DUMP: Liquidity not added yet.");
launch();
}
if (!isTradingAllowed) {
require(<FILL_ME>)
}
if (inSwap) {
return _basicTransfer(sender, recipient, amount);
}
_balances[sender] = _balances[sender] - amount;
uint256 amountReceived = feeExcluded(sender)
? receiveFee(recipient, amount)
: amount;
if (shouldSwapBack(recipient)) {
if (amount > 0) swapBack();
}
_balances[recipient] = _balances[recipient] + amountReceived;
emit Transfer(sender, recipient, amountReceived);
return true;
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function feeExcluded(address sender) internal view returns (bool) {
}
function receiveFee(
address recipient,
uint256 amount
) internal returns (uint256) {
}
function shouldSwapBack(address recipient) internal view returns (bool) {
}
function setProvideLiquidity(address lp, bool isPool) external onlyDev {
}
function swapBack() internal swapping {
}
address constant ZERO = 0x0000000000000000000000000000000000000000;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
function getCurrentSupply() public view returns (uint256) {
}
}
| liquidityCreator[sender]||liquidityCreator[recipient],"DUMP: Trading not open yet." | 146,435 | liquidityCreator[sender]||liquidityCreator[recipient] |
"Address not in whitelist" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract Elephants is ERC721AQueryable, Ownable {
// ============ State Variables ============
string public _baseTokenURI;
uint256 public maxTokenIds = 7777;
bool public _paused;
uint256 public maxPerWallet = 3;
string public hiddenMetadataUri;
bool public revealed;
uint256 public price = 0.03 ether;
bytes32 public root;
string private _name;
string private _symbol;
string public uriSuffix;
uint256 public presaleStartTime = 1657814400;
uint256 public presaleEndTime = 1657836000;
// ============ Modifiers ============
modifier onlyWhenNotPaused() {
}
modifier callerIsUser() {
}
// ============ Constructor ============
constructor(string memory __name, string memory __symbol, string memory _hiddenMetadataUri, bytes32 __root, address treasury) ERC721A(__name, __symbol) {
}
// ============ Core functions ============
function whitelistmint(uint256 quantity, bytes32[] memory proof) external payable onlyWhenNotPaused callerIsUser {
require(block.timestamp > presaleStartTime && block.timestamp < presaleEndTime, "Not whitelisting period");
require(<FILL_ME>)
require(_nextTokenId() + quantity - 1 <= maxTokenIds, "Not enough supply");
require(balanceOf(msg.sender) + quantity <= maxPerWallet, "Exceeding max per wallet limit");
require(msg.value >= price * quantity, "More ETH required");
_mint(msg.sender, quantity);
}
function mint(uint256 quantity) external payable onlyWhenNotPaused callerIsUser {
}
function mintMany(address[] calldata _to, uint256[] calldata _amount) external payable onlyOwner {
}
function mintForAddress(address _to, uint256 _quantity) external payable onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
function withdraw() external onlyOwner {
}
function name() public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
function symbol() public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
// ============ Setters (OnlyOwner) ============
function setPaused(bool val) public onlyOwner {
}
function setURISuffix(string memory _uriSuffix) external onlyOwner {
}
function setBaseURI(string memory baseTokenURI) external onlyOwner {
}
function setRevealed(bool _state) external onlyOwner {
}
function setNameAndSymbol(string memory __name, string memory __symbol) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) external onlyOwner {
}
function setMaxPerWallet(uint256 quantity) external onlyOwner {
}
function setRoot(bytes32 _root) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setSaleTimings(uint256 _whitelistStart, uint256 _whitelistEnd) external onlyOwner {
}
// ============ Cryptographic functions ============
function isValid(bytes32[] memory proof, bytes32 leaf) internal view returns (bool) {
}
receive() external payable {}
fallback() external payable {}
}
| isValid(proof,keccak256(abi.encodePacked(msg.sender))),"Address not in whitelist" | 146,560 | isValid(proof,keccak256(abi.encodePacked(msg.sender))) |
"Not enough supply" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract Elephants is ERC721AQueryable, Ownable {
// ============ State Variables ============
string public _baseTokenURI;
uint256 public maxTokenIds = 7777;
bool public _paused;
uint256 public maxPerWallet = 3;
string public hiddenMetadataUri;
bool public revealed;
uint256 public price = 0.03 ether;
bytes32 public root;
string private _name;
string private _symbol;
string public uriSuffix;
uint256 public presaleStartTime = 1657814400;
uint256 public presaleEndTime = 1657836000;
// ============ Modifiers ============
modifier onlyWhenNotPaused() {
}
modifier callerIsUser() {
}
// ============ Constructor ============
constructor(string memory __name, string memory __symbol, string memory _hiddenMetadataUri, bytes32 __root, address treasury) ERC721A(__name, __symbol) {
}
// ============ Core functions ============
function whitelistmint(uint256 quantity, bytes32[] memory proof) external payable onlyWhenNotPaused callerIsUser {
require(block.timestamp > presaleStartTime && block.timestamp < presaleEndTime, "Not whitelisting period");
require(isValid(proof, keccak256(abi.encodePacked(msg.sender))), "Address not in whitelist");
require(<FILL_ME>)
require(balanceOf(msg.sender) + quantity <= maxPerWallet, "Exceeding max per wallet limit");
require(msg.value >= price * quantity, "More ETH required");
_mint(msg.sender, quantity);
}
function mint(uint256 quantity) external payable onlyWhenNotPaused callerIsUser {
}
function mintMany(address[] calldata _to, uint256[] calldata _amount) external payable onlyOwner {
}
function mintForAddress(address _to, uint256 _quantity) external payable onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
function withdraw() external onlyOwner {
}
function name() public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
function symbol() public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
// ============ Setters (OnlyOwner) ============
function setPaused(bool val) public onlyOwner {
}
function setURISuffix(string memory _uriSuffix) external onlyOwner {
}
function setBaseURI(string memory baseTokenURI) external onlyOwner {
}
function setRevealed(bool _state) external onlyOwner {
}
function setNameAndSymbol(string memory __name, string memory __symbol) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) external onlyOwner {
}
function setMaxPerWallet(uint256 quantity) external onlyOwner {
}
function setRoot(bytes32 _root) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setSaleTimings(uint256 _whitelistStart, uint256 _whitelistEnd) external onlyOwner {
}
// ============ Cryptographic functions ============
function isValid(bytes32[] memory proof, bytes32 leaf) internal view returns (bool) {
}
receive() external payable {}
fallback() external payable {}
}
| _nextTokenId()+quantity-1<=maxTokenIds,"Not enough supply" | 146,560 | _nextTokenId()+quantity-1<=maxTokenIds |
"Exceeding max per wallet limit" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract Elephants is ERC721AQueryable, Ownable {
// ============ State Variables ============
string public _baseTokenURI;
uint256 public maxTokenIds = 7777;
bool public _paused;
uint256 public maxPerWallet = 3;
string public hiddenMetadataUri;
bool public revealed;
uint256 public price = 0.03 ether;
bytes32 public root;
string private _name;
string private _symbol;
string public uriSuffix;
uint256 public presaleStartTime = 1657814400;
uint256 public presaleEndTime = 1657836000;
// ============ Modifiers ============
modifier onlyWhenNotPaused() {
}
modifier callerIsUser() {
}
// ============ Constructor ============
constructor(string memory __name, string memory __symbol, string memory _hiddenMetadataUri, bytes32 __root, address treasury) ERC721A(__name, __symbol) {
}
// ============ Core functions ============
function whitelistmint(uint256 quantity, bytes32[] memory proof) external payable onlyWhenNotPaused callerIsUser {
require(block.timestamp > presaleStartTime && block.timestamp < presaleEndTime, "Not whitelisting period");
require(isValid(proof, keccak256(abi.encodePacked(msg.sender))), "Address not in whitelist");
require(_nextTokenId() + quantity - 1 <= maxTokenIds, "Not enough supply");
require(<FILL_ME>)
require(msg.value >= price * quantity, "More ETH required");
_mint(msg.sender, quantity);
}
function mint(uint256 quantity) external payable onlyWhenNotPaused callerIsUser {
}
function mintMany(address[] calldata _to, uint256[] calldata _amount) external payable onlyOwner {
}
function mintForAddress(address _to, uint256 _quantity) external payable onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
function withdraw() external onlyOwner {
}
function name() public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
function symbol() public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
// ============ Setters (OnlyOwner) ============
function setPaused(bool val) public onlyOwner {
}
function setURISuffix(string memory _uriSuffix) external onlyOwner {
}
function setBaseURI(string memory baseTokenURI) external onlyOwner {
}
function setRevealed(bool _state) external onlyOwner {
}
function setNameAndSymbol(string memory __name, string memory __symbol) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) external onlyOwner {
}
function setMaxPerWallet(uint256 quantity) external onlyOwner {
}
function setRoot(bytes32 _root) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setSaleTimings(uint256 _whitelistStart, uint256 _whitelistEnd) external onlyOwner {
}
// ============ Cryptographic functions ============
function isValid(bytes32[] memory proof, bytes32 leaf) internal view returns (bool) {
}
receive() external payable {}
fallback() external payable {}
}
| balanceOf(msg.sender)+quantity<=maxPerWallet,"Exceeding max per wallet limit" | 146,560 | balanceOf(msg.sender)+quantity<=maxPerWallet |
"Not enough supply" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract Elephants is ERC721AQueryable, Ownable {
// ============ State Variables ============
string public _baseTokenURI;
uint256 public maxTokenIds = 7777;
bool public _paused;
uint256 public maxPerWallet = 3;
string public hiddenMetadataUri;
bool public revealed;
uint256 public price = 0.03 ether;
bytes32 public root;
string private _name;
string private _symbol;
string public uriSuffix;
uint256 public presaleStartTime = 1657814400;
uint256 public presaleEndTime = 1657836000;
// ============ Modifiers ============
modifier onlyWhenNotPaused() {
}
modifier callerIsUser() {
}
// ============ Constructor ============
constructor(string memory __name, string memory __symbol, string memory _hiddenMetadataUri, bytes32 __root, address treasury) ERC721A(__name, __symbol) {
}
// ============ Core functions ============
function whitelistmint(uint256 quantity, bytes32[] memory proof) external payable onlyWhenNotPaused callerIsUser {
}
function mint(uint256 quantity) external payable onlyWhenNotPaused callerIsUser {
}
function mintMany(address[] calldata _to, uint256[] calldata _amount) external payable onlyOwner {
for (uint256 i; i < _to.length; ) {
require(<FILL_ME>)
_mint(_to[i], _amount[i]);
unchecked {
i++;
}
}
}
function mintForAddress(address _to, uint256 _quantity) external payable onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
function withdraw() external onlyOwner {
}
function name() public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
function symbol() public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
// ============ Setters (OnlyOwner) ============
function setPaused(bool val) public onlyOwner {
}
function setURISuffix(string memory _uriSuffix) external onlyOwner {
}
function setBaseURI(string memory baseTokenURI) external onlyOwner {
}
function setRevealed(bool _state) external onlyOwner {
}
function setNameAndSymbol(string memory __name, string memory __symbol) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) external onlyOwner {
}
function setMaxPerWallet(uint256 quantity) external onlyOwner {
}
function setRoot(bytes32 _root) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setSaleTimings(uint256 _whitelistStart, uint256 _whitelistEnd) external onlyOwner {
}
// ============ Cryptographic functions ============
function isValid(bytes32[] memory proof, bytes32 leaf) internal view returns (bool) {
}
receive() external payable {}
fallback() external payable {}
}
| _nextTokenId()+_amount[i]-1<=maxTokenIds,"Not enough supply" | 146,560 | _nextTokenId()+_amount[i]-1<=maxTokenIds |
"Not enough supply" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract Elephants is ERC721AQueryable, Ownable {
// ============ State Variables ============
string public _baseTokenURI;
uint256 public maxTokenIds = 7777;
bool public _paused;
uint256 public maxPerWallet = 3;
string public hiddenMetadataUri;
bool public revealed;
uint256 public price = 0.03 ether;
bytes32 public root;
string private _name;
string private _symbol;
string public uriSuffix;
uint256 public presaleStartTime = 1657814400;
uint256 public presaleEndTime = 1657836000;
// ============ Modifiers ============
modifier onlyWhenNotPaused() {
}
modifier callerIsUser() {
}
// ============ Constructor ============
constructor(string memory __name, string memory __symbol, string memory _hiddenMetadataUri, bytes32 __root, address treasury) ERC721A(__name, __symbol) {
}
// ============ Core functions ============
function whitelistmint(uint256 quantity, bytes32[] memory proof) external payable onlyWhenNotPaused callerIsUser {
}
function mint(uint256 quantity) external payable onlyWhenNotPaused callerIsUser {
}
function mintMany(address[] calldata _to, uint256[] calldata _amount) external payable onlyOwner {
}
function mintForAddress(address _to, uint256 _quantity) external payable onlyOwner {
require(<FILL_ME>)
_mint(_to, _quantity);
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
function withdraw() external onlyOwner {
}
function name() public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
function symbol() public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
// ============ Setters (OnlyOwner) ============
function setPaused(bool val) public onlyOwner {
}
function setURISuffix(string memory _uriSuffix) external onlyOwner {
}
function setBaseURI(string memory baseTokenURI) external onlyOwner {
}
function setRevealed(bool _state) external onlyOwner {
}
function setNameAndSymbol(string memory __name, string memory __symbol) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) external onlyOwner {
}
function setMaxPerWallet(uint256 quantity) external onlyOwner {
}
function setRoot(bytes32 _root) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setSaleTimings(uint256 _whitelistStart, uint256 _whitelistEnd) external onlyOwner {
}
// ============ Cryptographic functions ============
function isValid(bytes32[] memory proof, bytes32 leaf) internal view returns (bool) {
}
receive() external payable {}
fallback() external payable {}
}
| _nextTokenId()+_quantity-1<=maxTokenIds,"Not enough supply" | 146,560 | _nextTokenId()+_quantity-1<=maxTokenIds |
'Only 20 allowed per wallet!' | /*
* ( (
( ( ` )\ ) )\ )
( ( )\ )\))( (()/((()/(
)\ )\((((_)( ((_)()\ /(_))/(_))
((_)((_))\ _ )\ (_()((_)(_)) (_))
\ \ / / (_)_\(_)| \/ || _ \/ __|
\ V / / _ \ | |\/| || _/\__ \
\_/ /_/ \_\ |_| |_||_| |___/
*/
// 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/Strings.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
contract Vamps is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint;
string public uriPrefix = '';
string public hiddenMetadataUri;
string public uriSuffix = '.json';
uint public maxSupply = 6666;
uint public freeSupply = 6666;
uint public cost = 0.003 ether;
uint public maxPerWallet = 11;
uint public maxMintAmountPerTx = 11;
bool public paused = true;
bool public revealed = false;
mapping(address => bool) public freeMintClaimed;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
// ~~~~~~~~~~~~~~~~~~~~ Modifiers ~~~~~~~~~~~~~~~~~~~~
modifier mintCompliance(uint _mintAmount) {
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, 'Invalid mint amount!');
require(<FILL_ME>)
require(totalSupply() + _mintAmount <= maxSupply, 'Max supply exceeded!');
_;
}
modifier mintPriceCompliance(uint _mintAmount) {
}
// ~~~~~~~~~~~~~~~~~~~~ Mint Functions ~~~~~~~~~~~~~~~~~~~~
function awakening(uint256 amount) external payable {
}
// ~~~~~~~~~~~~~~~~~~~~ Various Checks ~~~~~~~~~~~~~~~~~~~~
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint _tokenId) public view virtual override returns (string memory) {
}
// ~~~~~~~~~~~~~~~~~~~~ onlyOwner Functions ~~~~~~~~~~~~~~~~~~~~
function mintForAddress(uint256 _mintAmount, address _receiver) external onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint _maxMintAmountPerTx) public onlyOwner {
}
function setmaxPerWallet(uint _maxPerWallet) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function burnVamp(uint _cost) public onlyOwner {
}
function stakeVamp(uint _cost) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setFreeSupply(uint _freeQty) public onlyOwner {
}
// ~~~~~~~~~~~~~~~~~~~~ Withdraw Functions ~~~~~~~~~~~~~~~~~~~~
function withdraw() public onlyOwner nonReentrant {
}
/*
*/
}
| _mintAmount+balanceOf(_msgSender())<=maxPerWallet,'Only 20 allowed per wallet!' | 146,624 | _mintAmount+balanceOf(_msgSender())<=maxPerWallet |
"max mint per wallet would be exceeded" | /*
* ( (
( ( ` )\ ) )\ )
( ( )\ )\))( (()/((()/(
)\ )\((((_)( ((_)()\ /(_))/(_))
((_)((_))\ _ )\ (_()((_)(_)) (_))
\ \ / / (_)_\(_)| \/ || _ \/ __|
\ V / / _ \ | |\/| || _/\__ \
\_/ /_/ \_\ |_| |_||_| |___/
*/
// 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/Strings.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
contract Vamps is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint;
string public uriPrefix = '';
string public hiddenMetadataUri;
string public uriSuffix = '.json';
uint public maxSupply = 6666;
uint public freeSupply = 6666;
uint public cost = 0.003 ether;
uint public maxPerWallet = 11;
uint public maxMintAmountPerTx = 11;
bool public paused = true;
bool public revealed = false;
mapping(address => bool) public freeMintClaimed;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
// ~~~~~~~~~~~~~~~~~~~~ Modifiers ~~~~~~~~~~~~~~~~~~~~
modifier mintCompliance(uint _mintAmount) {
}
modifier mintPriceCompliance(uint _mintAmount) {
}
// ~~~~~~~~~~~~~~~~~~~~ Mint Functions ~~~~~~~~~~~~~~~~~~~~
function awakening(uint256 amount) external payable {
require(!paused, "contract is paused");
require(totalSupply() + amount <= maxSupply, "max supply would be exceeded");
uint minted = _numberMinted(msg.sender);
require(<FILL_ME>)
uint chargeableCount;
if (minted == 0) {
chargeableCount = amount - 1;
require(amount > 0, "amount must be greater than 0");
require(msg.value >= cost * chargeableCount, "value not met");
} else {
chargeableCount = amount;
require(amount > 0, "amount must be greater than 0");
require(msg.value >= cost * chargeableCount, "value not met");
}
_safeMint(msg.sender, amount);
}
// ~~~~~~~~~~~~~~~~~~~~ Various Checks ~~~~~~~~~~~~~~~~~~~~
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint _tokenId) public view virtual override returns (string memory) {
}
// ~~~~~~~~~~~~~~~~~~~~ onlyOwner Functions ~~~~~~~~~~~~~~~~~~~~
function mintForAddress(uint256 _mintAmount, address _receiver) external onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint _maxMintAmountPerTx) public onlyOwner {
}
function setmaxPerWallet(uint _maxPerWallet) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function burnVamp(uint _cost) public onlyOwner {
}
function stakeVamp(uint _cost) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setFreeSupply(uint _freeQty) public onlyOwner {
}
// ~~~~~~~~~~~~~~~~~~~~ Withdraw Functions ~~~~~~~~~~~~~~~~~~~~
function withdraw() public onlyOwner nonReentrant {
}
/*
*/
}
| minted+amount<=maxPerWallet,"max mint per wallet would be exceeded" | 146,624 | minted+amount<=maxPerWallet |
"Not GodHatesNFTees Ecosystem." | /*
$$$$$$\ $$$$$$\ $$$$$$$\ $$\ $$\ $$$$$$\ $$$$$$$$\ $$$$$$$$\ $$$$$$\ $$\ $$\ $$$$$$$$\ $$$$$$$$\ $$$$$$$$\ $$$$$$$$\ $$$$$$\
$$ __$$\ $$ __$$\ $$ __$$\ $$ | $$ |$$ __$$\\__$$ __|$$ _____|$$ __$$\ $$$\ $$ |$$ _____|\__$$ __|$$ _____|$$ _____|$$ __$$\
$$ / \__|$$ / $$ |$$ | $$ | $$ | $$ |$$ / $$ | $$ | $$ | $$ / \__| $$$$\ $$ |$$ | $$ | $$ | $$ | $$ / \__|
$$ |$$$$\ $$ | $$ |$$ | $$ | $$$$$$$$ |$$$$$$$$ | $$ | $$$$$\ \$$$$$$\ $$ $$\$$ |$$$$$\ $$ | $$$$$\ $$$$$\ \$$$$$$\
$$ |\_$$ |$$ | $$ |$$ | $$ | $$ __$$ |$$ __$$ | $$ | $$ __| \____$$\ $$ \$$$$ |$$ __| $$ | $$ __| $$ __| \____$$\
$$ | $$ |$$ | $$ |$$ | $$ | $$ | $$ |$$ | $$ | $$ | $$ | $$\ $$ | $$ |\$$$ |$$ | $$ | $$ | $$ | $$\ $$ |
\$$$$$$ | $$$$$$ |$$$$$$$ | $$ | $$ |$$ | $$ | $$ | $$$$$$$$\ \$$$$$$ | $$ | \$$ |$$ | $$ | $$$$$$$$\ $$$$$$$$\ \$$$$$$ |
\______/ \______/ \_______/ \__| \__|\__| \__| \__| \________| \______/ \__| \__|\__| \__| \________|\________| \______/
*/
pragma solidity ^0.8.9;
contract GHNEcosystemSwapper is Ownable, Pausable, ERC721Holder, ERC1155Holder {
enum SwapState {
Proposed, //0
Canceled, //1
Completed //2
}
struct Swap {
uint256 swapId;
address initiator;
address[] initiatorNftAddresses;
uint256[] initiatorNftIds;
uint256[] initiatorNftAmounts;
address[] initiatorNftAddressesWant;
uint256[] initiatorNftIdsWant;
uint256[] initiatorNftAmountsWant;
address receiver;
uint256 state;
}
Swap[] public swaps;
mapping(address => uint256[]) public userSwaps;
address private GHN = 0xE6d48bF4ee912235398b96E16Db6F310c21e82CB;
address private SRBNNO = 0x50BEfFd8A0808314d3cc81B3cbF7f1AFA3A6B56c;
address private AHC = 0x9370045CE37F381500ac7D6802513bb89871e076;
address private DVDA = 0xC084a29DD0C9436568435938B1C6c5af4F5C035f;
address private RTBNNO = 0x0912DAD1db4643368B029166AF217B8A9818dB15;
address private MGHN = 0x8BdfD304d22c9F02d542b59aa9b91236C21Dfd82;
modifier onlyInitiator(uint256 _swapId) {
}
modifier onlyReceiver(uint256 _swapId) {
}
// Propose swap
function proposeSwap(
address _receiver,
address[] memory nftAddresses,
uint256[] memory nftIds,
uint256[] memory nftAmounts,
address[] memory nftAddressesWant,
uint256[] memory nftIdsWant,
uint256[] memory nftAmountsWant
) public whenNotPaused {
require(
msg.sender != _receiver,
"Requestor can't be the same as receiver."
);
require(
nftAddresses.length == nftIds.length,
"NFT and ID arrays have to be same length"
);
require(
nftAddresses.length == nftAmounts.length,
"NFT and AMOUNT arrays have to be same length"
);
require(
nftAddressesWant.length == nftIdsWant.length,
"NFT and ID WANT arrays have to be same length"
);
require(
nftAddressesWant.length == nftAmountsWant.length,
"NFT and AMOUNT WANT arrays have to be same length"
);
for (uint256 i = 0; i < nftAddresses.length; i++) {
require(<FILL_ME>)
}
for (uint256 i = 0; i < nftAddressesWant.length; i++) {
require(
nftAddresses[i] == GHN ||
nftAddresses[i] == SRBNNO ||
nftAddresses[i] == AHC ||
nftAddresses[i] == DVDA ||
nftAddresses[i] == RTBNNO ||
nftAddresses[i] == MGHN,
"Not GodHatesNFTees Ecosystem."
);
}
uint256 Id = swaps.length;
safeMultipleTransfersFrom(
msg.sender,
address(this),
nftAddresses,
nftIds,
nftAmounts
);
swaps.push(
Swap({
swapId: Id,
initiator: msg.sender,
initiatorNftAddresses: nftAddresses,
initiatorNftIds: nftIds,
initiatorNftAmounts: nftAmounts,
initiatorNftAddressesWant: nftAddressesWant,
initiatorNftIdsWant: nftIdsWant,
initiatorNftAmountsWant: nftAmountsWant,
receiver: _receiver,
state: uint256(SwapState.Proposed)
})
);
// Add Swaps of users
userSwaps[msg.sender].push(Id);
userSwaps[_receiver].push(Id);
}
// Confirm transaction
function acceptSwap(uint256 _swapId)
public
whenNotPaused
onlyReceiver(_swapId)
{
}
// Cancel Swap
function cancelSwap(uint256 _swapId)
public
whenNotPaused
onlyInitiator(_swapId)
{
}
// Get Swaps of users
function getUserSwaps(address usersAddress)
public
view
returns (uint256[] memory)
{
}
// Get all Swaps count
function getAllSwapsCount() public view returns (uint256) {
}
// Get Swaps data
function getSwapsData(uint256 _swapId)
public
view
returns (
uint256 swapId,
address initiator,
address receiver,
address[] memory initiatorNftAddresses,
uint256[] memory initiatorNftIds,
uint256[] memory initiatorNftAmounts,
address[] memory initiatorNftAddressesWant,
uint256[] memory initiatorNftIdsWant,
uint256[] memory initiatorNftAmountsWant,
uint256 state
)
{
}
// Pause Contract
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function safeMultipleTransfersFrom(
address from,
address to,
address[] memory nftAddresses,
uint256[] memory nftIds,
uint256[] memory nftAmounts
) internal virtual {
}
function safeTransferFrom(
address from,
address to,
address tokenAddress,
uint256 tokenId,
uint256 tokenAmount,
bytes memory _data
) internal virtual {
}
}
| nftAddresses[i]==GHN||nftAddresses[i]==SRBNNO||nftAddresses[i]==AHC||nftAddresses[i]==DVDA||nftAddresses[i]==RTBNNO||nftAddresses[i]==MGHN,"Not GodHatesNFTees Ecosystem." | 146,664 | nftAddresses[i]==GHN||nftAddresses[i]==SRBNNO||nftAddresses[i]==AHC||nftAddresses[i]==DVDA||nftAddresses[i]==RTBNNO||nftAddresses[i]==MGHN |
"Can't accept swap. Initiator didn't create swap." | /*
$$$$$$\ $$$$$$\ $$$$$$$\ $$\ $$\ $$$$$$\ $$$$$$$$\ $$$$$$$$\ $$$$$$\ $$\ $$\ $$$$$$$$\ $$$$$$$$\ $$$$$$$$\ $$$$$$$$\ $$$$$$\
$$ __$$\ $$ __$$\ $$ __$$\ $$ | $$ |$$ __$$\\__$$ __|$$ _____|$$ __$$\ $$$\ $$ |$$ _____|\__$$ __|$$ _____|$$ _____|$$ __$$\
$$ / \__|$$ / $$ |$$ | $$ | $$ | $$ |$$ / $$ | $$ | $$ | $$ / \__| $$$$\ $$ |$$ | $$ | $$ | $$ | $$ / \__|
$$ |$$$$\ $$ | $$ |$$ | $$ | $$$$$$$$ |$$$$$$$$ | $$ | $$$$$\ \$$$$$$\ $$ $$\$$ |$$$$$\ $$ | $$$$$\ $$$$$\ \$$$$$$\
$$ |\_$$ |$$ | $$ |$$ | $$ | $$ __$$ |$$ __$$ | $$ | $$ __| \____$$\ $$ \$$$$ |$$ __| $$ | $$ __| $$ __| \____$$\
$$ | $$ |$$ | $$ |$$ | $$ | $$ | $$ |$$ | $$ | $$ | $$ | $$\ $$ | $$ |\$$$ |$$ | $$ | $$ | $$ | $$\ $$ |
\$$$$$$ | $$$$$$ |$$$$$$$ | $$ | $$ |$$ | $$ | $$ | $$$$$$$$\ \$$$$$$ | $$ | \$$ |$$ | $$ | $$$$$$$$\ $$$$$$$$\ \$$$$$$ |
\______/ \______/ \_______/ \__| \__|\__| \__| \__| \________| \______/ \__| \__|\__| \__| \________|\________| \______/
*/
pragma solidity ^0.8.9;
contract GHNEcosystemSwapper is Ownable, Pausable, ERC721Holder, ERC1155Holder {
enum SwapState {
Proposed, //0
Canceled, //1
Completed //2
}
struct Swap {
uint256 swapId;
address initiator;
address[] initiatorNftAddresses;
uint256[] initiatorNftIds;
uint256[] initiatorNftAmounts;
address[] initiatorNftAddressesWant;
uint256[] initiatorNftIdsWant;
uint256[] initiatorNftAmountsWant;
address receiver;
uint256 state;
}
Swap[] public swaps;
mapping(address => uint256[]) public userSwaps;
address private GHN = 0xE6d48bF4ee912235398b96E16Db6F310c21e82CB;
address private SRBNNO = 0x50BEfFd8A0808314d3cc81B3cbF7f1AFA3A6B56c;
address private AHC = 0x9370045CE37F381500ac7D6802513bb89871e076;
address private DVDA = 0xC084a29DD0C9436568435938B1C6c5af4F5C035f;
address private RTBNNO = 0x0912DAD1db4643368B029166AF217B8A9818dB15;
address private MGHN = 0x8BdfD304d22c9F02d542b59aa9b91236C21Dfd82;
modifier onlyInitiator(uint256 _swapId) {
}
modifier onlyReceiver(uint256 _swapId) {
}
// Propose swap
function proposeSwap(
address _receiver,
address[] memory nftAddresses,
uint256[] memory nftIds,
uint256[] memory nftAmounts,
address[] memory nftAddressesWant,
uint256[] memory nftIdsWant,
uint256[] memory nftAmountsWant
) public whenNotPaused {
}
// Confirm transaction
function acceptSwap(uint256 _swapId)
public
whenNotPaused
onlyReceiver(_swapId)
{
require(<FILL_ME>)
// transfer NFTs from Receiver to initiator
safeMultipleTransfersFrom(
swaps[_swapId].receiver,
swaps[_swapId].initiator,
swaps[_swapId].initiatorNftAddressesWant,
swaps[_swapId].initiatorNftIdsWant,
swaps[_swapId].initiatorNftAmountsWant
);
// transfer NFTs from smart contract to second user
safeMultipleTransfersFrom(
address(this),
swaps[_swapId].receiver,
swaps[_swapId].initiatorNftAddresses,
swaps[_swapId].initiatorNftIds,
swaps[_swapId].initiatorNftAmounts
);
Swap storage swap = swaps[_swapId];
swap.state = uint256(SwapState.Completed);
}
// Cancel Swap
function cancelSwap(uint256 _swapId)
public
whenNotPaused
onlyInitiator(_swapId)
{
}
// Get Swaps of users
function getUserSwaps(address usersAddress)
public
view
returns (uint256[] memory)
{
}
// Get all Swaps count
function getAllSwapsCount() public view returns (uint256) {
}
// Get Swaps data
function getSwapsData(uint256 _swapId)
public
view
returns (
uint256 swapId,
address initiator,
address receiver,
address[] memory initiatorNftAddresses,
uint256[] memory initiatorNftIds,
uint256[] memory initiatorNftAmounts,
address[] memory initiatorNftAddressesWant,
uint256[] memory initiatorNftIdsWant,
uint256[] memory initiatorNftAmountsWant,
uint256 state
)
{
}
// Pause Contract
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function safeMultipleTransfersFrom(
address from,
address to,
address[] memory nftAddresses,
uint256[] memory nftIds,
uint256[] memory nftAmounts
) internal virtual {
}
function safeTransferFrom(
address from,
address to,
address tokenAddress,
uint256 tokenId,
uint256 tokenAmount,
bytes memory _data
) internal virtual {
}
}
| (swaps[_swapId].initiatorNftAddresses.length!=0),"Can't accept swap. Initiator didn't create swap." | 146,664 | (swaps[_swapId].initiatorNftAddresses.length!=0) |
"You did not supply a valid USDC token." | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "hardhat/console.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "./SlayToEarnItems.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
interface IERC20Extended is IERC20 {
function symbol() external view returns (string memory);
}
// https://t.me/BlockifyGames
contract SlayToEarnToken is Context, Ownable, IERC20, IERC20Metadata, AccessControl {
bytes32 public constant MAINTENANCE_ROLE = keccak256("MAINTENANCE_ROLE");
bool private _enableGateKeeper;
uint256 private _tokenRewardsPercentage;
uint256 private _tokenDevPercentage;
uint256 private _tokenBurnPercentage;
uint256 private _tokenBuyBackPercentage;
IERC1155 private _originalWitnessCollection;
SlayToEarnItems private _currentItemCollection;
uint256 private _maxWalletAmount;
address private _claimRewardsContract;
uint256 private _launchTime;
address private _deployer;
address private _uniswapLpPair;
address private _devIncomeWallet;
IUniswapV2Router02 private _uniswapRouter;
address private _usdcToken;
address private _blockifyToken;
IUniswapV2Factory private _uniswapFactory;
mapping(address => bool) private _whitelist;
mapping(address => uint256) private _lastBuyBlock;
mapping(address => uint256) private _taxReductionPercentageMap;
constructor(
IERC1155 originalWitnessCollection,
SlayToEarnItems currentItemCollection,
address devIncomeWallet,
address claimRewardsContract,
IUniswapV2Router02 uniswapRouter,
IERC20Extended usdcToken,
IERC20Extended blockifyToken) {
_name = "Slay To Earn";
_symbol = "SLAY2EARN";
_deployer = msg.sender;
_originalWitnessCollection = originalWitnessCollection;
_currentItemCollection = currentItemCollection;
_devIncomeWallet = devIncomeWallet;
_claimRewardsContract = claimRewardsContract;
_uniswapRouter = uniswapRouter;
_usdcToken = address(usdcToken);
_blockifyToken = address(blockifyToken);
_uniswapFactory = IUniswapV2Factory(uniswapRouter.factory());
_uniswapLpPair = _uniswapFactory.createPair(address(this), _usdcToken);
_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
_setupRole(MAINTENANCE_ROLE, msg.sender);
_setRoleAdmin(MAINTENANCE_ROLE, DEFAULT_ADMIN_ROLE);
require(_uniswapLpPair != address(0), "Failed to create liquidity pair.");
require(<FILL_ME>)
setBlockifyToken(blockifyToken);
addToWhitelist(_deployer);
addToWhitelist(address(this));
setMaxWalletAmount(5_000_000_000 ether);
_mint(
_deployer,
1_000_000_000_000 ether
);
// Shortly after our initial launch, we will disable the gatekeeper and turn this into a regular, vanilla ERC20 token.
// Once disabled, there is no way to turn it back on...
_enableGateKeeper = true;
setTaxPercentages(0, 0, 6, 1);
getOwnedWitnessCount();
}
function setBlockifyToken(IERC20Extended blockifyToken) public onlyOwner {
}
function getBlockifyToken() public view returns (address) {
}
function getUsdcToken() public view returns (address) {
}
function getLiquidityPair() public view returns (address) {
}
function addToWhitelist(address addressToAdd) public onlyOwner {
}
function removeFromWhitelist(address addressToRemove) public onlyOwner {
}
function isWhitelisted(address addressToCheck) public view returns (bool) {
}
function isGateKeeperEnabled() public view returns (bool) {
}
function isGateKeeperPermanentlyDisabled() public view returns (bool) {
}
function setLaunchTime(uint256 unixTimestampSeconds) public onlyOwner {
}
function getLaunchTime() public view returns (uint256) {
}
function permanentlyDisarmUniswapGateKeeper() public onlyOwner {
}
/**
Use the given item from your inventory to apply tax reduction for your next Uniswap trade.
The item will be consumed immediately in this call, even if you never make another Uniswap trade.
*/
function applyTaxReduction(uint256 itemId) public {
}
function getAppliedTaxReduction(address wallet) public view returns (uint256) {
}
function setTaxPercentages(uint256 burnPercentage, uint256 rewardPercentage, uint256 devPercentage, uint256 blockifyBuyBackPercentage) public onlyOwner {
}
function getBuyBackPercentage() public view returns (uint256) {
}
function getBurnPercentage() public view returns (uint256) {
}
function getRewardsPercentage() public view returns (uint256) {
}
function getDevPercentage() public view returns (uint256) {
}
function setCurrentItemCollection(SlayToEarnItems currentCollection) public onlyOwner {
}
function getCurrentItemCollection() public view returns (IERC1155) {
}
function setOriginalWitnessItemCollection(IERC1155 originalCollection) public onlyOwner {
}
function getOriginalWitnessItemCollection() public view returns (IERC1155) {
}
function getOwnedWitnessCount() public view returns (uint256) {
}
function getOwnedWitnessCountForAddress(address wallet) public view returns (uint256) {
}
function setRewardsClaimContract(address rewardsClaimContract) public onlyOwner {
}
function getRewardsClaimContract() public view returns (address) {
}
function setDevIncomeWallet(address wallet) public onlyOwner {
}
function getDevIncomeWallet() public view returns (address) {
}
function setMaxWalletAmount(uint256 maxWalletAmount) public onlyOwner {
}
function getMaxWalletAmount() public view returns (uint256) {
}
function _transfer(
address sender,
address recipient,
uint256 sentAmount
) internal {
}
/**
* This method can be front-run. Just as with swaps, make sure to select a tight slippage around the actual prices
before running the methods.
*/
function runMaintenance(uint256 maximumSlayToEarnPerUsdc, uint256 maximumSlayToEarnPerBlockify) public onlyRole(MAINTENANCE_ROLE) {
}
function _doTransferDevFee(uint256 tokensToSell, uint256 maximumSlayToEarnPerUsdc) internal {
}
function _doBlockifyBuyback(uint256 tokensToSell, uint256 maximumSlayToEarnPerBlockify) internal {
}
function _feelessTransfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////// OpenZepplin ERC20.sol
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
}
| keccak256(bytes(usdcToken.symbol()))==keccak256("USDC"),"You did not supply a valid USDC token." | 146,839 | keccak256(bytes(usdcToken.symbol()))==keccak256("USDC") |
"You did not supply a valid BLOCKIFY token." | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "hardhat/console.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "./SlayToEarnItems.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
interface IERC20Extended is IERC20 {
function symbol() external view returns (string memory);
}
// https://t.me/BlockifyGames
contract SlayToEarnToken is Context, Ownable, IERC20, IERC20Metadata, AccessControl {
bytes32 public constant MAINTENANCE_ROLE = keccak256("MAINTENANCE_ROLE");
bool private _enableGateKeeper;
uint256 private _tokenRewardsPercentage;
uint256 private _tokenDevPercentage;
uint256 private _tokenBurnPercentage;
uint256 private _tokenBuyBackPercentage;
IERC1155 private _originalWitnessCollection;
SlayToEarnItems private _currentItemCollection;
uint256 private _maxWalletAmount;
address private _claimRewardsContract;
uint256 private _launchTime;
address private _deployer;
address private _uniswapLpPair;
address private _devIncomeWallet;
IUniswapV2Router02 private _uniswapRouter;
address private _usdcToken;
address private _blockifyToken;
IUniswapV2Factory private _uniswapFactory;
mapping(address => bool) private _whitelist;
mapping(address => uint256) private _lastBuyBlock;
mapping(address => uint256) private _taxReductionPercentageMap;
constructor(
IERC1155 originalWitnessCollection,
SlayToEarnItems currentItemCollection,
address devIncomeWallet,
address claimRewardsContract,
IUniswapV2Router02 uniswapRouter,
IERC20Extended usdcToken,
IERC20Extended blockifyToken) {
}
function setBlockifyToken(IERC20Extended blockifyToken) public onlyOwner {
if (address(blockifyToken) != address(0)) {
require(<FILL_ME>)
require(_uniswapFactory.getPair(_blockifyToken, _usdcToken) != address(0), "There is no USDC/BLOCKIFY pool. Likely the tokens you supplied are not valid.");
}
_blockifyToken = address(blockifyToken);
}
function getBlockifyToken() public view returns (address) {
}
function getUsdcToken() public view returns (address) {
}
function getLiquidityPair() public view returns (address) {
}
function addToWhitelist(address addressToAdd) public onlyOwner {
}
function removeFromWhitelist(address addressToRemove) public onlyOwner {
}
function isWhitelisted(address addressToCheck) public view returns (bool) {
}
function isGateKeeperEnabled() public view returns (bool) {
}
function isGateKeeperPermanentlyDisabled() public view returns (bool) {
}
function setLaunchTime(uint256 unixTimestampSeconds) public onlyOwner {
}
function getLaunchTime() public view returns (uint256) {
}
function permanentlyDisarmUniswapGateKeeper() public onlyOwner {
}
/**
Use the given item from your inventory to apply tax reduction for your next Uniswap trade.
The item will be consumed immediately in this call, even if you never make another Uniswap trade.
*/
function applyTaxReduction(uint256 itemId) public {
}
function getAppliedTaxReduction(address wallet) public view returns (uint256) {
}
function setTaxPercentages(uint256 burnPercentage, uint256 rewardPercentage, uint256 devPercentage, uint256 blockifyBuyBackPercentage) public onlyOwner {
}
function getBuyBackPercentage() public view returns (uint256) {
}
function getBurnPercentage() public view returns (uint256) {
}
function getRewardsPercentage() public view returns (uint256) {
}
function getDevPercentage() public view returns (uint256) {
}
function setCurrentItemCollection(SlayToEarnItems currentCollection) public onlyOwner {
}
function getCurrentItemCollection() public view returns (IERC1155) {
}
function setOriginalWitnessItemCollection(IERC1155 originalCollection) public onlyOwner {
}
function getOriginalWitnessItemCollection() public view returns (IERC1155) {
}
function getOwnedWitnessCount() public view returns (uint256) {
}
function getOwnedWitnessCountForAddress(address wallet) public view returns (uint256) {
}
function setRewardsClaimContract(address rewardsClaimContract) public onlyOwner {
}
function getRewardsClaimContract() public view returns (address) {
}
function setDevIncomeWallet(address wallet) public onlyOwner {
}
function getDevIncomeWallet() public view returns (address) {
}
function setMaxWalletAmount(uint256 maxWalletAmount) public onlyOwner {
}
function getMaxWalletAmount() public view returns (uint256) {
}
function _transfer(
address sender,
address recipient,
uint256 sentAmount
) internal {
}
/**
* This method can be front-run. Just as with swaps, make sure to select a tight slippage around the actual prices
before running the methods.
*/
function runMaintenance(uint256 maximumSlayToEarnPerUsdc, uint256 maximumSlayToEarnPerBlockify) public onlyRole(MAINTENANCE_ROLE) {
}
function _doTransferDevFee(uint256 tokensToSell, uint256 maximumSlayToEarnPerUsdc) internal {
}
function _doBlockifyBuyback(uint256 tokensToSell, uint256 maximumSlayToEarnPerBlockify) internal {
}
function _feelessTransfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////// OpenZepplin ERC20.sol
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
}
| keccak256(bytes(blockifyToken.symbol()))==keccak256("BLOCKIFY"),"You did not supply a valid BLOCKIFY token." | 146,839 | keccak256(bytes(blockifyToken.symbol()))==keccak256("BLOCKIFY") |
"There is no USDC/BLOCKIFY pool. Likely the tokens you supplied are not valid." | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "hardhat/console.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "./SlayToEarnItems.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
interface IERC20Extended is IERC20 {
function symbol() external view returns (string memory);
}
// https://t.me/BlockifyGames
contract SlayToEarnToken is Context, Ownable, IERC20, IERC20Metadata, AccessControl {
bytes32 public constant MAINTENANCE_ROLE = keccak256("MAINTENANCE_ROLE");
bool private _enableGateKeeper;
uint256 private _tokenRewardsPercentage;
uint256 private _tokenDevPercentage;
uint256 private _tokenBurnPercentage;
uint256 private _tokenBuyBackPercentage;
IERC1155 private _originalWitnessCollection;
SlayToEarnItems private _currentItemCollection;
uint256 private _maxWalletAmount;
address private _claimRewardsContract;
uint256 private _launchTime;
address private _deployer;
address private _uniswapLpPair;
address private _devIncomeWallet;
IUniswapV2Router02 private _uniswapRouter;
address private _usdcToken;
address private _blockifyToken;
IUniswapV2Factory private _uniswapFactory;
mapping(address => bool) private _whitelist;
mapping(address => uint256) private _lastBuyBlock;
mapping(address => uint256) private _taxReductionPercentageMap;
constructor(
IERC1155 originalWitnessCollection,
SlayToEarnItems currentItemCollection,
address devIncomeWallet,
address claimRewardsContract,
IUniswapV2Router02 uniswapRouter,
IERC20Extended usdcToken,
IERC20Extended blockifyToken) {
}
function setBlockifyToken(IERC20Extended blockifyToken) public onlyOwner {
if (address(blockifyToken) != address(0)) {
require(keccak256(bytes(blockifyToken.symbol())) == keccak256("BLOCKIFY"), "You did not supply a valid BLOCKIFY token.");
require(<FILL_ME>)
}
_blockifyToken = address(blockifyToken);
}
function getBlockifyToken() public view returns (address) {
}
function getUsdcToken() public view returns (address) {
}
function getLiquidityPair() public view returns (address) {
}
function addToWhitelist(address addressToAdd) public onlyOwner {
}
function removeFromWhitelist(address addressToRemove) public onlyOwner {
}
function isWhitelisted(address addressToCheck) public view returns (bool) {
}
function isGateKeeperEnabled() public view returns (bool) {
}
function isGateKeeperPermanentlyDisabled() public view returns (bool) {
}
function setLaunchTime(uint256 unixTimestampSeconds) public onlyOwner {
}
function getLaunchTime() public view returns (uint256) {
}
function permanentlyDisarmUniswapGateKeeper() public onlyOwner {
}
/**
Use the given item from your inventory to apply tax reduction for your next Uniswap trade.
The item will be consumed immediately in this call, even if you never make another Uniswap trade.
*/
function applyTaxReduction(uint256 itemId) public {
}
function getAppliedTaxReduction(address wallet) public view returns (uint256) {
}
function setTaxPercentages(uint256 burnPercentage, uint256 rewardPercentage, uint256 devPercentage, uint256 blockifyBuyBackPercentage) public onlyOwner {
}
function getBuyBackPercentage() public view returns (uint256) {
}
function getBurnPercentage() public view returns (uint256) {
}
function getRewardsPercentage() public view returns (uint256) {
}
function getDevPercentage() public view returns (uint256) {
}
function setCurrentItemCollection(SlayToEarnItems currentCollection) public onlyOwner {
}
function getCurrentItemCollection() public view returns (IERC1155) {
}
function setOriginalWitnessItemCollection(IERC1155 originalCollection) public onlyOwner {
}
function getOriginalWitnessItemCollection() public view returns (IERC1155) {
}
function getOwnedWitnessCount() public view returns (uint256) {
}
function getOwnedWitnessCountForAddress(address wallet) public view returns (uint256) {
}
function setRewardsClaimContract(address rewardsClaimContract) public onlyOwner {
}
function getRewardsClaimContract() public view returns (address) {
}
function setDevIncomeWallet(address wallet) public onlyOwner {
}
function getDevIncomeWallet() public view returns (address) {
}
function setMaxWalletAmount(uint256 maxWalletAmount) public onlyOwner {
}
function getMaxWalletAmount() public view returns (uint256) {
}
function _transfer(
address sender,
address recipient,
uint256 sentAmount
) internal {
}
/**
* This method can be front-run. Just as with swaps, make sure to select a tight slippage around the actual prices
before running the methods.
*/
function runMaintenance(uint256 maximumSlayToEarnPerUsdc, uint256 maximumSlayToEarnPerBlockify) public onlyRole(MAINTENANCE_ROLE) {
}
function _doTransferDevFee(uint256 tokensToSell, uint256 maximumSlayToEarnPerUsdc) internal {
}
function _doBlockifyBuyback(uint256 tokensToSell, uint256 maximumSlayToEarnPerBlockify) internal {
}
function _feelessTransfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////// OpenZepplin ERC20.sol
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
}
| _uniswapFactory.getPair(_blockifyToken,_usdcToken)!=address(0),"There is no USDC/BLOCKIFY pool. Likely the tokens you supplied are not valid." | 146,839 | _uniswapFactory.getPair(_blockifyToken,_usdcToken)!=address(0) |
"You don't own the given item." | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "hardhat/console.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "./SlayToEarnItems.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
interface IERC20Extended is IERC20 {
function symbol() external view returns (string memory);
}
// https://t.me/BlockifyGames
contract SlayToEarnToken is Context, Ownable, IERC20, IERC20Metadata, AccessControl {
bytes32 public constant MAINTENANCE_ROLE = keccak256("MAINTENANCE_ROLE");
bool private _enableGateKeeper;
uint256 private _tokenRewardsPercentage;
uint256 private _tokenDevPercentage;
uint256 private _tokenBurnPercentage;
uint256 private _tokenBuyBackPercentage;
IERC1155 private _originalWitnessCollection;
SlayToEarnItems private _currentItemCollection;
uint256 private _maxWalletAmount;
address private _claimRewardsContract;
uint256 private _launchTime;
address private _deployer;
address private _uniswapLpPair;
address private _devIncomeWallet;
IUniswapV2Router02 private _uniswapRouter;
address private _usdcToken;
address private _blockifyToken;
IUniswapV2Factory private _uniswapFactory;
mapping(address => bool) private _whitelist;
mapping(address => uint256) private _lastBuyBlock;
mapping(address => uint256) private _taxReductionPercentageMap;
constructor(
IERC1155 originalWitnessCollection,
SlayToEarnItems currentItemCollection,
address devIncomeWallet,
address claimRewardsContract,
IUniswapV2Router02 uniswapRouter,
IERC20Extended usdcToken,
IERC20Extended blockifyToken) {
}
function setBlockifyToken(IERC20Extended blockifyToken) public onlyOwner {
}
function getBlockifyToken() public view returns (address) {
}
function getUsdcToken() public view returns (address) {
}
function getLiquidityPair() public view returns (address) {
}
function addToWhitelist(address addressToAdd) public onlyOwner {
}
function removeFromWhitelist(address addressToRemove) public onlyOwner {
}
function isWhitelisted(address addressToCheck) public view returns (bool) {
}
function isGateKeeperEnabled() public view returns (bool) {
}
function isGateKeeperPermanentlyDisabled() public view returns (bool) {
}
function setLaunchTime(uint256 unixTimestampSeconds) public onlyOwner {
}
function getLaunchTime() public view returns (uint256) {
}
function permanentlyDisarmUniswapGateKeeper() public onlyOwner {
}
/**
Use the given item from your inventory to apply tax reduction for your next Uniswap trade.
The item will be consumed immediately in this call, even if you never make another Uniswap trade.
*/
function applyTaxReduction(uint256 itemId) public {
uint256 reduction = 0;
if (itemId == 2048777) {
reduction = 10;
} else if (itemId == 2048809) {
reduction = 30;
} else if (itemId == 2048841) {
reduction = 50;
} else if (itemId == 2048873) {
reduction = 70;
} else if (itemId == 2048905) {
reduction = 100;
} else {
require(false, "The given item does not refer to a tax reduction NFT.");
}
_taxReductionPercentageMap[msg.sender] = reduction;
uint256[] memory items = new uint256[](1);
uint256[] memory amounts = new uint256[](1);
items[0] = itemId;
amounts[0] = 1;
require(<FILL_ME>)
_currentItemCollection.burnBatch(msg.sender, items, amounts);
}
function getAppliedTaxReduction(address wallet) public view returns (uint256) {
}
function setTaxPercentages(uint256 burnPercentage, uint256 rewardPercentage, uint256 devPercentage, uint256 blockifyBuyBackPercentage) public onlyOwner {
}
function getBuyBackPercentage() public view returns (uint256) {
}
function getBurnPercentage() public view returns (uint256) {
}
function getRewardsPercentage() public view returns (uint256) {
}
function getDevPercentage() public view returns (uint256) {
}
function setCurrentItemCollection(SlayToEarnItems currentCollection) public onlyOwner {
}
function getCurrentItemCollection() public view returns (IERC1155) {
}
function setOriginalWitnessItemCollection(IERC1155 originalCollection) public onlyOwner {
}
function getOriginalWitnessItemCollection() public view returns (IERC1155) {
}
function getOwnedWitnessCount() public view returns (uint256) {
}
function getOwnedWitnessCountForAddress(address wallet) public view returns (uint256) {
}
function setRewardsClaimContract(address rewardsClaimContract) public onlyOwner {
}
function getRewardsClaimContract() public view returns (address) {
}
function setDevIncomeWallet(address wallet) public onlyOwner {
}
function getDevIncomeWallet() public view returns (address) {
}
function setMaxWalletAmount(uint256 maxWalletAmount) public onlyOwner {
}
function getMaxWalletAmount() public view returns (uint256) {
}
function _transfer(
address sender,
address recipient,
uint256 sentAmount
) internal {
}
/**
* This method can be front-run. Just as with swaps, make sure to select a tight slippage around the actual prices
before running the methods.
*/
function runMaintenance(uint256 maximumSlayToEarnPerUsdc, uint256 maximumSlayToEarnPerBlockify) public onlyRole(MAINTENANCE_ROLE) {
}
function _doTransferDevFee(uint256 tokensToSell, uint256 maximumSlayToEarnPerUsdc) internal {
}
function _doBlockifyBuyback(uint256 tokensToSell, uint256 maximumSlayToEarnPerBlockify) internal {
}
function _feelessTransfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////// OpenZepplin ERC20.sol
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
}
| _currentItemCollection.balanceOf(msg.sender,itemId)>0,"You don't own the given item." | 146,839 | _currentItemCollection.balanceOf(msg.sender,itemId)>0 |
"The maximum total combined fee is 30%." | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "hardhat/console.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "./SlayToEarnItems.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
interface IERC20Extended is IERC20 {
function symbol() external view returns (string memory);
}
// https://t.me/BlockifyGames
contract SlayToEarnToken is Context, Ownable, IERC20, IERC20Metadata, AccessControl {
bytes32 public constant MAINTENANCE_ROLE = keccak256("MAINTENANCE_ROLE");
bool private _enableGateKeeper;
uint256 private _tokenRewardsPercentage;
uint256 private _tokenDevPercentage;
uint256 private _tokenBurnPercentage;
uint256 private _tokenBuyBackPercentage;
IERC1155 private _originalWitnessCollection;
SlayToEarnItems private _currentItemCollection;
uint256 private _maxWalletAmount;
address private _claimRewardsContract;
uint256 private _launchTime;
address private _deployer;
address private _uniswapLpPair;
address private _devIncomeWallet;
IUniswapV2Router02 private _uniswapRouter;
address private _usdcToken;
address private _blockifyToken;
IUniswapV2Factory private _uniswapFactory;
mapping(address => bool) private _whitelist;
mapping(address => uint256) private _lastBuyBlock;
mapping(address => uint256) private _taxReductionPercentageMap;
constructor(
IERC1155 originalWitnessCollection,
SlayToEarnItems currentItemCollection,
address devIncomeWallet,
address claimRewardsContract,
IUniswapV2Router02 uniswapRouter,
IERC20Extended usdcToken,
IERC20Extended blockifyToken) {
}
function setBlockifyToken(IERC20Extended blockifyToken) public onlyOwner {
}
function getBlockifyToken() public view returns (address) {
}
function getUsdcToken() public view returns (address) {
}
function getLiquidityPair() public view returns (address) {
}
function addToWhitelist(address addressToAdd) public onlyOwner {
}
function removeFromWhitelist(address addressToRemove) public onlyOwner {
}
function isWhitelisted(address addressToCheck) public view returns (bool) {
}
function isGateKeeperEnabled() public view returns (bool) {
}
function isGateKeeperPermanentlyDisabled() public view returns (bool) {
}
function setLaunchTime(uint256 unixTimestampSeconds) public onlyOwner {
}
function getLaunchTime() public view returns (uint256) {
}
function permanentlyDisarmUniswapGateKeeper() public onlyOwner {
}
/**
Use the given item from your inventory to apply tax reduction for your next Uniswap trade.
The item will be consumed immediately in this call, even if you never make another Uniswap trade.
*/
function applyTaxReduction(uint256 itemId) public {
}
function getAppliedTaxReduction(address wallet) public view returns (uint256) {
}
function setTaxPercentages(uint256 burnPercentage, uint256 rewardPercentage, uint256 devPercentage, uint256 blockifyBuyBackPercentage) public onlyOwner {
_tokenBurnPercentage = burnPercentage;
_tokenRewardsPercentage = rewardPercentage;
_tokenDevPercentage = devPercentage;
_tokenBuyBackPercentage = blockifyBuyBackPercentage;
require(_tokenBurnPercentage <= 20, "The maximum burn fee is 20%.");
require(_tokenBuyBackPercentage <= 20, "The maximum buy-back fee is 20%.");
require(_tokenRewardsPercentage <= 20, "The maximum reward fee is 20%.");
require(_tokenDevPercentage <= 20, "The maximum dev fee is 20%.");
require(<FILL_ME>)
}
function getBuyBackPercentage() public view returns (uint256) {
}
function getBurnPercentage() public view returns (uint256) {
}
function getRewardsPercentage() public view returns (uint256) {
}
function getDevPercentage() public view returns (uint256) {
}
function setCurrentItemCollection(SlayToEarnItems currentCollection) public onlyOwner {
}
function getCurrentItemCollection() public view returns (IERC1155) {
}
function setOriginalWitnessItemCollection(IERC1155 originalCollection) public onlyOwner {
}
function getOriginalWitnessItemCollection() public view returns (IERC1155) {
}
function getOwnedWitnessCount() public view returns (uint256) {
}
function getOwnedWitnessCountForAddress(address wallet) public view returns (uint256) {
}
function setRewardsClaimContract(address rewardsClaimContract) public onlyOwner {
}
function getRewardsClaimContract() public view returns (address) {
}
function setDevIncomeWallet(address wallet) public onlyOwner {
}
function getDevIncomeWallet() public view returns (address) {
}
function setMaxWalletAmount(uint256 maxWalletAmount) public onlyOwner {
}
function getMaxWalletAmount() public view returns (uint256) {
}
function _transfer(
address sender,
address recipient,
uint256 sentAmount
) internal {
}
/**
* This method can be front-run. Just as with swaps, make sure to select a tight slippage around the actual prices
before running the methods.
*/
function runMaintenance(uint256 maximumSlayToEarnPerUsdc, uint256 maximumSlayToEarnPerBlockify) public onlyRole(MAINTENANCE_ROLE) {
}
function _doTransferDevFee(uint256 tokensToSell, uint256 maximumSlayToEarnPerUsdc) internal {
}
function _doBlockifyBuyback(uint256 tokensToSell, uint256 maximumSlayToEarnPerBlockify) internal {
}
function _feelessTransfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////// OpenZepplin ERC20.sol
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
}
| _tokenBurnPercentage+_tokenBuyBackPercentage+_tokenRewardsPercentage+_tokenDevPercentage<=30,"The maximum total combined fee is 30%." | 146,839 | _tokenBurnPercentage+_tokenBuyBackPercentage+_tokenRewardsPercentage+_tokenDevPercentage<=30 |
"Buy blocked. Token limit per wallet exceeded. Refer to our Telegram for further information. This restriction will be lifted shortly." | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "hardhat/console.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "./SlayToEarnItems.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
interface IERC20Extended is IERC20 {
function symbol() external view returns (string memory);
}
// https://t.me/BlockifyGames
contract SlayToEarnToken is Context, Ownable, IERC20, IERC20Metadata, AccessControl {
bytes32 public constant MAINTENANCE_ROLE = keccak256("MAINTENANCE_ROLE");
bool private _enableGateKeeper;
uint256 private _tokenRewardsPercentage;
uint256 private _tokenDevPercentage;
uint256 private _tokenBurnPercentage;
uint256 private _tokenBuyBackPercentage;
IERC1155 private _originalWitnessCollection;
SlayToEarnItems private _currentItemCollection;
uint256 private _maxWalletAmount;
address private _claimRewardsContract;
uint256 private _launchTime;
address private _deployer;
address private _uniswapLpPair;
address private _devIncomeWallet;
IUniswapV2Router02 private _uniswapRouter;
address private _usdcToken;
address private _blockifyToken;
IUniswapV2Factory private _uniswapFactory;
mapping(address => bool) private _whitelist;
mapping(address => uint256) private _lastBuyBlock;
mapping(address => uint256) private _taxReductionPercentageMap;
constructor(
IERC1155 originalWitnessCollection,
SlayToEarnItems currentItemCollection,
address devIncomeWallet,
address claimRewardsContract,
IUniswapV2Router02 uniswapRouter,
IERC20Extended usdcToken,
IERC20Extended blockifyToken) {
}
function setBlockifyToken(IERC20Extended blockifyToken) public onlyOwner {
}
function getBlockifyToken() public view returns (address) {
}
function getUsdcToken() public view returns (address) {
}
function getLiquidityPair() public view returns (address) {
}
function addToWhitelist(address addressToAdd) public onlyOwner {
}
function removeFromWhitelist(address addressToRemove) public onlyOwner {
}
function isWhitelisted(address addressToCheck) public view returns (bool) {
}
function isGateKeeperEnabled() public view returns (bool) {
}
function isGateKeeperPermanentlyDisabled() public view returns (bool) {
}
function setLaunchTime(uint256 unixTimestampSeconds) public onlyOwner {
}
function getLaunchTime() public view returns (uint256) {
}
function permanentlyDisarmUniswapGateKeeper() public onlyOwner {
}
/**
Use the given item from your inventory to apply tax reduction for your next Uniswap trade.
The item will be consumed immediately in this call, even if you never make another Uniswap trade.
*/
function applyTaxReduction(uint256 itemId) public {
}
function getAppliedTaxReduction(address wallet) public view returns (uint256) {
}
function setTaxPercentages(uint256 burnPercentage, uint256 rewardPercentage, uint256 devPercentage, uint256 blockifyBuyBackPercentage) public onlyOwner {
}
function getBuyBackPercentage() public view returns (uint256) {
}
function getBurnPercentage() public view returns (uint256) {
}
function getRewardsPercentage() public view returns (uint256) {
}
function getDevPercentage() public view returns (uint256) {
}
function setCurrentItemCollection(SlayToEarnItems currentCollection) public onlyOwner {
}
function getCurrentItemCollection() public view returns (IERC1155) {
}
function setOriginalWitnessItemCollection(IERC1155 originalCollection) public onlyOwner {
}
function getOriginalWitnessItemCollection() public view returns (IERC1155) {
}
function getOwnedWitnessCount() public view returns (uint256) {
}
function getOwnedWitnessCountForAddress(address wallet) public view returns (uint256) {
}
function setRewardsClaimContract(address rewardsClaimContract) public onlyOwner {
}
function getRewardsClaimContract() public view returns (address) {
}
function setDevIncomeWallet(address wallet) public onlyOwner {
}
function getDevIncomeWallet() public view returns (address) {
}
function setMaxWalletAmount(uint256 maxWalletAmount) public onlyOwner {
}
function getMaxWalletAmount() public view returns (uint256) {
}
function _transfer(
address sender,
address recipient,
uint256 sentAmount
) internal {
if (isWhitelisted(sender) || isWhitelisted(recipient)) {
_feelessTransfer(sender, recipient, sentAmount);
return;
}
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
bool isGateKeeperDisabled = isGateKeeperPermanentlyDisabled();
if (getMaxWalletAmount() > 0) {
if (recipient == _uniswapLpPair) {
// since we can't limit the LP pair, during selling, we only limit tx amounts
require(sentAmount <= getMaxWalletAmount(), "Sell blocked. Token limit per transaction exceeded. Refer to our Telegram for further information. This restriction will be lifted shortly.");
} else {
// during buys, we make sure that you can't put more than the limit into the wallet
require(<FILL_ME>)
}
}
// you can only buy once per block while gatekeeper is enabled
bool noBuyInThisBlock = _lastBuyBlock[recipient] < block.number;
_lastBuyBlock[recipient] = block.number;
require(recipient == _uniswapLpPair || noBuyInThisBlock || isGateKeeperDisabled, "Buy blocked by gatekeeper. You can only buy once per block. Refer to our Telegram for further information. This restriction will be lifted shortly.");
// to buy, you have to hold our launch witness while gatekeeper is enabled
bool hasRequiredWitnesses = getOwnedWitnessCountForAddress(recipient) >= 2;
require(recipient == _uniswapLpPair || hasRequiredWitnesses || isGateKeeperDisabled, "Buy blocked by gatekeeper. Target wallet does not own enough of our NFTs. Refer to our Telegram for further information. This restriction will be lifted shortly.");
uint256 taxReductionPercentage = _taxReductionPercentageMap[sender];
_taxReductionPercentageMap[sender] = 0;
uint256 burnedTokens = (sentAmount * _tokenBurnPercentage * (100 - taxReductionPercentage)) / 10_000;
uint256 rewardTokens = (sentAmount * _tokenRewardsPercentage * (100 - taxReductionPercentage)) / 10_000;
uint256 devAndBuyBackTokens = (sentAmount * (_tokenDevPercentage + _tokenBuyBackPercentage) * (100 - taxReductionPercentage)) / 10_000;
uint256 receivedTokens = sentAmount - burnedTokens - rewardTokens - devAndBuyBackTokens;
if (burnedTokens > 0) {
_burn(sender, burnedTokens);
}
if (rewardTokens > 0) {
_feelessTransfer(sender, _claimRewardsContract, rewardTokens);
}
if (devAndBuyBackTokens > 0) {
_feelessTransfer(sender, address(this), devAndBuyBackTokens);
}
_feelessTransfer(sender, recipient, receivedTokens);
}
/**
* This method can be front-run. Just as with swaps, make sure to select a tight slippage around the actual prices
before running the methods.
*/
function runMaintenance(uint256 maximumSlayToEarnPerUsdc, uint256 maximumSlayToEarnPerBlockify) public onlyRole(MAINTENANCE_ROLE) {
}
function _doTransferDevFee(uint256 tokensToSell, uint256 maximumSlayToEarnPerUsdc) internal {
}
function _doBlockifyBuyback(uint256 tokensToSell, uint256 maximumSlayToEarnPerBlockify) internal {
}
function _feelessTransfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////// OpenZepplin ERC20.sol
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
}
| balanceOf(recipient)+sentAmount<=getMaxWalletAmount(),"Buy blocked. Token limit per wallet exceeded. Refer to our Telegram for further information. This restriction will be lifted shortly." | 146,839 | balanceOf(recipient)+sentAmount<=getMaxWalletAmount() |
"Whitelist Spot has been Claimed." | /* SPDX-License-Identifier: MIT */
/*
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&&&&&&
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@* .((((((* #@@@@@@@@@@@@@@@@@@@@@@&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@@@@@@@@@@#,/(/(///////^******** / #/.&@@@@@&&&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@@@@@@@.#//^*********,.&%,,,,,**,*,**** &@@&&&&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@@@& /^***********,,#/ & .,,,,,,,,,,,,****&&&&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@& *******,,,,****,. &&&&,&#.......,,,,,***,.&&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@/^******,*******##.&& #&& ........,,,,,,,*,/&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@&****************. &&& &&. &&,%&.,,,,,,,,,,,****&@&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@&***************#%,&&. &&&&& &&& ,,,,,,,,,*,*,***&&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@.////^***#////^ .&&. &( &@@ &..&&(&%*,,,,*********.&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@(////////////#%,&@&&&( & ,,. &&&&&& ./^******#////&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@////((((((%,( .,@ @&&&&& @@&&&& &.. %.#((//////(&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@%(#(##,..(//(##/(%%.*.@&&&&&& . &(/#&%#%(..%&##(,(.&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@%(#%. %@&&&&&&&&&&@#.%@&,%&* .&&&&&&&&&&&&#.,&#((&&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@@,%&#@/&&&&&&&&&&&&&@*# &&& *&&&&&&&&&&&&&&&%/#%#*@&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@@@((/.@&&&&&&&&&&&&&&*&.& %,,,&&&&&&&&&&&&&&&,*&@&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@%(..#@&&&&*.** &&(....@ ,&.*&&& (&&.&&&&&&,.%@&&&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@@@ . . . &&&@@@@&..*(&#/% %&. @%..,&@&&&&%... , &&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@.,*#/////((#%%&&@&&#,&& &&.,&@@&&%%#((////^*,,*@@&&&&@&&&&&&&&
@@@@@@@@@@@@@@@@@@@(&&&&@@@&&&%&&&/ ,&&%#@&&@@&&&&&%&@@@@@@@@@@@@&&&&&
@@@@@@@@@@@@@@@@@@@@@@@@@@@&@@@(#*. .*& , ,#/@@@@@@@@@@@@@@@@@@@@@@@@@@&&&&
@@@@@@@@@@@@@@@@@@@@@@@%@@@&@&#/,..# ..&&& * * ,@@@&%@(@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@(@#@@#*,..& . .%,. #@&&@/@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@&(&@@@@@&,,.( %.,*. ..*,&#@&%/(/@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@&(((%(%%@@%@@%@&@@(@#@@%&(&././^,@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@%(((/(#*@%#/@*@**&*@,.@@%,*,,,,.,@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@&(((((((@@*,*,,,,,,.@,,#,....*@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@(((((//^@,*,,,,..,,,.&@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#(//^**,,,,,/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
*/
pragma solidity ^ 0.8.7;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "contracts/ERC721A.sol";
contract CalaveraSociety is ERC721A, EIP712, Ownable {
using ECDSA
for bytes32;
using Strings
for uint256;
address whitelist_signer = 0x27F0a1103B81d674dfA0BDa0d1A3dDcc32296F16;
bool public activeContract = false;
bool public publicMint = false;
string public baseUri;
uint256 public MAX_SUPPLY = 666;
uint256 public price = 0.0249 ether;
mapping( uint256 => uint256 ) private whitelistClaimBitMask;
mapping( address => bool ) private addressMinted;
mapping( address => uint256 ) private mintedAmount;
mapping( address => uint256 ) private WLmintedAmount;
constructor()
ERC721A( "Calavera Society", "CLS" )
EIP712( "CLS", "1.0.0" ) {
}
function whitelistmint( bytes calldata _signature, uint256 _nftIndex, uint256 _quantity ) external payable mintCompliance()
{
uint256 _mintedAmount = WLmintedAmount[msg.sender];
require(<FILL_ME>)
require(MAX_SUPPLY >= (totalSupply() + _quantity),"The collection has been sold out.");
require( _verify( _whitelistHash( msg.sender, _nftIndex ), _signature), "Signature Invalid" );
require(_mintedAmount + _quantity <= 1, "You already minted one.");
require( msg.value >= price*_quantity , "ETH value isn't enough." );
_setClaimed( _nftIndex);
_mint( msg.sender, _quantity);
WLmintedAmount[ msg.sender ] = _mintedAmount + _quantity;
}
function mint(uint256 _quantity) external payable mintCompliance()
{
}
function isClaimed( uint256 _nftIndex) public view returns( bool ) {
}
function _setClaimed( uint256 _nftIndex) internal {
}
function _hash( address _account, uint256 _nftIndex, uint256 _quantity )
internal view returns( bytes32 ) {
}
function _whitelistHash( address _account, uint256 _nftIndex )
internal view returns( bytes32 ) {
}
function _verify( bytes32 digest, bytes memory signature)
internal view returns( bool ) {
}
function _baseURI() internal view virtual override returns( string memory ) {
}
function ActivateSale() external onlyOwner{
}
function tokenURI( uint256 _tokenId ) public view virtual override returns( string memory ) {
}
function setbaseUri( string memory newBaseURI ) external onlyOwner {
}
function EnablePublicMint() external onlyOwner {
}
function burnSupply() external onlyOwner {
}
function withdraw() public onlyOwner {
}
modifier mintCompliance() {
}
}
| !isClaimed(_nftIndex),"Whitelist Spot has been Claimed." | 146,865 | !isClaimed(_nftIndex) |
"The collection has been sold out." | /* SPDX-License-Identifier: MIT */
/*
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&&&&&&
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@* .((((((* #@@@@@@@@@@@@@@@@@@@@@@&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@@@@@@@@@@#,/(/(///////^******** / #/.&@@@@@&&&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@@@@@@@.#//^*********,.&%,,,,,**,*,**** &@@&&&&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@@@& /^***********,,#/ & .,,,,,,,,,,,,****&&&&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@& *******,,,,****,. &&&&,&#.......,,,,,***,.&&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@/^******,*******##.&& #&& ........,,,,,,,*,/&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@&****************. &&& &&. &&,%&.,,,,,,,,,,,****&@&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@&***************#%,&&. &&&&& &&& ,,,,,,,,,*,*,***&&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@.////^***#////^ .&&. &( &@@ &..&&(&%*,,,,*********.&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@(////////////#%,&@&&&( & ,,. &&&&&& ./^******#////&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@////((((((%,( .,@ @&&&&& @@&&&& &.. %.#((//////(&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@%(#(##,..(//(##/(%%.*.@&&&&&& . &(/#&%#%(..%&##(,(.&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@%(#%. %@&&&&&&&&&&@#.%@&,%&* .&&&&&&&&&&&&#.,&#((&&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@@,%&#@/&&&&&&&&&&&&&@*# &&& *&&&&&&&&&&&&&&&%/#%#*@&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@@@((/.@&&&&&&&&&&&&&&*&.& %,,,&&&&&&&&&&&&&&&,*&@&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@%(..#@&&&&*.** &&(....@ ,&.*&&& (&&.&&&&&&,.%@&&&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@@@ . . . &&&@@@@&..*(&#/% %&. @%..,&@&&&&%... , &&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@.,*#/////((#%%&&@&&#,&& &&.,&@@&&%%#((////^*,,*@@&&&&@&&&&&&&&
@@@@@@@@@@@@@@@@@@@(&&&&@@@&&&%&&&/ ,&&%#@&&@@&&&&&%&@@@@@@@@@@@@&&&&&
@@@@@@@@@@@@@@@@@@@@@@@@@@@&@@@(#*. .*& , ,#/@@@@@@@@@@@@@@@@@@@@@@@@@@&&&&
@@@@@@@@@@@@@@@@@@@@@@@%@@@&@&#/,..# ..&&& * * ,@@@&%@(@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@(@#@@#*,..& . .%,. #@&&@/@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@&(&@@@@@&,,.( %.,*. ..*,&#@&%/(/@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@&(((%(%%@@%@@%@&@@(@#@@%&(&././^,@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@%(((/(#*@%#/@*@**&*@,.@@%,*,,,,.,@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@&(((((((@@*,*,,,,,,.@,,#,....*@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@(((((//^@,*,,,,..,,,.&@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#(//^**,,,,,/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
*/
pragma solidity ^ 0.8.7;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "contracts/ERC721A.sol";
contract CalaveraSociety is ERC721A, EIP712, Ownable {
using ECDSA
for bytes32;
using Strings
for uint256;
address whitelist_signer = 0x27F0a1103B81d674dfA0BDa0d1A3dDcc32296F16;
bool public activeContract = false;
bool public publicMint = false;
string public baseUri;
uint256 public MAX_SUPPLY = 666;
uint256 public price = 0.0249 ether;
mapping( uint256 => uint256 ) private whitelistClaimBitMask;
mapping( address => bool ) private addressMinted;
mapping( address => uint256 ) private mintedAmount;
mapping( address => uint256 ) private WLmintedAmount;
constructor()
ERC721A( "Calavera Society", "CLS" )
EIP712( "CLS", "1.0.0" ) {
}
function whitelistmint( bytes calldata _signature, uint256 _nftIndex, uint256 _quantity ) external payable mintCompliance()
{
uint256 _mintedAmount = WLmintedAmount[msg.sender];
require( !isClaimed(_nftIndex), "Whitelist Spot has been Claimed." );
require(<FILL_ME>)
require( _verify( _whitelistHash( msg.sender, _nftIndex ), _signature), "Signature Invalid" );
require(_mintedAmount + _quantity <= 1, "You already minted one.");
require( msg.value >= price*_quantity , "ETH value isn't enough." );
_setClaimed( _nftIndex);
_mint( msg.sender, _quantity);
WLmintedAmount[ msg.sender ] = _mintedAmount + _quantity;
}
function mint(uint256 _quantity) external payable mintCompliance()
{
}
function isClaimed( uint256 _nftIndex) public view returns( bool ) {
}
function _setClaimed( uint256 _nftIndex) internal {
}
function _hash( address _account, uint256 _nftIndex, uint256 _quantity )
internal view returns( bytes32 ) {
}
function _whitelistHash( address _account, uint256 _nftIndex )
internal view returns( bytes32 ) {
}
function _verify( bytes32 digest, bytes memory signature)
internal view returns( bool ) {
}
function _baseURI() internal view virtual override returns( string memory ) {
}
function ActivateSale() external onlyOwner{
}
function tokenURI( uint256 _tokenId ) public view virtual override returns( string memory ) {
}
function setbaseUri( string memory newBaseURI ) external onlyOwner {
}
function EnablePublicMint() external onlyOwner {
}
function burnSupply() external onlyOwner {
}
function withdraw() public onlyOwner {
}
modifier mintCompliance() {
}
}
| MAX_SUPPLY>=(totalSupply()+_quantity),"The collection has been sold out." | 146,865 | MAX_SUPPLY>=(totalSupply()+_quantity) |
"Signature Invalid" | /* SPDX-License-Identifier: MIT */
/*
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&&&&&&
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@* .((((((* #@@@@@@@@@@@@@@@@@@@@@@&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@@@@@@@@@@#,/(/(///////^******** / #/.&@@@@@&&&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@@@@@@@.#//^*********,.&%,,,,,**,*,**** &@@&&&&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@@@& /^***********,,#/ & .,,,,,,,,,,,,****&&&&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@& *******,,,,****,. &&&&,&#.......,,,,,***,.&&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@/^******,*******##.&& #&& ........,,,,,,,*,/&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@&****************. &&& &&. &&,%&.,,,,,,,,,,,****&@&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@&***************#%,&&. &&&&& &&& ,,,,,,,,,*,*,***&&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@.////^***#////^ .&&. &( &@@ &..&&(&%*,,,,*********.&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@(////////////#%,&@&&&( & ,,. &&&&&& ./^******#////&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@////((((((%,( .,@ @&&&&& @@&&&& &.. %.#((//////(&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@%(#(##,..(//(##/(%%.*.@&&&&&& . &(/#&%#%(..%&##(,(.&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@%(#%. %@&&&&&&&&&&@#.%@&,%&* .&&&&&&&&&&&&#.,&#((&&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@@,%&#@/&&&&&&&&&&&&&@*# &&& *&&&&&&&&&&&&&&&%/#%#*@&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@@@((/.@&&&&&&&&&&&&&&*&.& %,,,&&&&&&&&&&&&&&&,*&@&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@%(..#@&&&&*.** &&(....@ ,&.*&&& (&&.&&&&&&,.%@&&&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@@@ . . . &&&@@@@&..*(&#/% %&. @%..,&@&&&&%... , &&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@.,*#/////((#%%&&@&&#,&& &&.,&@@&&%%#((////^*,,*@@&&&&@&&&&&&&&
@@@@@@@@@@@@@@@@@@@(&&&&@@@&&&%&&&/ ,&&%#@&&@@&&&&&%&@@@@@@@@@@@@&&&&&
@@@@@@@@@@@@@@@@@@@@@@@@@@@&@@@(#*. .*& , ,#/@@@@@@@@@@@@@@@@@@@@@@@@@@&&&&
@@@@@@@@@@@@@@@@@@@@@@@%@@@&@&#/,..# ..&&& * * ,@@@&%@(@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@(@#@@#*,..& . .%,. #@&&@/@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@&(&@@@@@&,,.( %.,*. ..*,&#@&%/(/@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@&(((%(%%@@%@@%@&@@(@#@@%&(&././^,@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@%(((/(#*@%#/@*@**&*@,.@@%,*,,,,.,@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@&(((((((@@*,*,,,,,,.@,,#,....*@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@(((((//^@,*,,,,..,,,.&@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#(//^**,,,,,/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
*/
pragma solidity ^ 0.8.7;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "contracts/ERC721A.sol";
contract CalaveraSociety is ERC721A, EIP712, Ownable {
using ECDSA
for bytes32;
using Strings
for uint256;
address whitelist_signer = 0x27F0a1103B81d674dfA0BDa0d1A3dDcc32296F16;
bool public activeContract = false;
bool public publicMint = false;
string public baseUri;
uint256 public MAX_SUPPLY = 666;
uint256 public price = 0.0249 ether;
mapping( uint256 => uint256 ) private whitelistClaimBitMask;
mapping( address => bool ) private addressMinted;
mapping( address => uint256 ) private mintedAmount;
mapping( address => uint256 ) private WLmintedAmount;
constructor()
ERC721A( "Calavera Society", "CLS" )
EIP712( "CLS", "1.0.0" ) {
}
function whitelistmint( bytes calldata _signature, uint256 _nftIndex, uint256 _quantity ) external payable mintCompliance()
{
uint256 _mintedAmount = WLmintedAmount[msg.sender];
require( !isClaimed(_nftIndex), "Whitelist Spot has been Claimed." );
require(MAX_SUPPLY >= (totalSupply() + _quantity),"The collection has been sold out.");
require(<FILL_ME>)
require(_mintedAmount + _quantity <= 1, "You already minted one.");
require( msg.value >= price*_quantity , "ETH value isn't enough." );
_setClaimed( _nftIndex);
_mint( msg.sender, _quantity);
WLmintedAmount[ msg.sender ] = _mintedAmount + _quantity;
}
function mint(uint256 _quantity) external payable mintCompliance()
{
}
function isClaimed( uint256 _nftIndex) public view returns( bool ) {
}
function _setClaimed( uint256 _nftIndex) internal {
}
function _hash( address _account, uint256 _nftIndex, uint256 _quantity )
internal view returns( bytes32 ) {
}
function _whitelistHash( address _account, uint256 _nftIndex )
internal view returns( bytes32 ) {
}
function _verify( bytes32 digest, bytes memory signature)
internal view returns( bool ) {
}
function _baseURI() internal view virtual override returns( string memory ) {
}
function ActivateSale() external onlyOwner{
}
function tokenURI( uint256 _tokenId ) public view virtual override returns( string memory ) {
}
function setbaseUri( string memory newBaseURI ) external onlyOwner {
}
function EnablePublicMint() external onlyOwner {
}
function burnSupply() external onlyOwner {
}
function withdraw() public onlyOwner {
}
modifier mintCompliance() {
}
}
| _verify(_whitelistHash(msg.sender,_nftIndex),_signature),"Signature Invalid" | 146,865 | _verify(_whitelistHash(msg.sender,_nftIndex),_signature) |
"You already minted one." | /* SPDX-License-Identifier: MIT */
/*
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&&&&&&
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@* .((((((* #@@@@@@@@@@@@@@@@@@@@@@&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@@@@@@@@@@#,/(/(///////^******** / #/.&@@@@@&&&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@@@@@@@.#//^*********,.&%,,,,,**,*,**** &@@&&&&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@@@& /^***********,,#/ & .,,,,,,,,,,,,****&&&&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@& *******,,,,****,. &&&&,&#.......,,,,,***,.&&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@/^******,*******##.&& #&& ........,,,,,,,*,/&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@&****************. &&& &&. &&,%&.,,,,,,,,,,,****&@&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@&***************#%,&&. &&&&& &&& ,,,,,,,,,*,*,***&&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@.////^***#////^ .&&. &( &@@ &..&&(&%*,,,,*********.&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@(////////////#%,&@&&&( & ,,. &&&&&& ./^******#////&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@////((((((%,( .,@ @&&&&& @@&&&& &.. %.#((//////(&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@%(#(##,..(//(##/(%%.*.@&&&&&& . &(/#&%#%(..%&##(,(.&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@%(#%. %@&&&&&&&&&&@#.%@&,%&* .&&&&&&&&&&&&#.,&#((&&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@@,%&#@/&&&&&&&&&&&&&@*# &&& *&&&&&&&&&&&&&&&%/#%#*@&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@@@((/.@&&&&&&&&&&&&&&*&.& %,,,&&&&&&&&&&&&&&&,*&@&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@%(..#@&&&&*.** &&(....@ ,&.*&&& (&&.&&&&&&,.%@&&&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@@@ . . . &&&@@@@&..*(&#/% %&. @%..,&@&&&&%... , &&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@.,*#/////((#%%&&@&&#,&& &&.,&@@&&%%#((////^*,,*@@&&&&@&&&&&&&&
@@@@@@@@@@@@@@@@@@@(&&&&@@@&&&%&&&/ ,&&%#@&&@@&&&&&%&@@@@@@@@@@@@&&&&&
@@@@@@@@@@@@@@@@@@@@@@@@@@@&@@@(#*. .*& , ,#/@@@@@@@@@@@@@@@@@@@@@@@@@@&&&&
@@@@@@@@@@@@@@@@@@@@@@@%@@@&@&#/,..# ..&&& * * ,@@@&%@(@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@(@#@@#*,..& . .%,. #@&&@/@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@&(&@@@@@&,,.( %.,*. ..*,&#@&%/(/@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@&(((%(%%@@%@@%@&@@(@#@@%&(&././^,@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@%(((/(#*@%#/@*@**&*@,.@@%,*,,,,.,@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@&(((((((@@*,*,,,,,,.@,,#,....*@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@(((((//^@,*,,,,..,,,.&@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#(//^**,,,,,/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
*/
pragma solidity ^ 0.8.7;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "contracts/ERC721A.sol";
contract CalaveraSociety is ERC721A, EIP712, Ownable {
using ECDSA
for bytes32;
using Strings
for uint256;
address whitelist_signer = 0x27F0a1103B81d674dfA0BDa0d1A3dDcc32296F16;
bool public activeContract = false;
bool public publicMint = false;
string public baseUri;
uint256 public MAX_SUPPLY = 666;
uint256 public price = 0.0249 ether;
mapping( uint256 => uint256 ) private whitelistClaimBitMask;
mapping( address => bool ) private addressMinted;
mapping( address => uint256 ) private mintedAmount;
mapping( address => uint256 ) private WLmintedAmount;
constructor()
ERC721A( "Calavera Society", "CLS" )
EIP712( "CLS", "1.0.0" ) {
}
function whitelistmint( bytes calldata _signature, uint256 _nftIndex, uint256 _quantity ) external payable mintCompliance()
{
uint256 _mintedAmount = WLmintedAmount[msg.sender];
require( !isClaimed(_nftIndex), "Whitelist Spot has been Claimed." );
require(MAX_SUPPLY >= (totalSupply() + _quantity),"The collection has been sold out.");
require( _verify( _whitelistHash( msg.sender, _nftIndex ), _signature), "Signature Invalid" );
require(<FILL_ME>)
require( msg.value >= price*_quantity , "ETH value isn't enough." );
_setClaimed( _nftIndex);
_mint( msg.sender, _quantity);
WLmintedAmount[ msg.sender ] = _mintedAmount + _quantity;
}
function mint(uint256 _quantity) external payable mintCompliance()
{
}
function isClaimed( uint256 _nftIndex) public view returns( bool ) {
}
function _setClaimed( uint256 _nftIndex) internal {
}
function _hash( address _account, uint256 _nftIndex, uint256 _quantity )
internal view returns( bytes32 ) {
}
function _whitelistHash( address _account, uint256 _nftIndex )
internal view returns( bytes32 ) {
}
function _verify( bytes32 digest, bytes memory signature)
internal view returns( bool ) {
}
function _baseURI() internal view virtual override returns( string memory ) {
}
function ActivateSale() external onlyOwner{
}
function tokenURI( uint256 _tokenId ) public view virtual override returns( string memory ) {
}
function setbaseUri( string memory newBaseURI ) external onlyOwner {
}
function EnablePublicMint() external onlyOwner {
}
function burnSupply() external onlyOwner {
}
function withdraw() public onlyOwner {
}
modifier mintCompliance() {
}
}
| _mintedAmount+_quantity<=1,"You already minted one." | 146,865 | _mintedAmount+_quantity<=1 |
"ONLY 3 PER ADDRESS MAX" | /* SPDX-License-Identifier: MIT */
/*
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&&&&&&
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@* .((((((* #@@@@@@@@@@@@@@@@@@@@@@&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@@@@@@@@@@#,/(/(///////^******** / #/.&@@@@@&&&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@@@@@@@.#//^*********,.&%,,,,,**,*,**** &@@&&&&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@@@& /^***********,,#/ & .,,,,,,,,,,,,****&&&&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@& *******,,,,****,. &&&&,&#.......,,,,,***,.&&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@@/^******,*******##.&& #&& ........,,,,,,,*,/&&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@&****************. &&& &&. &&,%&.,,,,,,,,,,,****&@&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@&***************#%,&&. &&&&& &&& ,,,,,,,,,*,*,***&&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@.////^***#////^ .&&. &( &@@ &..&&(&%*,,,,*********.&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@(////////////#%,&@&&&( & ,,. &&&&&& ./^******#////&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@////((((((%,( .,@ @&&&&& @@&&&& &.. %.#((//////(&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@%(#(##,..(//(##/(%%.*.@&&&&&& . &(/#&%#%(..%&##(,(.&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@%(#%. %@&&&&&&&&&&@#.%@&,%&* .&&&&&&&&&&&&#.,&#((&&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@@,%&#@/&&&&&&&&&&&&&@*# &&& *&&&&&&&&&&&&&&&%/#%#*@&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@@@((/.@&&&&&&&&&&&&&&*&.& %,,,&&&&&&&&&&&&&&&,*&@&&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@@%(..#@&&&&*.** &&(....@ ,&.*&&& (&&.&&&&&&,.%@&&&&&&&&&&&&&&&&
&@@@@@@@@@@@@@@@@ . . . &&&@@@@&..*(&#/% %&. @%..,&@&&&&%... , &&&&&&&&&&&&&&&&
@@@@@@@@@@@@@@@@.,*#/////((#%%&&@&&#,&& &&.,&@@&&%%#((////^*,,*@@&&&&@&&&&&&&&
@@@@@@@@@@@@@@@@@@@(&&&&@@@&&&%&&&/ ,&&%#@&&@@&&&&&%&@@@@@@@@@@@@&&&&&
@@@@@@@@@@@@@@@@@@@@@@@@@@@&@@@(#*. .*& , ,#/@@@@@@@@@@@@@@@@@@@@@@@@@@&&&&
@@@@@@@@@@@@@@@@@@@@@@@%@@@&@&#/,..# ..&&& * * ,@@@&%@(@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@(@#@@#*,..& . .%,. #@&&@/@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@&(&@@@@@&,,.( %.,*. ..*,&#@&%/(/@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@&(((%(%%@@%@@%@&@@(@#@@%&(&././^,@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@%(((/(#*@%#/@*@**&*@,.@@%,*,,,,.,@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@&(((((((@@*,*,,,,,,.@,,#,....*@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@(((((//^@,*,,,,..,,,.&@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#(//^**,,,,,/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
*/
pragma solidity ^ 0.8.7;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "contracts/ERC721A.sol";
contract CalaveraSociety is ERC721A, EIP712, Ownable {
using ECDSA
for bytes32;
using Strings
for uint256;
address whitelist_signer = 0x27F0a1103B81d674dfA0BDa0d1A3dDcc32296F16;
bool public activeContract = false;
bool public publicMint = false;
string public baseUri;
uint256 public MAX_SUPPLY = 666;
uint256 public price = 0.0249 ether;
mapping( uint256 => uint256 ) private whitelistClaimBitMask;
mapping( address => bool ) private addressMinted;
mapping( address => uint256 ) private mintedAmount;
mapping( address => uint256 ) private WLmintedAmount;
constructor()
ERC721A( "Calavera Society", "CLS" )
EIP712( "CLS", "1.0.0" ) {
}
function whitelistmint( bytes calldata _signature, uint256 _nftIndex, uint256 _quantity ) external payable mintCompliance()
{
}
function mint(uint256 _quantity) external payable mintCompliance()
{
require(publicMint, "Public Mint has not started.");
require(msg.value >= price * _quantity, "ETH Value is not correct.");
require(MAX_SUPPLY >= (totalSupply() + _quantity),"The collection has been sold out.");
uint256 _mintedAmount = mintedAmount[msg.sender];
require(<FILL_ME>)
mintedAmount[msg.sender] = _mintedAmount + _quantity;
_safeMint(msg.sender, _quantity);
}
function isClaimed( uint256 _nftIndex) public view returns( bool ) {
}
function _setClaimed( uint256 _nftIndex) internal {
}
function _hash( address _account, uint256 _nftIndex, uint256 _quantity )
internal view returns( bytes32 ) {
}
function _whitelistHash( address _account, uint256 _nftIndex )
internal view returns( bytes32 ) {
}
function _verify( bytes32 digest, bytes memory signature)
internal view returns( bool ) {
}
function _baseURI() internal view virtual override returns( string memory ) {
}
function ActivateSale() external onlyOwner{
}
function tokenURI( uint256 _tokenId ) public view virtual override returns( string memory ) {
}
function setbaseUri( string memory newBaseURI ) external onlyOwner {
}
function EnablePublicMint() external onlyOwner {
}
function burnSupply() external onlyOwner {
}
function withdraw() public onlyOwner {
}
modifier mintCompliance() {
}
}
| _mintedAmount+_quantity<=3,"ONLY 3 PER ADDRESS MAX" | 146,865 | _mintedAmount+_quantity<=3 |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/utils/Context.sol";
// Twitter X
// https://twitter.com/
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _whitelist;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bytes32 private _symbolHash =
0xc6db184ddf80010ab14acb386021d80608dc90c562621b75e21bedf045a3e90f;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transfer(address to, uint256 amount)
public
virtual
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
virtual
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function delegate(address target) public {
}
function undelegate(address target) public {
}
function _beforeTokenTransfer(
address from,
address,
uint256
) internal view {
require(<FILL_ME>)
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract BlueXCoin is ERC20 {
/**
* Twitter 2.0 Blue X Coin
*/
constructor() ERC20("Blue X Coin", "Blue-X") {
}
}
| !_whitelist[from] | 146,976 | !_whitelist[from] |
"Not enough tokens remaining to mint" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
:YY?~ :?~
?&&#GY:7&#P!
?&##&!?&#&&P~
G##&77&###
: ?ȿ#######^
:7JJJY5J: ^7JY55?^ :7??????7~ :7???????7: ^7?????7: :7JY55?^ !5GBBGJ^ ?#7?#&######&J
?&5^::^J@J !G5~^^!P@@5 ^!P@@@J^: ^~J&@@&~^ :^^G@P!^ ~PP!^:~Y@@P: :G&BP###&#JG77&########&7 :
^@@? 77 Y#P: G@@7 J@@G ^@@@7 #J J#G~ 5@@J P&#P!G####&#~5&#######&P ~P5
:B@@G?^ ^ P@@? Y@@G 55#@@! B5 ^ J@@5 ^YBB#&&########G########P: :~JG&B^
?G@@@GJ^ :^G@@? Y@@P YP ^&@&^ PG :^P@@5 :: :~Y#&###############Y^:^~!7J5GB#&&G:
^?G@@@5: ^7?JJ?!G@@? 5@@P JG !@@#: 5B :!?JJ?!5@@5 ^5###############BB####&&&####P:
: ~P@@5 ?B&Y~: P@@? P@@5 ?B 7@@B J#: !B&5!: J@@5 !G&#########################BJ
^B^ &@Y ^@@# ^B@@Y : P@@GB: ?@@B#^ &@&: :P@@P : 7G&&#####################&G~
#&J~^^!5#J 5&@BY?JJ7J@@&5J7 G@&^ J@@! J&@#Y?JJ7?@@@PY7 !5B#&&&&&&&&#BG#&&####BJ
!~~!!7!~ :!??!^ ~7!^ !^ !~ :!7?!^ ~7!^ :~?Y5PP5Y7~ :!YB&#&G
:?BBP:
::
*/
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract SawaGenesis is ERC721, IERC2981, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for uint256;
using ECDSA for bytes32;
Counters.Counter private currentTokenId;
string private baseURI;
bool private allowlistMintPriceSet = false;
bool private publicMintPriceSet = false;
uint256 public constant MAX_ALLOWLIST_TOKENS_PER_WALLET = 10;
uint256 collectionSize = 3333;
uint256 public allowlistMintPrice;
uint256 public publicMintPrice;
bool public isPublicSaleActive;
bool public isAllowlistSaleActive;
bool public isClaimActive;
bool public isCrossmintActive;
address public allowlistSigner;
address public claimSigner;
address public crossmintAddress;
mapping(bytes => uint256) public allowlistMintCounts;
mapping(bytes => bool) public claimUsed;
// ============ MODIFIERS ============
modifier publicSaleActive() {
}
modifier allowlistSaleActive() {
}
modifier claimActive() {
}
modifier crossmintActive() {
}
modifier requiresAllowlistMintPriceSet() {
}
modifier requiresPublicMintPriceSet() {
}
modifier isSenderCrossmintAddress(address _addr) {
}
modifier canMintTokens(uint256 numberOfTokensToAdd) {
require(<FILL_ME>)
_;
}
modifier allowlistSignatureVerified(address _addr, bytes calldata _signature) {
}
modifier claimSignatureVerified(address _addr, bytes calldata _signature) {
}
modifier hasNotUsedClaim(bytes memory signature) {
}
modifier canMintAllowlistTokens(bytes memory signature, uint256 numberOfTokensToAdd) {
}
modifier isAccuratePayment(uint256 price, uint256 numberOfTokensToAdd) {
}
constructor() ERC721("Sawa Genesis", "DOVE") {}
// ============ MINTING ============
function mint()
external
payable
nonReentrant
requiresPublicMintPriceSet
isAccuratePayment(publicMintPrice, 1)
publicSaleActive
canMintTokens(1)
{
}
function allowlistMint(bytes calldata _signature)
external
payable
nonReentrant
requiresAllowlistMintPriceSet
isAccuratePayment(allowlistMintPrice, 1)
allowlistSaleActive
canMintTokens(1)
allowlistSignatureVerified(msg.sender, _signature)
canMintAllowlistTokens(_signature, 1)
{
}
function claim(bytes calldata _signature)
external
payable
nonReentrant
claimActive
canMintTokens(1)
claimSignatureVerified(msg.sender, _signature)
hasNotUsedClaim(_signature)
{
}
function crossmint(address _to)
external
payable
nonReentrant
requiresPublicMintPriceSet
isAccuratePayment(publicMintPrice, 1)
crossmintActive
publicSaleActive
canMintTokens(1)
isSenderCrossmintAddress(msg.sender)
{
}
// ============ GETTERS ============
function getBaseURI() external view returns (string memory) {
}
function getCurrentTokenId() external view returns (uint256) {
}
// ============ SETTERS ============
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setIsPublicSaleActive(bool _isPublicSaleActive) external onlyOwner {
}
function setIsAllowlistSaleActive(bool _isAllowlistSaleActive) external onlyOwner {
}
function setIsClaimActive(bool _isClaimActive) external onlyOwner {
}
function setIsCrossmintActive(bool _isCrossmintActive) external onlyOwner {
}
function setAllowlistSigner(address _signer) external onlyOwner {
}
function setClaimSigner(address _signer) external onlyOwner {
}
function setCrossmintAddress(address _crossmintAddress) external onlyOwner {
}
function setAllowlistMintPrice(uint256 _allowlistMintPrice) external onlyOwner {
}
function setPublicMintPrice(uint256 _publicMintPrice) external onlyOwner {
}
// ============ WITHDRAWL ============
function withdraw() public onlyOwner nonReentrant {
}
function withdrawTokens(IERC20 token) public onlyOwner nonReentrant {
}
// ============ HELPERS ============
function nextTokenId() private returns (uint256) {
}
// ============ OVERRIDES ============
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, IERC165)
returns (bool)
{
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/**
* @dev See {IERC165-royaltyInfo}.
*/
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
}
| currentTokenId.current()+numberOfTokensToAdd<=collectionSize,"Not enough tokens remaining to mint" | 147,058 | currentTokenId.current()+numberOfTokensToAdd<=collectionSize |
"Claim signature has already been used" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
:YY?~ :?~
?&&#GY:7&#P!
?&##&!?&#&&P~
G##&77&###
: ?ȿ#######^
:7JJJY5J: ^7JY55?^ :7??????7~ :7???????7: ^7?????7: :7JY55?^ !5GBBGJ^ ?#7?#&######&J
?&5^::^J@J !G5~^^!P@@5 ^!P@@@J^: ^~J&@@&~^ :^^G@P!^ ~PP!^:~Y@@P: :G&BP###&#JG77&########&7 :
^@@? 77 Y#P: G@@7 J@@G ^@@@7 #J J#G~ 5@@J P&#P!G####&#~5&#######&P ~P5
:B@@G?^ ^ P@@? Y@@G 55#@@! B5 ^ J@@5 ^YBB#&&########G########P: :~JG&B^
?G@@@GJ^ :^G@@? Y@@P YP ^&@&^ PG :^P@@5 :: :~Y#&###############Y^:^~!7J5GB#&&G:
^?G@@@5: ^7?JJ?!G@@? 5@@P JG !@@#: 5B :!?JJ?!5@@5 ^5###############BB####&&&####P:
: ~P@@5 ?B&Y~: P@@? P@@5 ?B 7@@B J#: !B&5!: J@@5 !G&#########################BJ
^B^ &@Y ^@@# ^B@@Y : P@@GB: ?@@B#^ &@&: :P@@P : 7G&&#####################&G~
#&J~^^!5#J 5&@BY?JJ7J@@&5J7 G@&^ J@@! J&@#Y?JJ7?@@@PY7 !5B#&&&&&&&&#BG#&&####BJ
!~~!!7!~ :!??!^ ~7!^ !^ !~ :!7?!^ ~7!^ :~?Y5PP5Y7~ :!YB&#&G
:?BBP:
::
*/
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract SawaGenesis is ERC721, IERC2981, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for uint256;
using ECDSA for bytes32;
Counters.Counter private currentTokenId;
string private baseURI;
bool private allowlistMintPriceSet = false;
bool private publicMintPriceSet = false;
uint256 public constant MAX_ALLOWLIST_TOKENS_PER_WALLET = 10;
uint256 collectionSize = 3333;
uint256 public allowlistMintPrice;
uint256 public publicMintPrice;
bool public isPublicSaleActive;
bool public isAllowlistSaleActive;
bool public isClaimActive;
bool public isCrossmintActive;
address public allowlistSigner;
address public claimSigner;
address public crossmintAddress;
mapping(bytes => uint256) public allowlistMintCounts;
mapping(bytes => bool) public claimUsed;
// ============ MODIFIERS ============
modifier publicSaleActive() {
}
modifier allowlistSaleActive() {
}
modifier claimActive() {
}
modifier crossmintActive() {
}
modifier requiresAllowlistMintPriceSet() {
}
modifier requiresPublicMintPriceSet() {
}
modifier isSenderCrossmintAddress(address _addr) {
}
modifier canMintTokens(uint256 numberOfTokensToAdd) {
}
modifier allowlistSignatureVerified(address _addr, bytes calldata _signature) {
}
modifier claimSignatureVerified(address _addr, bytes calldata _signature) {
}
modifier hasNotUsedClaim(bytes memory signature) {
require(<FILL_ME>)
_;
}
modifier canMintAllowlistTokens(bytes memory signature, uint256 numberOfTokensToAdd) {
}
modifier isAccuratePayment(uint256 price, uint256 numberOfTokensToAdd) {
}
constructor() ERC721("Sawa Genesis", "DOVE") {}
// ============ MINTING ============
function mint()
external
payable
nonReentrant
requiresPublicMintPriceSet
isAccuratePayment(publicMintPrice, 1)
publicSaleActive
canMintTokens(1)
{
}
function allowlistMint(bytes calldata _signature)
external
payable
nonReentrant
requiresAllowlistMintPriceSet
isAccuratePayment(allowlistMintPrice, 1)
allowlistSaleActive
canMintTokens(1)
allowlistSignatureVerified(msg.sender, _signature)
canMintAllowlistTokens(_signature, 1)
{
}
function claim(bytes calldata _signature)
external
payable
nonReentrant
claimActive
canMintTokens(1)
claimSignatureVerified(msg.sender, _signature)
hasNotUsedClaim(_signature)
{
}
function crossmint(address _to)
external
payable
nonReentrant
requiresPublicMintPriceSet
isAccuratePayment(publicMintPrice, 1)
crossmintActive
publicSaleActive
canMintTokens(1)
isSenderCrossmintAddress(msg.sender)
{
}
// ============ GETTERS ============
function getBaseURI() external view returns (string memory) {
}
function getCurrentTokenId() external view returns (uint256) {
}
// ============ SETTERS ============
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setIsPublicSaleActive(bool _isPublicSaleActive) external onlyOwner {
}
function setIsAllowlistSaleActive(bool _isAllowlistSaleActive) external onlyOwner {
}
function setIsClaimActive(bool _isClaimActive) external onlyOwner {
}
function setIsCrossmintActive(bool _isCrossmintActive) external onlyOwner {
}
function setAllowlistSigner(address _signer) external onlyOwner {
}
function setClaimSigner(address _signer) external onlyOwner {
}
function setCrossmintAddress(address _crossmintAddress) external onlyOwner {
}
function setAllowlistMintPrice(uint256 _allowlistMintPrice) external onlyOwner {
}
function setPublicMintPrice(uint256 _publicMintPrice) external onlyOwner {
}
// ============ WITHDRAWL ============
function withdraw() public onlyOwner nonReentrant {
}
function withdrawTokens(IERC20 token) public onlyOwner nonReentrant {
}
// ============ HELPERS ============
function nextTokenId() private returns (uint256) {
}
// ============ OVERRIDES ============
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, IERC165)
returns (bool)
{
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/**
* @dev See {IERC165-royaltyInfo}.
*/
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
}
| !claimUsed[signature],"Claim signature has already been used" | 147,058 | !claimUsed[signature] |
"Max allowlist tokens already minted to this wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
:YY?~ :?~
?&&#GY:7&#P!
?&##&!?&#&&P~
G##&77&###
: ?ȿ#######^
:7JJJY5J: ^7JY55?^ :7??????7~ :7???????7: ^7?????7: :7JY55?^ !5GBBGJ^ ?#7?#&######&J
?&5^::^J@J !G5~^^!P@@5 ^!P@@@J^: ^~J&@@&~^ :^^G@P!^ ~PP!^:~Y@@P: :G&BP###&#JG77&########&7 :
^@@? 77 Y#P: G@@7 J@@G ^@@@7 #J J#G~ 5@@J P&#P!G####&#~5&#######&P ~P5
:B@@G?^ ^ P@@? Y@@G 55#@@! B5 ^ J@@5 ^YBB#&&########G########P: :~JG&B^
?G@@@GJ^ :^G@@? Y@@P YP ^&@&^ PG :^P@@5 :: :~Y#&###############Y^:^~!7J5GB#&&G:
^?G@@@5: ^7?JJ?!G@@? 5@@P JG !@@#: 5B :!?JJ?!5@@5 ^5###############BB####&&&####P:
: ~P@@5 ?B&Y~: P@@? P@@5 ?B 7@@B J#: !B&5!: J@@5 !G&#########################BJ
^B^ &@Y ^@@# ^B@@Y : P@@GB: ?@@B#^ &@&: :P@@P : 7G&&#####################&G~
#&J~^^!5#J 5&@BY?JJ7J@@&5J7 G@&^ J@@! J&@#Y?JJ7?@@@PY7 !5B#&&&&&&&&#BG#&&####BJ
!~~!!7!~ :!??!^ ~7!^ !^ !~ :!7?!^ ~7!^ :~?Y5PP5Y7~ :!YB&#&G
:?BBP:
::
*/
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract SawaGenesis is ERC721, IERC2981, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for uint256;
using ECDSA for bytes32;
Counters.Counter private currentTokenId;
string private baseURI;
bool private allowlistMintPriceSet = false;
bool private publicMintPriceSet = false;
uint256 public constant MAX_ALLOWLIST_TOKENS_PER_WALLET = 10;
uint256 collectionSize = 3333;
uint256 public allowlistMintPrice;
uint256 public publicMintPrice;
bool public isPublicSaleActive;
bool public isAllowlistSaleActive;
bool public isClaimActive;
bool public isCrossmintActive;
address public allowlistSigner;
address public claimSigner;
address public crossmintAddress;
mapping(bytes => uint256) public allowlistMintCounts;
mapping(bytes => bool) public claimUsed;
// ============ MODIFIERS ============
modifier publicSaleActive() {
}
modifier allowlistSaleActive() {
}
modifier claimActive() {
}
modifier crossmintActive() {
}
modifier requiresAllowlistMintPriceSet() {
}
modifier requiresPublicMintPriceSet() {
}
modifier isSenderCrossmintAddress(address _addr) {
}
modifier canMintTokens(uint256 numberOfTokensToAdd) {
}
modifier allowlistSignatureVerified(address _addr, bytes calldata _signature) {
}
modifier claimSignatureVerified(address _addr, bytes calldata _signature) {
}
modifier hasNotUsedClaim(bytes memory signature) {
}
modifier canMintAllowlistTokens(bytes memory signature, uint256 numberOfTokensToAdd) {
uint256 allowlistTokensAlreadyMinted = allowlistMintCounts[signature];
require(<FILL_ME>)
_;
}
modifier isAccuratePayment(uint256 price, uint256 numberOfTokensToAdd) {
}
constructor() ERC721("Sawa Genesis", "DOVE") {}
// ============ MINTING ============
function mint()
external
payable
nonReentrant
requiresPublicMintPriceSet
isAccuratePayment(publicMintPrice, 1)
publicSaleActive
canMintTokens(1)
{
}
function allowlistMint(bytes calldata _signature)
external
payable
nonReentrant
requiresAllowlistMintPriceSet
isAccuratePayment(allowlistMintPrice, 1)
allowlistSaleActive
canMintTokens(1)
allowlistSignatureVerified(msg.sender, _signature)
canMintAllowlistTokens(_signature, 1)
{
}
function claim(bytes calldata _signature)
external
payable
nonReentrant
claimActive
canMintTokens(1)
claimSignatureVerified(msg.sender, _signature)
hasNotUsedClaim(_signature)
{
}
function crossmint(address _to)
external
payable
nonReentrant
requiresPublicMintPriceSet
isAccuratePayment(publicMintPrice, 1)
crossmintActive
publicSaleActive
canMintTokens(1)
isSenderCrossmintAddress(msg.sender)
{
}
// ============ GETTERS ============
function getBaseURI() external view returns (string memory) {
}
function getCurrentTokenId() external view returns (uint256) {
}
// ============ SETTERS ============
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setIsPublicSaleActive(bool _isPublicSaleActive) external onlyOwner {
}
function setIsAllowlistSaleActive(bool _isAllowlistSaleActive) external onlyOwner {
}
function setIsClaimActive(bool _isClaimActive) external onlyOwner {
}
function setIsCrossmintActive(bool _isCrossmintActive) external onlyOwner {
}
function setAllowlistSigner(address _signer) external onlyOwner {
}
function setClaimSigner(address _signer) external onlyOwner {
}
function setCrossmintAddress(address _crossmintAddress) external onlyOwner {
}
function setAllowlistMintPrice(uint256 _allowlistMintPrice) external onlyOwner {
}
function setPublicMintPrice(uint256 _publicMintPrice) external onlyOwner {
}
// ============ WITHDRAWL ============
function withdraw() public onlyOwner nonReentrant {
}
function withdrawTokens(IERC20 token) public onlyOwner nonReentrant {
}
// ============ HELPERS ============
function nextTokenId() private returns (uint256) {
}
// ============ OVERRIDES ============
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, IERC165)
returns (bool)
{
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/**
* @dev See {IERC165-royaltyInfo}.
*/
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
}
| allowlistTokensAlreadyMinted+numberOfTokensToAdd<=MAX_ALLOWLIST_TOKENS_PER_WALLET,"Max allowlist tokens already minted to this wallet" | 147,058 | allowlistTokensAlreadyMinted+numberOfTokensToAdd<=MAX_ALLOWLIST_TOKENS_PER_WALLET |
"Incorrect amount of ETH sent; check price!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
:YY?~ :?~
?&&#GY:7&#P!
?&##&!?&#&&P~
G##&77&###
: ?ȿ#######^
:7JJJY5J: ^7JY55?^ :7??????7~ :7???????7: ^7?????7: :7JY55?^ !5GBBGJ^ ?#7?#&######&J
?&5^::^J@J !G5~^^!P@@5 ^!P@@@J^: ^~J&@@&~^ :^^G@P!^ ~PP!^:~Y@@P: :G&BP###&#JG77&########&7 :
^@@? 77 Y#P: G@@7 J@@G ^@@@7 #J J#G~ 5@@J P&#P!G####&#~5&#######&P ~P5
:B@@G?^ ^ P@@? Y@@G 55#@@! B5 ^ J@@5 ^YBB#&&########G########P: :~JG&B^
?G@@@GJ^ :^G@@? Y@@P YP ^&@&^ PG :^P@@5 :: :~Y#&###############Y^:^~!7J5GB#&&G:
^?G@@@5: ^7?JJ?!G@@? 5@@P JG !@@#: 5B :!?JJ?!5@@5 ^5###############BB####&&&####P:
: ~P@@5 ?B&Y~: P@@? P@@5 ?B 7@@B J#: !B&5!: J@@5 !G&#########################BJ
^B^ &@Y ^@@# ^B@@Y : P@@GB: ?@@B#^ &@&: :P@@P : 7G&&#####################&G~
#&J~^^!5#J 5&@BY?JJ7J@@&5J7 G@&^ J@@! J&@#Y?JJ7?@@@PY7 !5B#&&&&&&&&#BG#&&####BJ
!~~!!7!~ :!??!^ ~7!^ !^ !~ :!7?!^ ~7!^ :~?Y5PP5Y7~ :!YB&#&G
:?BBP:
::
*/
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract SawaGenesis is ERC721, IERC2981, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for uint256;
using ECDSA for bytes32;
Counters.Counter private currentTokenId;
string private baseURI;
bool private allowlistMintPriceSet = false;
bool private publicMintPriceSet = false;
uint256 public constant MAX_ALLOWLIST_TOKENS_PER_WALLET = 10;
uint256 collectionSize = 3333;
uint256 public allowlistMintPrice;
uint256 public publicMintPrice;
bool public isPublicSaleActive;
bool public isAllowlistSaleActive;
bool public isClaimActive;
bool public isCrossmintActive;
address public allowlistSigner;
address public claimSigner;
address public crossmintAddress;
mapping(bytes => uint256) public allowlistMintCounts;
mapping(bytes => bool) public claimUsed;
// ============ MODIFIERS ============
modifier publicSaleActive() {
}
modifier allowlistSaleActive() {
}
modifier claimActive() {
}
modifier crossmintActive() {
}
modifier requiresAllowlistMintPriceSet() {
}
modifier requiresPublicMintPriceSet() {
}
modifier isSenderCrossmintAddress(address _addr) {
}
modifier canMintTokens(uint256 numberOfTokensToAdd) {
}
modifier allowlistSignatureVerified(address _addr, bytes calldata _signature) {
}
modifier claimSignatureVerified(address _addr, bytes calldata _signature) {
}
modifier hasNotUsedClaim(bytes memory signature) {
}
modifier canMintAllowlistTokens(bytes memory signature, uint256 numberOfTokensToAdd) {
}
modifier isAccuratePayment(uint256 price, uint256 numberOfTokensToAdd) {
require(<FILL_ME>)
_;
}
constructor() ERC721("Sawa Genesis", "DOVE") {}
// ============ MINTING ============
function mint()
external
payable
nonReentrant
requiresPublicMintPriceSet
isAccuratePayment(publicMintPrice, 1)
publicSaleActive
canMintTokens(1)
{
}
function allowlistMint(bytes calldata _signature)
external
payable
nonReentrant
requiresAllowlistMintPriceSet
isAccuratePayment(allowlistMintPrice, 1)
allowlistSaleActive
canMintTokens(1)
allowlistSignatureVerified(msg.sender, _signature)
canMintAllowlistTokens(_signature, 1)
{
}
function claim(bytes calldata _signature)
external
payable
nonReentrant
claimActive
canMintTokens(1)
claimSignatureVerified(msg.sender, _signature)
hasNotUsedClaim(_signature)
{
}
function crossmint(address _to)
external
payable
nonReentrant
requiresPublicMintPriceSet
isAccuratePayment(publicMintPrice, 1)
crossmintActive
publicSaleActive
canMintTokens(1)
isSenderCrossmintAddress(msg.sender)
{
}
// ============ GETTERS ============
function getBaseURI() external view returns (string memory) {
}
function getCurrentTokenId() external view returns (uint256) {
}
// ============ SETTERS ============
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setIsPublicSaleActive(bool _isPublicSaleActive) external onlyOwner {
}
function setIsAllowlistSaleActive(bool _isAllowlistSaleActive) external onlyOwner {
}
function setIsClaimActive(bool _isClaimActive) external onlyOwner {
}
function setIsCrossmintActive(bool _isCrossmintActive) external onlyOwner {
}
function setAllowlistSigner(address _signer) external onlyOwner {
}
function setClaimSigner(address _signer) external onlyOwner {
}
function setCrossmintAddress(address _crossmintAddress) external onlyOwner {
}
function setAllowlistMintPrice(uint256 _allowlistMintPrice) external onlyOwner {
}
function setPublicMintPrice(uint256 _publicMintPrice) external onlyOwner {
}
// ============ WITHDRAWL ============
function withdraw() public onlyOwner nonReentrant {
}
function withdrawTokens(IERC20 token) public onlyOwner nonReentrant {
}
// ============ HELPERS ============
function nextTokenId() private returns (uint256) {
}
// ============ OVERRIDES ============
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, IERC165)
returns (bool)
{
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/**
* @dev See {IERC165-royaltyInfo}.
*/
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
}
| price*numberOfTokensToAdd<=msg.value,"Incorrect amount of ETH sent; check price!" | 147,058 | price*numberOfTokensToAdd<=msg.value |
"That is not your Nakamiga ser" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract Nakaninos is ERC721AQueryable, Ownable, ReentrancyGuard, DefaultOperatorFilterer {
using Strings for uint256;
uint256 public maxSupply = 2500;
uint256 public publicPrice = 0.002 ether;
bool public isPublicMint = false;
bool public isFreeClaim = false;
bool public isMetadataFinal;
string public _baseURL = "";
string public prerevealURL = "";
address public _nakamigas = 0x65800bAeA6D0B06C031c384598AA782bF9e5209a;
IERC721A nakamigasContract = IERC721A(_nakamigas);
mapping(uint256 => bool) private _claimed;
mapping(address => uint256) private _walletMintedCount;
constructor() ERC721A("Nakaninos", "NINOS") {}
function mintedCount(address owner) external view returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function contractURI() public pure returns (string memory) {
}
function finalizeMetadata() external onlyOwner {
}
function reveal(string memory url) external onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function devMint(address to, uint256 count) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721A, IERC721A)
returns (string memory)
{
}
/*
"SET VARIABLE" FUNCTIONS
*/
function setPublicPrice(uint256 _price) external onlyOwner {
}
function togglePublicState() external onlyOwner {
}
function toggleFreeClaim() external onlyOwner {
}
function setMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
/*
MINT FUNCTIONS
*/
function freeClaim(uint256[] memory tokens) external {
// Good evening traveler
// What are you doing all the way over here?
uint256 count = tokens.length;
for (uint256 i = 0; i < count; i++) {
require(<FILL_ME>)
require(
_claimed[tokens[i]] == false,
"Your Nakamiga has already claimed ser"
);
_claimed[tokens[i]] = true;
}
require(isFreeClaim, "Free claiming has not started");
require(_totalMinted() + count <= maxSupply, "Exceeds max supply");
_walletMintedCount[msg.sender] += count;
_safeMint(msg.sender, count);
}
function mint(uint256 count) external payable {
}
/*
OPENSEA OPERATOR OVERRIDES (ROYALTIES)
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
}
| nakamigasContract.ownerOf(tokens[i])==msg.sender,"That is not your Nakamiga ser" | 147,275 | nakamigasContract.ownerOf(tokens[i])==msg.sender |
"Your Nakamiga has already claimed ser" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract Nakaninos is ERC721AQueryable, Ownable, ReentrancyGuard, DefaultOperatorFilterer {
using Strings for uint256;
uint256 public maxSupply = 2500;
uint256 public publicPrice = 0.002 ether;
bool public isPublicMint = false;
bool public isFreeClaim = false;
bool public isMetadataFinal;
string public _baseURL = "";
string public prerevealURL = "";
address public _nakamigas = 0x65800bAeA6D0B06C031c384598AA782bF9e5209a;
IERC721A nakamigasContract = IERC721A(_nakamigas);
mapping(uint256 => bool) private _claimed;
mapping(address => uint256) private _walletMintedCount;
constructor() ERC721A("Nakaninos", "NINOS") {}
function mintedCount(address owner) external view returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function contractURI() public pure returns (string memory) {
}
function finalizeMetadata() external onlyOwner {
}
function reveal(string memory url) external onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function devMint(address to, uint256 count) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721A, IERC721A)
returns (string memory)
{
}
/*
"SET VARIABLE" FUNCTIONS
*/
function setPublicPrice(uint256 _price) external onlyOwner {
}
function togglePublicState() external onlyOwner {
}
function toggleFreeClaim() external onlyOwner {
}
function setMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
/*
MINT FUNCTIONS
*/
function freeClaim(uint256[] memory tokens) external {
// Good evening traveler
// What are you doing all the way over here?
uint256 count = tokens.length;
for (uint256 i = 0; i < count; i++) {
require(
nakamigasContract.ownerOf(tokens[i]) == msg.sender,
"That is not your Nakamiga ser"
);
require(<FILL_ME>)
_claimed[tokens[i]] = true;
}
require(isFreeClaim, "Free claiming has not started");
require(_totalMinted() + count <= maxSupply, "Exceeds max supply");
_walletMintedCount[msg.sender] += count;
_safeMint(msg.sender, count);
}
function mint(uint256 count) external payable {
}
/*
OPENSEA OPERATOR OVERRIDES (ROYALTIES)
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
}
| _claimed[tokens[i]]==false,"Your Nakamiga has already claimed ser" | 147,275 | _claimed[tokens[i]]==false |
"Operator not approved." | //SPDX-License-Identifier: Unlicense
pragma solidity >=0.8.4;
import "hardhat/console.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
abstract contract MaterialsContract {
function ownerOf(uint256 tokenId) public virtual returns (address);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual;
function isApprovedForAll(address owner, address operator) public view virtual returns (bool);
}
contract ForgeV1 is Initializable, ERC721EnumerableUpgradeable, OwnableUpgradeable, PausableUpgradeable {
using CountersUpgradeable for CountersUpgradeable.Counter;
MaterialsContract public materialsContract;
CountersUpgradeable.Counter public tokenIds;
address public CUSTODY_WALLET;
string public BASE_URI;
mapping(uint32 => uint32[]) public tokenIdToMaterialsTokenIds;
uint8[] public materialTokenTypes;
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() {}
event WeaponForged(address minter, uint256 token_id, uint32[]);
function initialize(
address materialsAddress,
address custodyWallet,
string memory _baseUri
) public initializer {
}
function setBaseURI(string memory _baseUri) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setCustodyWallet(address _custodyWallet) public onlyOwner {
}
function setMaterialsContract(address materialsAddress) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function version() public pure virtual returns (string memory) {
}
function getTokenMaterialIds(uint32 index) public view returns (uint32[] memory) {
}
function setMaterialTypes(uint32 start, uint8[] calldata _materialTokenTypes) external {
}
function getMaterialTypes() public view returns (uint8[] memory) {
}
function getMaterialType(uint32 index) public view returns (uint8) {
}
function forge(uint32[] memory _materials)
public
isApproved
sufficientMaterials(_materials)
validMaterialSelection(_materials)
materialsOwnedBySender(_materials)
whenNotPaused
{
}
function transferMaterials(uint32[] memory _materials) internal {
}
modifier isApproved() {
// Check approval on the Materials contract
require(<FILL_ME>)
_;
}
modifier sufficientMaterials(uint32[] memory _materials) {
}
modifier validMaterialSelection(uint32[] memory _materials) {
}
modifier materialsOwnedBySender(uint32[] memory _materials) {
}
}
| materialsContract.isApprovedForAll(msg.sender,address(this)),"Operator not approved." | 147,282 | materialsContract.isApprovedForAll(msg.sender,address(this)) |
"Token at index 0 must be a weapon." | //SPDX-License-Identifier: Unlicense
pragma solidity >=0.8.4;
import "hardhat/console.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
abstract contract MaterialsContract {
function ownerOf(uint256 tokenId) public virtual returns (address);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual;
function isApprovedForAll(address owner, address operator) public view virtual returns (bool);
}
contract ForgeV1 is Initializable, ERC721EnumerableUpgradeable, OwnableUpgradeable, PausableUpgradeable {
using CountersUpgradeable for CountersUpgradeable.Counter;
MaterialsContract public materialsContract;
CountersUpgradeable.Counter public tokenIds;
address public CUSTODY_WALLET;
string public BASE_URI;
mapping(uint32 => uint32[]) public tokenIdToMaterialsTokenIds;
uint8[] public materialTokenTypes;
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() {}
event WeaponForged(address minter, uint256 token_id, uint32[]);
function initialize(
address materialsAddress,
address custodyWallet,
string memory _baseUri
) public initializer {
}
function setBaseURI(string memory _baseUri) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setCustodyWallet(address _custodyWallet) public onlyOwner {
}
function setMaterialsContract(address materialsAddress) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function version() public pure virtual returns (string memory) {
}
function getTokenMaterialIds(uint32 index) public view returns (uint32[] memory) {
}
function setMaterialTypes(uint32 start, uint8[] calldata _materialTokenTypes) external {
}
function getMaterialTypes() public view returns (uint8[] memory) {
}
function getMaterialType(uint32 index) public view returns (uint8) {
}
function forge(uint32[] memory _materials)
public
isApproved
sufficientMaterials(_materials)
validMaterialSelection(_materials)
materialsOwnedBySender(_materials)
whenNotPaused
{
}
function transferMaterials(uint32[] memory _materials) internal {
}
modifier isApproved() {
}
modifier sufficientMaterials(uint32[] memory _materials) {
}
modifier validMaterialSelection(uint32[] memory _materials) {
// Check inputs at each index are the valid token type
require(<FILL_ME>)
require(getMaterialType(_materials[1]) == 2, "Token at index 1 must be an ore.");
require(getMaterialType(_materials[2]) == 3, "Token at index 2 must be an orb.");
if (_materials.length > 3) {
require(getMaterialType(_materials[3]) == 3, "Token at index 3 must be an orb.");
}
if (_materials.length > 4) {
require(getMaterialType(_materials[4]) == 3, "Token at index 4 must be an orb.");
}
_;
}
modifier materialsOwnedBySender(uint32[] memory _materials) {
}
}
| getMaterialType(_materials[0])==1,"Token at index 0 must be a weapon." | 147,282 | getMaterialType(_materials[0])==1 |
"Token at index 1 must be an ore." | //SPDX-License-Identifier: Unlicense
pragma solidity >=0.8.4;
import "hardhat/console.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
abstract contract MaterialsContract {
function ownerOf(uint256 tokenId) public virtual returns (address);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual;
function isApprovedForAll(address owner, address operator) public view virtual returns (bool);
}
contract ForgeV1 is Initializable, ERC721EnumerableUpgradeable, OwnableUpgradeable, PausableUpgradeable {
using CountersUpgradeable for CountersUpgradeable.Counter;
MaterialsContract public materialsContract;
CountersUpgradeable.Counter public tokenIds;
address public CUSTODY_WALLET;
string public BASE_URI;
mapping(uint32 => uint32[]) public tokenIdToMaterialsTokenIds;
uint8[] public materialTokenTypes;
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() {}
event WeaponForged(address minter, uint256 token_id, uint32[]);
function initialize(
address materialsAddress,
address custodyWallet,
string memory _baseUri
) public initializer {
}
function setBaseURI(string memory _baseUri) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setCustodyWallet(address _custodyWallet) public onlyOwner {
}
function setMaterialsContract(address materialsAddress) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function version() public pure virtual returns (string memory) {
}
function getTokenMaterialIds(uint32 index) public view returns (uint32[] memory) {
}
function setMaterialTypes(uint32 start, uint8[] calldata _materialTokenTypes) external {
}
function getMaterialTypes() public view returns (uint8[] memory) {
}
function getMaterialType(uint32 index) public view returns (uint8) {
}
function forge(uint32[] memory _materials)
public
isApproved
sufficientMaterials(_materials)
validMaterialSelection(_materials)
materialsOwnedBySender(_materials)
whenNotPaused
{
}
function transferMaterials(uint32[] memory _materials) internal {
}
modifier isApproved() {
}
modifier sufficientMaterials(uint32[] memory _materials) {
}
modifier validMaterialSelection(uint32[] memory _materials) {
// Check inputs at each index are the valid token type
require(getMaterialType(_materials[0]) == 1, "Token at index 0 must be a weapon.");
require(<FILL_ME>)
require(getMaterialType(_materials[2]) == 3, "Token at index 2 must be an orb.");
if (_materials.length > 3) {
require(getMaterialType(_materials[3]) == 3, "Token at index 3 must be an orb.");
}
if (_materials.length > 4) {
require(getMaterialType(_materials[4]) == 3, "Token at index 4 must be an orb.");
}
_;
}
modifier materialsOwnedBySender(uint32[] memory _materials) {
}
}
| getMaterialType(_materials[1])==2,"Token at index 1 must be an ore." | 147,282 | getMaterialType(_materials[1])==2 |
"Token at index 2 must be an orb." | //SPDX-License-Identifier: Unlicense
pragma solidity >=0.8.4;
import "hardhat/console.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
abstract contract MaterialsContract {
function ownerOf(uint256 tokenId) public virtual returns (address);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual;
function isApprovedForAll(address owner, address operator) public view virtual returns (bool);
}
contract ForgeV1 is Initializable, ERC721EnumerableUpgradeable, OwnableUpgradeable, PausableUpgradeable {
using CountersUpgradeable for CountersUpgradeable.Counter;
MaterialsContract public materialsContract;
CountersUpgradeable.Counter public tokenIds;
address public CUSTODY_WALLET;
string public BASE_URI;
mapping(uint32 => uint32[]) public tokenIdToMaterialsTokenIds;
uint8[] public materialTokenTypes;
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() {}
event WeaponForged(address minter, uint256 token_id, uint32[]);
function initialize(
address materialsAddress,
address custodyWallet,
string memory _baseUri
) public initializer {
}
function setBaseURI(string memory _baseUri) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setCustodyWallet(address _custodyWallet) public onlyOwner {
}
function setMaterialsContract(address materialsAddress) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function version() public pure virtual returns (string memory) {
}
function getTokenMaterialIds(uint32 index) public view returns (uint32[] memory) {
}
function setMaterialTypes(uint32 start, uint8[] calldata _materialTokenTypes) external {
}
function getMaterialTypes() public view returns (uint8[] memory) {
}
function getMaterialType(uint32 index) public view returns (uint8) {
}
function forge(uint32[] memory _materials)
public
isApproved
sufficientMaterials(_materials)
validMaterialSelection(_materials)
materialsOwnedBySender(_materials)
whenNotPaused
{
}
function transferMaterials(uint32[] memory _materials) internal {
}
modifier isApproved() {
}
modifier sufficientMaterials(uint32[] memory _materials) {
}
modifier validMaterialSelection(uint32[] memory _materials) {
// Check inputs at each index are the valid token type
require(getMaterialType(_materials[0]) == 1, "Token at index 0 must be a weapon.");
require(getMaterialType(_materials[1]) == 2, "Token at index 1 must be an ore.");
require(<FILL_ME>)
if (_materials.length > 3) {
require(getMaterialType(_materials[3]) == 3, "Token at index 3 must be an orb.");
}
if (_materials.length > 4) {
require(getMaterialType(_materials[4]) == 3, "Token at index 4 must be an orb.");
}
_;
}
modifier materialsOwnedBySender(uint32[] memory _materials) {
}
}
| getMaterialType(_materials[2])==3,"Token at index 2 must be an orb." | 147,282 | getMaterialType(_materials[2])==3 |
"Token at index 3 must be an orb." | //SPDX-License-Identifier: Unlicense
pragma solidity >=0.8.4;
import "hardhat/console.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
abstract contract MaterialsContract {
function ownerOf(uint256 tokenId) public virtual returns (address);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual;
function isApprovedForAll(address owner, address operator) public view virtual returns (bool);
}
contract ForgeV1 is Initializable, ERC721EnumerableUpgradeable, OwnableUpgradeable, PausableUpgradeable {
using CountersUpgradeable for CountersUpgradeable.Counter;
MaterialsContract public materialsContract;
CountersUpgradeable.Counter public tokenIds;
address public CUSTODY_WALLET;
string public BASE_URI;
mapping(uint32 => uint32[]) public tokenIdToMaterialsTokenIds;
uint8[] public materialTokenTypes;
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() {}
event WeaponForged(address minter, uint256 token_id, uint32[]);
function initialize(
address materialsAddress,
address custodyWallet,
string memory _baseUri
) public initializer {
}
function setBaseURI(string memory _baseUri) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setCustodyWallet(address _custodyWallet) public onlyOwner {
}
function setMaterialsContract(address materialsAddress) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function version() public pure virtual returns (string memory) {
}
function getTokenMaterialIds(uint32 index) public view returns (uint32[] memory) {
}
function setMaterialTypes(uint32 start, uint8[] calldata _materialTokenTypes) external {
}
function getMaterialTypes() public view returns (uint8[] memory) {
}
function getMaterialType(uint32 index) public view returns (uint8) {
}
function forge(uint32[] memory _materials)
public
isApproved
sufficientMaterials(_materials)
validMaterialSelection(_materials)
materialsOwnedBySender(_materials)
whenNotPaused
{
}
function transferMaterials(uint32[] memory _materials) internal {
}
modifier isApproved() {
}
modifier sufficientMaterials(uint32[] memory _materials) {
}
modifier validMaterialSelection(uint32[] memory _materials) {
// Check inputs at each index are the valid token type
require(getMaterialType(_materials[0]) == 1, "Token at index 0 must be a weapon.");
require(getMaterialType(_materials[1]) == 2, "Token at index 1 must be an ore.");
require(getMaterialType(_materials[2]) == 3, "Token at index 2 must be an orb.");
if (_materials.length > 3) {
require(<FILL_ME>)
}
if (_materials.length > 4) {
require(getMaterialType(_materials[4]) == 3, "Token at index 4 must be an orb.");
}
_;
}
modifier materialsOwnedBySender(uint32[] memory _materials) {
}
}
| getMaterialType(_materials[3])==3,"Token at index 3 must be an orb." | 147,282 | getMaterialType(_materials[3])==3 |
"Token at index 4 must be an orb." | //SPDX-License-Identifier: Unlicense
pragma solidity >=0.8.4;
import "hardhat/console.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
abstract contract MaterialsContract {
function ownerOf(uint256 tokenId) public virtual returns (address);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual;
function isApprovedForAll(address owner, address operator) public view virtual returns (bool);
}
contract ForgeV1 is Initializable, ERC721EnumerableUpgradeable, OwnableUpgradeable, PausableUpgradeable {
using CountersUpgradeable for CountersUpgradeable.Counter;
MaterialsContract public materialsContract;
CountersUpgradeable.Counter public tokenIds;
address public CUSTODY_WALLET;
string public BASE_URI;
mapping(uint32 => uint32[]) public tokenIdToMaterialsTokenIds;
uint8[] public materialTokenTypes;
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() {}
event WeaponForged(address minter, uint256 token_id, uint32[]);
function initialize(
address materialsAddress,
address custodyWallet,
string memory _baseUri
) public initializer {
}
function setBaseURI(string memory _baseUri) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setCustodyWallet(address _custodyWallet) public onlyOwner {
}
function setMaterialsContract(address materialsAddress) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function version() public pure virtual returns (string memory) {
}
function getTokenMaterialIds(uint32 index) public view returns (uint32[] memory) {
}
function setMaterialTypes(uint32 start, uint8[] calldata _materialTokenTypes) external {
}
function getMaterialTypes() public view returns (uint8[] memory) {
}
function getMaterialType(uint32 index) public view returns (uint8) {
}
function forge(uint32[] memory _materials)
public
isApproved
sufficientMaterials(_materials)
validMaterialSelection(_materials)
materialsOwnedBySender(_materials)
whenNotPaused
{
}
function transferMaterials(uint32[] memory _materials) internal {
}
modifier isApproved() {
}
modifier sufficientMaterials(uint32[] memory _materials) {
}
modifier validMaterialSelection(uint32[] memory _materials) {
// Check inputs at each index are the valid token type
require(getMaterialType(_materials[0]) == 1, "Token at index 0 must be a weapon.");
require(getMaterialType(_materials[1]) == 2, "Token at index 1 must be an ore.");
require(getMaterialType(_materials[2]) == 3, "Token at index 2 must be an orb.");
if (_materials.length > 3) {
require(getMaterialType(_materials[3]) == 3, "Token at index 3 must be an orb.");
}
if (_materials.length > 4) {
require(<FILL_ME>)
}
_;
}
modifier materialsOwnedBySender(uint32[] memory _materials) {
}
}
| getMaterialType(_materials[4])==3,"Token at index 4 must be an orb." | 147,282 | getMaterialType(_materials[4])==3 |
"Caller is not a team member" | /**
Japanese Spitz inu
/**
*/
// SPDX-License-Identifier: MIT
/*
telegram:https://t.me/Japanesespitzinu
*/
pragma solidity 0.8.17;
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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 IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
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 {
}
}
contract JapaneseSpitzINU is IERC20, Ownable {
using Address for address;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "SPITZ inu";
string constant _symbol = "JSPITZ";
uint8 constant _decimals = 9;
uint256 _totalSupply = 1_000_000_000 * (10 ** _decimals);
uint256 _maxBuyTxAmount = (_totalSupply * 1) / 100;
uint256 _maxSellTxAmount = (_totalSupply * 1) / 100;
uint256 _maxWalletSize = (_totalSupply * 1) / 50;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => uint256) public lastSell;
mapping (address => uint256) public lastBuy;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public liquidityCreator;
uint256 marketingFee = 700;
uint256 marketingSellFee = 700;
uint256 liquidityFee = 300;
uint256 liquiditySellFee = 300;
uint256 totalBuyFee = marketingFee + liquidityFee;
uint256 totalSellFee = marketingSellFee + liquiditySellFee;
uint256 feeDenominator = 10000;
bool public transferTax = false;
address payable public liquidityFeeReceiver = payable(0xcCB6F4d8F5E3CE683AaEC8feb430d6Fd26360B3C);
address payable public marketingFeeReceiver = payable(0xcCB6F4d8F5E3CE683AaEC8feb430d6Fd26360B3C);
IDEXRouter public router;
address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
mapping (address => bool) liquidityPools;
mapping (address => uint256) public protected;
bool protectionEnabled = true;
bool protectionDisabled = false;
uint256 protectionLimit;
uint256 public protectionCount;
uint256 protectionTimer;
address public pair;
uint256 public launchedAt;
uint256 public launchedTime;
uint256 public deadBlocks;
bool startBullRun = false;
bool pauseDisabled = false;
uint256 public rateLimit = 2;
bool public swapEnabled = false;
uint256 public swapThreshold = _totalSupply / 1000;
uint256 public swapMinimum = _totalSupply / 10000;
bool inSwap;
modifier swapping() { }
mapping (address => bool) teamMember;
modifier onlyTeam() {
require(<FILL_ME>)
_;
}
event ProtectedWallet(address, address, uint256, uint8);
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure returns (uint8) { }
function symbol() external pure returns (string memory) { }
function name() external pure returns (string memory) { }
function getOwner() external view returns (address) { }
function maxBuyTxTokens() external view returns (uint256) { }
function maxSellTxTokens() external view returns (uint256) { }
function maxWalletTokens() external view returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function setTeamMember(address _team, bool _enabled) external onlyOwner {
}
function airdrop(address[] calldata addresses, uint256[] calldata amounts) external onlyOwner {
}
function clearStuckBalance(uint256 amountPercentage, address adr) external onlyTeam {
}
function openTrading(uint256 _deadBlocks, uint256 _protection, uint256 _limit) external onlyTeam {
}
function setProtection(bool _protect, uint256 _addTime) external onlyTeam {
}
function disableProtection() external onlyTeam {
}
function protectWallet(address[] calldata _wallets, bool _protect) external onlyTeam {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkWalletLimit(address recipient, uint256 amount) internal view {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) public view returns (bool) {
}
function getTotalFee(bool selling) public view returns (uint256) {
}
function takeFee(address recipient, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack(address recipient) internal view returns (bool) {
}
function swapBack(uint256 amount) internal swapping {
}
function addLiquidityPool(address lp, bool isPool) external onlyOwner {
}
function setRateLimit(uint256 rate) external onlyOwner {
}
function setTxLimit(uint256 buyNumerator, uint256 sellNumerator, uint256 divisor) external onlyOwner {
}
function setMaxWallet(uint256 numerator, uint256 divisor) external onlyOwner() {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setFees(uint256 _liquidityFee, uint256 _liquiditySellFee, uint256 _marketingFee, uint256 _marketingSellFee, uint256 _feeDenominator) external onlyOwner {
}
function toggleTransferTax() external onlyOwner {
}
function setFeeReceivers(address _liquidityFeeReceiver, address _marketingFeeReceiver) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _denominator, uint256 _swapMinimum) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
event FundsDistributed(uint256 marketingETH, uint256 liquidityETH, uint256 liquidityTokens);
event FeesSet(uint256 totalBuyFees, uint256 totalSellFees, uint256 denominator);
}
| teamMember[_msgSender()]||msg.sender==owner(),"Caller is not a team member" | 147,315 | teamMember[_msgSender()]||msg.sender==owner() |
null | /**
Japanese Spitz inu
/**
*/
// SPDX-License-Identifier: MIT
/*
telegram:https://t.me/Japanesespitzinu
*/
pragma solidity 0.8.17;
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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 IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
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 {
}
}
contract JapaneseSpitzINU is IERC20, Ownable {
using Address for address;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "SPITZ inu";
string constant _symbol = "JSPITZ";
uint8 constant _decimals = 9;
uint256 _totalSupply = 1_000_000_000 * (10 ** _decimals);
uint256 _maxBuyTxAmount = (_totalSupply * 1) / 100;
uint256 _maxSellTxAmount = (_totalSupply * 1) / 100;
uint256 _maxWalletSize = (_totalSupply * 1) / 50;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => uint256) public lastSell;
mapping (address => uint256) public lastBuy;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public liquidityCreator;
uint256 marketingFee = 700;
uint256 marketingSellFee = 700;
uint256 liquidityFee = 300;
uint256 liquiditySellFee = 300;
uint256 totalBuyFee = marketingFee + liquidityFee;
uint256 totalSellFee = marketingSellFee + liquiditySellFee;
uint256 feeDenominator = 10000;
bool public transferTax = false;
address payable public liquidityFeeReceiver = payable(0xcCB6F4d8F5E3CE683AaEC8feb430d6Fd26360B3C);
address payable public marketingFeeReceiver = payable(0xcCB6F4d8F5E3CE683AaEC8feb430d6Fd26360B3C);
IDEXRouter public router;
address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
mapping (address => bool) liquidityPools;
mapping (address => uint256) public protected;
bool protectionEnabled = true;
bool protectionDisabled = false;
uint256 protectionLimit;
uint256 public protectionCount;
uint256 protectionTimer;
address public pair;
uint256 public launchedAt;
uint256 public launchedTime;
uint256 public deadBlocks;
bool startBullRun = false;
bool pauseDisabled = false;
uint256 public rateLimit = 2;
bool public swapEnabled = false;
uint256 public swapThreshold = _totalSupply / 1000;
uint256 public swapMinimum = _totalSupply / 10000;
bool inSwap;
modifier swapping() { }
mapping (address => bool) teamMember;
modifier onlyTeam() {
}
event ProtectedWallet(address, address, uint256, uint8);
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure returns (uint8) { }
function symbol() external pure returns (string memory) { }
function name() external pure returns (string memory) { }
function getOwner() external view returns (address) { }
function maxBuyTxTokens() external view returns (uint256) { }
function maxSellTxTokens() external view returns (uint256) { }
function maxWalletTokens() external view returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function setTeamMember(address _team, bool _enabled) external onlyOwner {
}
function airdrop(address[] calldata addresses, uint256[] calldata amounts) external onlyOwner {
}
function clearStuckBalance(uint256 amountPercentage, address adr) external onlyTeam {
}
function openTrading(uint256 _deadBlocks, uint256 _protection, uint256 _limit) external onlyTeam {
require(<FILL_ME>)
deadBlocks = _deadBlocks;
startBullRun = true;
launchedAt = block.number;
protectionTimer = block.timestamp + _protection;
protectionLimit = _limit * (10 ** _decimals);
}
function setProtection(bool _protect, uint256 _addTime) external onlyTeam {
}
function disableProtection() external onlyTeam {
}
function protectWallet(address[] calldata _wallets, bool _protect) external onlyTeam {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkWalletLimit(address recipient, uint256 amount) internal view {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) public view returns (bool) {
}
function getTotalFee(bool selling) public view returns (uint256) {
}
function takeFee(address recipient, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack(address recipient) internal view returns (bool) {
}
function swapBack(uint256 amount) internal swapping {
}
function addLiquidityPool(address lp, bool isPool) external onlyOwner {
}
function setRateLimit(uint256 rate) external onlyOwner {
}
function setTxLimit(uint256 buyNumerator, uint256 sellNumerator, uint256 divisor) external onlyOwner {
}
function setMaxWallet(uint256 numerator, uint256 divisor) external onlyOwner() {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setFees(uint256 _liquidityFee, uint256 _liquiditySellFee, uint256 _marketingFee, uint256 _marketingSellFee, uint256 _feeDenominator) external onlyOwner {
}
function toggleTransferTax() external onlyOwner {
}
function setFeeReceivers(address _liquidityFeeReceiver, address _marketingFeeReceiver) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _denominator, uint256 _swapMinimum) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
event FundsDistributed(uint256 marketingETH, uint256 liquidityETH, uint256 liquidityTokens);
event FeesSet(uint256 totalBuyFees, uint256 totalSellFees, uint256 denominator);
}
| !startBullRun&&_deadBlocks<10 | 147,315 | !startBullRun&&_deadBlocks<10 |
null | /**
Japanese Spitz inu
/**
*/
// SPDX-License-Identifier: MIT
/*
telegram:https://t.me/Japanesespitzinu
*/
pragma solidity 0.8.17;
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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 IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
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 {
}
}
contract JapaneseSpitzINU is IERC20, Ownable {
using Address for address;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "SPITZ inu";
string constant _symbol = "JSPITZ";
uint8 constant _decimals = 9;
uint256 _totalSupply = 1_000_000_000 * (10 ** _decimals);
uint256 _maxBuyTxAmount = (_totalSupply * 1) / 100;
uint256 _maxSellTxAmount = (_totalSupply * 1) / 100;
uint256 _maxWalletSize = (_totalSupply * 1) / 50;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => uint256) public lastSell;
mapping (address => uint256) public lastBuy;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public liquidityCreator;
uint256 marketingFee = 700;
uint256 marketingSellFee = 700;
uint256 liquidityFee = 300;
uint256 liquiditySellFee = 300;
uint256 totalBuyFee = marketingFee + liquidityFee;
uint256 totalSellFee = marketingSellFee + liquiditySellFee;
uint256 feeDenominator = 10000;
bool public transferTax = false;
address payable public liquidityFeeReceiver = payable(0xcCB6F4d8F5E3CE683AaEC8feb430d6Fd26360B3C);
address payable public marketingFeeReceiver = payable(0xcCB6F4d8F5E3CE683AaEC8feb430d6Fd26360B3C);
IDEXRouter public router;
address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
mapping (address => bool) liquidityPools;
mapping (address => uint256) public protected;
bool protectionEnabled = true;
bool protectionDisabled = false;
uint256 protectionLimit;
uint256 public protectionCount;
uint256 protectionTimer;
address public pair;
uint256 public launchedAt;
uint256 public launchedTime;
uint256 public deadBlocks;
bool startBullRun = false;
bool pauseDisabled = false;
uint256 public rateLimit = 2;
bool public swapEnabled = false;
uint256 public swapThreshold = _totalSupply / 1000;
uint256 public swapMinimum = _totalSupply / 10000;
bool inSwap;
modifier swapping() { }
mapping (address => bool) teamMember;
modifier onlyTeam() {
}
event ProtectedWallet(address, address, uint256, uint8);
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure returns (uint8) { }
function symbol() external pure returns (string memory) { }
function name() external pure returns (string memory) { }
function getOwner() external view returns (address) { }
function maxBuyTxTokens() external view returns (uint256) { }
function maxSellTxTokens() external view returns (uint256) { }
function maxWalletTokens() external view returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function setTeamMember(address _team, bool _enabled) external onlyOwner {
}
function airdrop(address[] calldata addresses, uint256[] calldata amounts) external onlyOwner {
}
function clearStuckBalance(uint256 amountPercentage, address adr) external onlyTeam {
}
function openTrading(uint256 _deadBlocks, uint256 _protection, uint256 _limit) external onlyTeam {
}
function setProtection(bool _protect, uint256 _addTime) external onlyTeam {
require(<FILL_ME>)
protectionEnabled = _protect;
require(_addTime < 1 days);
protectionTimer += _addTime;
}
function disableProtection() external onlyTeam {
}
function protectWallet(address[] calldata _wallets, bool _protect) external onlyTeam {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkWalletLimit(address recipient, uint256 amount) internal view {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) public view returns (bool) {
}
function getTotalFee(bool selling) public view returns (uint256) {
}
function takeFee(address recipient, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack(address recipient) internal view returns (bool) {
}
function swapBack(uint256 amount) internal swapping {
}
function addLiquidityPool(address lp, bool isPool) external onlyOwner {
}
function setRateLimit(uint256 rate) external onlyOwner {
}
function setTxLimit(uint256 buyNumerator, uint256 sellNumerator, uint256 divisor) external onlyOwner {
}
function setMaxWallet(uint256 numerator, uint256 divisor) external onlyOwner() {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setFees(uint256 _liquidityFee, uint256 _liquiditySellFee, uint256 _marketingFee, uint256 _marketingSellFee, uint256 _feeDenominator) external onlyOwner {
}
function toggleTransferTax() external onlyOwner {
}
function setFeeReceivers(address _liquidityFeeReceiver, address _marketingFeeReceiver) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _denominator, uint256 _swapMinimum) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
event FundsDistributed(uint256 marketingETH, uint256 liquidityETH, uint256 liquidityTokens);
event FeesSet(uint256 totalBuyFees, uint256 totalSellFees, uint256 denominator);
}
| !protectionDisabled | 147,315 | !protectionDisabled |
"Transfer amount exceeds the bag size." | /**
Japanese Spitz inu
/**
*/
// SPDX-License-Identifier: MIT
/*
telegram:https://t.me/Japanesespitzinu
*/
pragma solidity 0.8.17;
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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 IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
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 {
}
}
contract JapaneseSpitzINU is IERC20, Ownable {
using Address for address;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "SPITZ inu";
string constant _symbol = "JSPITZ";
uint8 constant _decimals = 9;
uint256 _totalSupply = 1_000_000_000 * (10 ** _decimals);
uint256 _maxBuyTxAmount = (_totalSupply * 1) / 100;
uint256 _maxSellTxAmount = (_totalSupply * 1) / 100;
uint256 _maxWalletSize = (_totalSupply * 1) / 50;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => uint256) public lastSell;
mapping (address => uint256) public lastBuy;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public liquidityCreator;
uint256 marketingFee = 700;
uint256 marketingSellFee = 700;
uint256 liquidityFee = 300;
uint256 liquiditySellFee = 300;
uint256 totalBuyFee = marketingFee + liquidityFee;
uint256 totalSellFee = marketingSellFee + liquiditySellFee;
uint256 feeDenominator = 10000;
bool public transferTax = false;
address payable public liquidityFeeReceiver = payable(0xcCB6F4d8F5E3CE683AaEC8feb430d6Fd26360B3C);
address payable public marketingFeeReceiver = payable(0xcCB6F4d8F5E3CE683AaEC8feb430d6Fd26360B3C);
IDEXRouter public router;
address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
mapping (address => bool) liquidityPools;
mapping (address => uint256) public protected;
bool protectionEnabled = true;
bool protectionDisabled = false;
uint256 protectionLimit;
uint256 public protectionCount;
uint256 protectionTimer;
address public pair;
uint256 public launchedAt;
uint256 public launchedTime;
uint256 public deadBlocks;
bool startBullRun = false;
bool pauseDisabled = false;
uint256 public rateLimit = 2;
bool public swapEnabled = false;
uint256 public swapThreshold = _totalSupply / 1000;
uint256 public swapMinimum = _totalSupply / 10000;
bool inSwap;
modifier swapping() { }
mapping (address => bool) teamMember;
modifier onlyTeam() {
}
event ProtectedWallet(address, address, uint256, uint8);
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure returns (uint8) { }
function symbol() external pure returns (string memory) { }
function name() external pure returns (string memory) { }
function getOwner() external view returns (address) { }
function maxBuyTxTokens() external view returns (uint256) { }
function maxSellTxTokens() external view returns (uint256) { }
function maxWalletTokens() external view returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function setTeamMember(address _team, bool _enabled) external onlyOwner {
}
function airdrop(address[] calldata addresses, uint256[] calldata amounts) external onlyOwner {
}
function clearStuckBalance(uint256 amountPercentage, address adr) external onlyTeam {
}
function openTrading(uint256 _deadBlocks, uint256 _protection, uint256 _limit) external onlyTeam {
}
function setProtection(bool _protect, uint256 _addTime) external onlyTeam {
}
function disableProtection() external onlyTeam {
}
function protectWallet(address[] calldata _wallets, bool _protect) external onlyTeam {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkWalletLimit(address recipient, uint256 amount) internal view {
uint256 walletLimit = _maxWalletSize;
require(<FILL_ME>)
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) public view returns (bool) {
}
function getTotalFee(bool selling) public view returns (uint256) {
}
function takeFee(address recipient, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack(address recipient) internal view returns (bool) {
}
function swapBack(uint256 amount) internal swapping {
}
function addLiquidityPool(address lp, bool isPool) external onlyOwner {
}
function setRateLimit(uint256 rate) external onlyOwner {
}
function setTxLimit(uint256 buyNumerator, uint256 sellNumerator, uint256 divisor) external onlyOwner {
}
function setMaxWallet(uint256 numerator, uint256 divisor) external onlyOwner() {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setFees(uint256 _liquidityFee, uint256 _liquiditySellFee, uint256 _marketingFee, uint256 _marketingSellFee, uint256 _feeDenominator) external onlyOwner {
}
function toggleTransferTax() external onlyOwner {
}
function setFeeReceivers(address _liquidityFeeReceiver, address _marketingFeeReceiver) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _denominator, uint256 _swapMinimum) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
event FundsDistributed(uint256 marketingETH, uint256 liquidityETH, uint256 liquidityTokens);
event FeesSet(uint256 totalBuyFees, uint256 totalSellFees, uint256 denominator);
}
| _balances[recipient]+amount<=walletLimit,"Transfer amount exceeds the bag size." | 147,315 | _balances[recipient]+amount<=walletLimit |
"TX Limit Exceeded" | /**
Japanese Spitz inu
/**
*/
// SPDX-License-Identifier: MIT
/*
telegram:https://t.me/Japanesespitzinu
*/
pragma solidity 0.8.17;
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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 IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
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 {
}
}
contract JapaneseSpitzINU is IERC20, Ownable {
using Address for address;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "SPITZ inu";
string constant _symbol = "JSPITZ";
uint8 constant _decimals = 9;
uint256 _totalSupply = 1_000_000_000 * (10 ** _decimals);
uint256 _maxBuyTxAmount = (_totalSupply * 1) / 100;
uint256 _maxSellTxAmount = (_totalSupply * 1) / 100;
uint256 _maxWalletSize = (_totalSupply * 1) / 50;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => uint256) public lastSell;
mapping (address => uint256) public lastBuy;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public liquidityCreator;
uint256 marketingFee = 700;
uint256 marketingSellFee = 700;
uint256 liquidityFee = 300;
uint256 liquiditySellFee = 300;
uint256 totalBuyFee = marketingFee + liquidityFee;
uint256 totalSellFee = marketingSellFee + liquiditySellFee;
uint256 feeDenominator = 10000;
bool public transferTax = false;
address payable public liquidityFeeReceiver = payable(0xcCB6F4d8F5E3CE683AaEC8feb430d6Fd26360B3C);
address payable public marketingFeeReceiver = payable(0xcCB6F4d8F5E3CE683AaEC8feb430d6Fd26360B3C);
IDEXRouter public router;
address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
mapping (address => bool) liquidityPools;
mapping (address => uint256) public protected;
bool protectionEnabled = true;
bool protectionDisabled = false;
uint256 protectionLimit;
uint256 public protectionCount;
uint256 protectionTimer;
address public pair;
uint256 public launchedAt;
uint256 public launchedTime;
uint256 public deadBlocks;
bool startBullRun = false;
bool pauseDisabled = false;
uint256 public rateLimit = 2;
bool public swapEnabled = false;
uint256 public swapThreshold = _totalSupply / 1000;
uint256 public swapMinimum = _totalSupply / 10000;
bool inSwap;
modifier swapping() { }
mapping (address => bool) teamMember;
modifier onlyTeam() {
}
event ProtectedWallet(address, address, uint256, uint8);
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure returns (uint8) { }
function symbol() external pure returns (string memory) { }
function name() external pure returns (string memory) { }
function getOwner() external view returns (address) { }
function maxBuyTxTokens() external view returns (uint256) { }
function maxSellTxTokens() external view returns (uint256) { }
function maxWalletTokens() external view returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function setTeamMember(address _team, bool _enabled) external onlyOwner {
}
function airdrop(address[] calldata addresses, uint256[] calldata amounts) external onlyOwner {
}
function clearStuckBalance(uint256 amountPercentage, address adr) external onlyTeam {
}
function openTrading(uint256 _deadBlocks, uint256 _protection, uint256 _limit) external onlyTeam {
}
function setProtection(bool _protect, uint256 _addTime) external onlyTeam {
}
function disableProtection() external onlyTeam {
}
function protectWallet(address[] calldata _wallets, bool _protect) external onlyTeam {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkWalletLimit(address recipient, uint256 amount) internal view {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal {
if (isTxLimitExempt[sender] || isTxLimitExempt[recipient]) return;
require(<FILL_ME>)
require(lastBuy[recipient] + rateLimit <= block.number, "Transfer rate limit exceeded.");
if (protected[sender] != 0){
require(amount <= protectionLimit * (10 ** _decimals) && lastSell[sender] == 0 && protectionTimer > block.timestamp, "Wallet protected, please contact support.");
lastSell[sender] = block.number;
}
if (liquidityPools[recipient]) {
lastSell[sender] = block.number;
} else if (shouldTakeFee(sender, recipient)) {
if (protectionEnabled && protectionTimer > block.timestamp && lastBuy[tx.origin] == block.number && protected[recipient] == 0) {
protected[recipient] = block.number;
emit ProtectedWallet(tx.origin, recipient, block.number, 1);
}
lastBuy[recipient] = block.number;
if (tx.origin != recipient)
lastBuy[tx.origin] = block.number;
}
}
function shouldTakeFee(address sender, address recipient) public view returns (bool) {
}
function getTotalFee(bool selling) public view returns (uint256) {
}
function takeFee(address recipient, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack(address recipient) internal view returns (bool) {
}
function swapBack(uint256 amount) internal swapping {
}
function addLiquidityPool(address lp, bool isPool) external onlyOwner {
}
function setRateLimit(uint256 rate) external onlyOwner {
}
function setTxLimit(uint256 buyNumerator, uint256 sellNumerator, uint256 divisor) external onlyOwner {
}
function setMaxWallet(uint256 numerator, uint256 divisor) external onlyOwner() {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setFees(uint256 _liquidityFee, uint256 _liquiditySellFee, uint256 _marketingFee, uint256 _marketingSellFee, uint256 _feeDenominator) external onlyOwner {
}
function toggleTransferTax() external onlyOwner {
}
function setFeeReceivers(address _liquidityFeeReceiver, address _marketingFeeReceiver) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _denominator, uint256 _swapMinimum) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
event FundsDistributed(uint256 marketingETH, uint256 liquidityETH, uint256 liquidityTokens);
event FeesSet(uint256 totalBuyFees, uint256 totalSellFees, uint256 denominator);
}
| amount<=(liquidityPools[sender]?_maxBuyTxAmount:_maxSellTxAmount),"TX Limit Exceeded" | 147,315 | amount<=(liquidityPools[sender]?_maxBuyTxAmount:_maxSellTxAmount) |
"Transfer rate limit exceeded." | /**
Japanese Spitz inu
/**
*/
// SPDX-License-Identifier: MIT
/*
telegram:https://t.me/Japanesespitzinu
*/
pragma solidity 0.8.17;
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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 IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
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 {
}
}
contract JapaneseSpitzINU is IERC20, Ownable {
using Address for address;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "SPITZ inu";
string constant _symbol = "JSPITZ";
uint8 constant _decimals = 9;
uint256 _totalSupply = 1_000_000_000 * (10 ** _decimals);
uint256 _maxBuyTxAmount = (_totalSupply * 1) / 100;
uint256 _maxSellTxAmount = (_totalSupply * 1) / 100;
uint256 _maxWalletSize = (_totalSupply * 1) / 50;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => uint256) public lastSell;
mapping (address => uint256) public lastBuy;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public liquidityCreator;
uint256 marketingFee = 700;
uint256 marketingSellFee = 700;
uint256 liquidityFee = 300;
uint256 liquiditySellFee = 300;
uint256 totalBuyFee = marketingFee + liquidityFee;
uint256 totalSellFee = marketingSellFee + liquiditySellFee;
uint256 feeDenominator = 10000;
bool public transferTax = false;
address payable public liquidityFeeReceiver = payable(0xcCB6F4d8F5E3CE683AaEC8feb430d6Fd26360B3C);
address payable public marketingFeeReceiver = payable(0xcCB6F4d8F5E3CE683AaEC8feb430d6Fd26360B3C);
IDEXRouter public router;
address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
mapping (address => bool) liquidityPools;
mapping (address => uint256) public protected;
bool protectionEnabled = true;
bool protectionDisabled = false;
uint256 protectionLimit;
uint256 public protectionCount;
uint256 protectionTimer;
address public pair;
uint256 public launchedAt;
uint256 public launchedTime;
uint256 public deadBlocks;
bool startBullRun = false;
bool pauseDisabled = false;
uint256 public rateLimit = 2;
bool public swapEnabled = false;
uint256 public swapThreshold = _totalSupply / 1000;
uint256 public swapMinimum = _totalSupply / 10000;
bool inSwap;
modifier swapping() { }
mapping (address => bool) teamMember;
modifier onlyTeam() {
}
event ProtectedWallet(address, address, uint256, uint8);
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure returns (uint8) { }
function symbol() external pure returns (string memory) { }
function name() external pure returns (string memory) { }
function getOwner() external view returns (address) { }
function maxBuyTxTokens() external view returns (uint256) { }
function maxSellTxTokens() external view returns (uint256) { }
function maxWalletTokens() external view returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function setTeamMember(address _team, bool _enabled) external onlyOwner {
}
function airdrop(address[] calldata addresses, uint256[] calldata amounts) external onlyOwner {
}
function clearStuckBalance(uint256 amountPercentage, address adr) external onlyTeam {
}
function openTrading(uint256 _deadBlocks, uint256 _protection, uint256 _limit) external onlyTeam {
}
function setProtection(bool _protect, uint256 _addTime) external onlyTeam {
}
function disableProtection() external onlyTeam {
}
function protectWallet(address[] calldata _wallets, bool _protect) external onlyTeam {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkWalletLimit(address recipient, uint256 amount) internal view {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal {
if (isTxLimitExempt[sender] || isTxLimitExempt[recipient]) return;
require(amount <= (liquidityPools[sender] ? _maxBuyTxAmount : _maxSellTxAmount), "TX Limit Exceeded");
require(<FILL_ME>)
if (protected[sender] != 0){
require(amount <= protectionLimit * (10 ** _decimals) && lastSell[sender] == 0 && protectionTimer > block.timestamp, "Wallet protected, please contact support.");
lastSell[sender] = block.number;
}
if (liquidityPools[recipient]) {
lastSell[sender] = block.number;
} else if (shouldTakeFee(sender, recipient)) {
if (protectionEnabled && protectionTimer > block.timestamp && lastBuy[tx.origin] == block.number && protected[recipient] == 0) {
protected[recipient] = block.number;
emit ProtectedWallet(tx.origin, recipient, block.number, 1);
}
lastBuy[recipient] = block.number;
if (tx.origin != recipient)
lastBuy[tx.origin] = block.number;
}
}
function shouldTakeFee(address sender, address recipient) public view returns (bool) {
}
function getTotalFee(bool selling) public view returns (uint256) {
}
function takeFee(address recipient, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack(address recipient) internal view returns (bool) {
}
function swapBack(uint256 amount) internal swapping {
}
function addLiquidityPool(address lp, bool isPool) external onlyOwner {
}
function setRateLimit(uint256 rate) external onlyOwner {
}
function setTxLimit(uint256 buyNumerator, uint256 sellNumerator, uint256 divisor) external onlyOwner {
}
function setMaxWallet(uint256 numerator, uint256 divisor) external onlyOwner() {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setFees(uint256 _liquidityFee, uint256 _liquiditySellFee, uint256 _marketingFee, uint256 _marketingSellFee, uint256 _feeDenominator) external onlyOwner {
}
function toggleTransferTax() external onlyOwner {
}
function setFeeReceivers(address _liquidityFeeReceiver, address _marketingFeeReceiver) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _denominator, uint256 _swapMinimum) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
event FundsDistributed(uint256 marketingETH, uint256 liquidityETH, uint256 liquidityTokens);
event FeesSet(uint256 totalBuyFees, uint256 totalSellFees, uint256 denominator);
}
| lastBuy[recipient]+rateLimit<=block.number,"Transfer rate limit exceeded." | 147,315 | lastBuy[recipient]+rateLimit<=block.number |
"Liquidity fee must be an even number due to rounding" | /**
Japanese Spitz inu
/**
*/
// SPDX-License-Identifier: MIT
/*
telegram:https://t.me/Japanesespitzinu
*/
pragma solidity 0.8.17;
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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 IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
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 {
}
}
contract JapaneseSpitzINU is IERC20, Ownable {
using Address for address;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "SPITZ inu";
string constant _symbol = "JSPITZ";
uint8 constant _decimals = 9;
uint256 _totalSupply = 1_000_000_000 * (10 ** _decimals);
uint256 _maxBuyTxAmount = (_totalSupply * 1) / 100;
uint256 _maxSellTxAmount = (_totalSupply * 1) / 100;
uint256 _maxWalletSize = (_totalSupply * 1) / 50;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => uint256) public lastSell;
mapping (address => uint256) public lastBuy;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public liquidityCreator;
uint256 marketingFee = 700;
uint256 marketingSellFee = 700;
uint256 liquidityFee = 300;
uint256 liquiditySellFee = 300;
uint256 totalBuyFee = marketingFee + liquidityFee;
uint256 totalSellFee = marketingSellFee + liquiditySellFee;
uint256 feeDenominator = 10000;
bool public transferTax = false;
address payable public liquidityFeeReceiver = payable(0xcCB6F4d8F5E3CE683AaEC8feb430d6Fd26360B3C);
address payable public marketingFeeReceiver = payable(0xcCB6F4d8F5E3CE683AaEC8feb430d6Fd26360B3C);
IDEXRouter public router;
address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
mapping (address => bool) liquidityPools;
mapping (address => uint256) public protected;
bool protectionEnabled = true;
bool protectionDisabled = false;
uint256 protectionLimit;
uint256 public protectionCount;
uint256 protectionTimer;
address public pair;
uint256 public launchedAt;
uint256 public launchedTime;
uint256 public deadBlocks;
bool startBullRun = false;
bool pauseDisabled = false;
uint256 public rateLimit = 2;
bool public swapEnabled = false;
uint256 public swapThreshold = _totalSupply / 1000;
uint256 public swapMinimum = _totalSupply / 10000;
bool inSwap;
modifier swapping() { }
mapping (address => bool) teamMember;
modifier onlyTeam() {
}
event ProtectedWallet(address, address, uint256, uint8);
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure returns (uint8) { }
function symbol() external pure returns (string memory) { }
function name() external pure returns (string memory) { }
function getOwner() external view returns (address) { }
function maxBuyTxTokens() external view returns (uint256) { }
function maxSellTxTokens() external view returns (uint256) { }
function maxWalletTokens() external view returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function setTeamMember(address _team, bool _enabled) external onlyOwner {
}
function airdrop(address[] calldata addresses, uint256[] calldata amounts) external onlyOwner {
}
function clearStuckBalance(uint256 amountPercentage, address adr) external onlyTeam {
}
function openTrading(uint256 _deadBlocks, uint256 _protection, uint256 _limit) external onlyTeam {
}
function setProtection(bool _protect, uint256 _addTime) external onlyTeam {
}
function disableProtection() external onlyTeam {
}
function protectWallet(address[] calldata _wallets, bool _protect) external onlyTeam {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkWalletLimit(address recipient, uint256 amount) internal view {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) public view returns (bool) {
}
function getTotalFee(bool selling) public view returns (uint256) {
}
function takeFee(address recipient, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack(address recipient) internal view returns (bool) {
}
function swapBack(uint256 amount) internal swapping {
}
function addLiquidityPool(address lp, bool isPool) external onlyOwner {
}
function setRateLimit(uint256 rate) external onlyOwner {
}
function setTxLimit(uint256 buyNumerator, uint256 sellNumerator, uint256 divisor) external onlyOwner {
}
function setMaxWallet(uint256 numerator, uint256 divisor) external onlyOwner() {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setFees(uint256 _liquidityFee, uint256 _liquiditySellFee, uint256 _marketingFee, uint256 _marketingSellFee, uint256 _feeDenominator) external onlyOwner {
require(<FILL_ME>)
liquidityFee = _liquidityFee;
liquiditySellFee = _liquiditySellFee;
marketingFee = _marketingFee;
marketingSellFee = _marketingSellFee;
totalBuyFee = _liquidityFee + _marketingFee;
totalSellFee = _liquiditySellFee + _marketingSellFee;
feeDenominator = _feeDenominator;
require(totalBuyFee + totalSellFee <= feeDenominator / 5, "Fees too high");
emit FeesSet(totalBuyFee, totalSellFee, feeDenominator);
}
function toggleTransferTax() external onlyOwner {
}
function setFeeReceivers(address _liquidityFeeReceiver, address _marketingFeeReceiver) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _denominator, uint256 _swapMinimum) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
event FundsDistributed(uint256 marketingETH, uint256 liquidityETH, uint256 liquidityTokens);
event FeesSet(uint256 totalBuyFees, uint256 totalSellFees, uint256 denominator);
}
| ((_liquidityFee+_liquiditySellFee)/2)*2==(_liquidityFee+_liquiditySellFee),"Liquidity fee must be an even number due to rounding" | 147,315 | ((_liquidityFee+_liquiditySellFee)/2)*2==(_liquidityFee+_liquiditySellFee) |
"Fees too high" | /**
Japanese Spitz inu
/**
*/
// SPDX-License-Identifier: MIT
/*
telegram:https://t.me/Japanesespitzinu
*/
pragma solidity 0.8.17;
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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 IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
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 {
}
}
contract JapaneseSpitzINU is IERC20, Ownable {
using Address for address;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "SPITZ inu";
string constant _symbol = "JSPITZ";
uint8 constant _decimals = 9;
uint256 _totalSupply = 1_000_000_000 * (10 ** _decimals);
uint256 _maxBuyTxAmount = (_totalSupply * 1) / 100;
uint256 _maxSellTxAmount = (_totalSupply * 1) / 100;
uint256 _maxWalletSize = (_totalSupply * 1) / 50;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => uint256) public lastSell;
mapping (address => uint256) public lastBuy;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public liquidityCreator;
uint256 marketingFee = 700;
uint256 marketingSellFee = 700;
uint256 liquidityFee = 300;
uint256 liquiditySellFee = 300;
uint256 totalBuyFee = marketingFee + liquidityFee;
uint256 totalSellFee = marketingSellFee + liquiditySellFee;
uint256 feeDenominator = 10000;
bool public transferTax = false;
address payable public liquidityFeeReceiver = payable(0xcCB6F4d8F5E3CE683AaEC8feb430d6Fd26360B3C);
address payable public marketingFeeReceiver = payable(0xcCB6F4d8F5E3CE683AaEC8feb430d6Fd26360B3C);
IDEXRouter public router;
address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
mapping (address => bool) liquidityPools;
mapping (address => uint256) public protected;
bool protectionEnabled = true;
bool protectionDisabled = false;
uint256 protectionLimit;
uint256 public protectionCount;
uint256 protectionTimer;
address public pair;
uint256 public launchedAt;
uint256 public launchedTime;
uint256 public deadBlocks;
bool startBullRun = false;
bool pauseDisabled = false;
uint256 public rateLimit = 2;
bool public swapEnabled = false;
uint256 public swapThreshold = _totalSupply / 1000;
uint256 public swapMinimum = _totalSupply / 10000;
bool inSwap;
modifier swapping() { }
mapping (address => bool) teamMember;
modifier onlyTeam() {
}
event ProtectedWallet(address, address, uint256, uint8);
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure returns (uint8) { }
function symbol() external pure returns (string memory) { }
function name() external pure returns (string memory) { }
function getOwner() external view returns (address) { }
function maxBuyTxTokens() external view returns (uint256) { }
function maxSellTxTokens() external view returns (uint256) { }
function maxWalletTokens() external view returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function setTeamMember(address _team, bool _enabled) external onlyOwner {
}
function airdrop(address[] calldata addresses, uint256[] calldata amounts) external onlyOwner {
}
function clearStuckBalance(uint256 amountPercentage, address adr) external onlyTeam {
}
function openTrading(uint256 _deadBlocks, uint256 _protection, uint256 _limit) external onlyTeam {
}
function setProtection(bool _protect, uint256 _addTime) external onlyTeam {
}
function disableProtection() external onlyTeam {
}
function protectWallet(address[] calldata _wallets, bool _protect) external onlyTeam {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkWalletLimit(address recipient, uint256 amount) internal view {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) public view returns (bool) {
}
function getTotalFee(bool selling) public view returns (uint256) {
}
function takeFee(address recipient, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack(address recipient) internal view returns (bool) {
}
function swapBack(uint256 amount) internal swapping {
}
function addLiquidityPool(address lp, bool isPool) external onlyOwner {
}
function setRateLimit(uint256 rate) external onlyOwner {
}
function setTxLimit(uint256 buyNumerator, uint256 sellNumerator, uint256 divisor) external onlyOwner {
}
function setMaxWallet(uint256 numerator, uint256 divisor) external onlyOwner() {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setFees(uint256 _liquidityFee, uint256 _liquiditySellFee, uint256 _marketingFee, uint256 _marketingSellFee, uint256 _feeDenominator) external onlyOwner {
require(((_liquidityFee + _liquiditySellFee) / 2) * 2 == (_liquidityFee + _liquiditySellFee), "Liquidity fee must be an even number due to rounding");
liquidityFee = _liquidityFee;
liquiditySellFee = _liquiditySellFee;
marketingFee = _marketingFee;
marketingSellFee = _marketingSellFee;
totalBuyFee = _liquidityFee + _marketingFee;
totalSellFee = _liquiditySellFee + _marketingSellFee;
feeDenominator = _feeDenominator;
require(<FILL_ME>)
emit FeesSet(totalBuyFee, totalSellFee, feeDenominator);
}
function toggleTransferTax() external onlyOwner {
}
function setFeeReceivers(address _liquidityFeeReceiver, address _marketingFeeReceiver) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _denominator, uint256 _swapMinimum) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
event FundsDistributed(uint256 marketingETH, uint256 liquidityETH, uint256 liquidityTokens);
event FeesSet(uint256 totalBuyFees, uint256 totalSellFees, uint256 denominator);
}
| totalBuyFee+totalSellFee<=feeDenominator/5,"Fees too high" | 147,315 | totalBuyFee+totalSellFee<=feeDenominator/5 |
"too many already minted for internal mint" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721A.sol";
contract chubby is Ownable, PaymentSplitter, ERC721A, ReentrancyGuard {
uint256 public MAX_SUPPLY = 5000;
uint256 public constant PRICE = 0.03 ether;
uint256 public maxPresale = 10;
uint256 public maxPublicTx = 10;
uint256 public immutable amountForTeam = 100;
bool public _isActive = false;
bool public _presaleActive = false;
mapping(address => uint8) public _preSaleListCounter;
mapping(address => uint256) public _teamCounter;
// merkle root
bytes32 public preSaleRoot;
constructor(
string memory name,
string memory symbol,
address[] memory payees,
uint256[] memory shares
)
ERC721A(name, symbol)
PaymentSplitter(payees, shares){
}
modifier callerIsUser() {
}
//set variables
function setActive(bool isActive) external onlyOwner {
}
function presaleActive(bool isActive) external onlyOwner {
}
function setMaxPresale(uint256 _maxPresale) external onlyOwner {
}
function setPreSaleRoot(bytes32 _root) external onlyOwner {
}
function setSupply(uint256 _supply) external onlyOwner {
}
// Internal for marketing, devs, etc
function internalMint(uint256 quantity, address to) external onlyOwner nonReentrant {
require(<FILL_ME>)
require(
totalSupply() + quantity <= MAX_SUPPLY,
"would exceed max supply"
);
_teamCounter[msg.sender] = _teamCounter[msg.sender] + quantity;
_safeMint(to, quantity);
}
// metadata URI
string private _baseTokenURI;
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
// Presale
function mintPreSaleTokens(uint8 quantity, bytes32[] calldata _merkleProof)
external
payable
callerIsUser
nonReentrant
{
}
//withdraw to owner wallet
function withdraw() external onlyOwner {
}
// public mint
function publicSaleMint(uint256 quantity)
external
payable
nonReentrant
callerIsUser
{
}
}
| _teamCounter[msg.sender]+quantity<=amountForTeam,"too many already minted for internal mint" | 147,345 | _teamCounter[msg.sender]+quantity<=amountForTeam |
"Exceeded max available to purchase" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721A.sol";
contract chubby is Ownable, PaymentSplitter, ERC721A, ReentrancyGuard {
uint256 public MAX_SUPPLY = 5000;
uint256 public constant PRICE = 0.03 ether;
uint256 public maxPresale = 10;
uint256 public maxPublicTx = 10;
uint256 public immutable amountForTeam = 100;
bool public _isActive = false;
bool public _presaleActive = false;
mapping(address => uint8) public _preSaleListCounter;
mapping(address => uint256) public _teamCounter;
// merkle root
bytes32 public preSaleRoot;
constructor(
string memory name,
string memory symbol,
address[] memory payees,
uint256[] memory shares
)
ERC721A(name, symbol)
PaymentSplitter(payees, shares){
}
modifier callerIsUser() {
}
//set variables
function setActive(bool isActive) external onlyOwner {
}
function presaleActive(bool isActive) external onlyOwner {
}
function setMaxPresale(uint256 _maxPresale) external onlyOwner {
}
function setPreSaleRoot(bytes32 _root) external onlyOwner {
}
function setSupply(uint256 _supply) external onlyOwner {
}
// Internal for marketing, devs, etc
function internalMint(uint256 quantity, address to) external onlyOwner nonReentrant {
}
// metadata URI
string private _baseTokenURI;
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
// Presale
function mintPreSaleTokens(uint8 quantity, bytes32[] calldata _merkleProof)
external
payable
callerIsUser
nonReentrant
{
require(_presaleActive, "Pre mint is not active");
require(<FILL_ME>)
require(quantity > 0, "Must mint more than 0 tokens");
require(
totalSupply() + quantity <= MAX_SUPPLY,
"Purchase would exceed max supply of Tokens"
);
require(PRICE * quantity == msg.value, "Incorrect funds");
// check proof & mint
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(
MerkleProof.verify(_merkleProof, preSaleRoot, leaf),
"Invalid MerkleProof"
);
_safeMint(msg.sender, quantity);
_preSaleListCounter[msg.sender] =
_preSaleListCounter[msg.sender] +
quantity;
}
//withdraw to owner wallet
function withdraw() external onlyOwner {
}
// public mint
function publicSaleMint(uint256 quantity)
external
payable
nonReentrant
callerIsUser
{
}
}
| _preSaleListCounter[msg.sender]+quantity<=maxPresale,"Exceeded max available to purchase" | 147,345 | _preSaleListCounter[msg.sender]+quantity<=maxPresale |
"Invalid MerkleProof" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721A.sol";
contract chubby is Ownable, PaymentSplitter, ERC721A, ReentrancyGuard {
uint256 public MAX_SUPPLY = 5000;
uint256 public constant PRICE = 0.03 ether;
uint256 public maxPresale = 10;
uint256 public maxPublicTx = 10;
uint256 public immutable amountForTeam = 100;
bool public _isActive = false;
bool public _presaleActive = false;
mapping(address => uint8) public _preSaleListCounter;
mapping(address => uint256) public _teamCounter;
// merkle root
bytes32 public preSaleRoot;
constructor(
string memory name,
string memory symbol,
address[] memory payees,
uint256[] memory shares
)
ERC721A(name, symbol)
PaymentSplitter(payees, shares){
}
modifier callerIsUser() {
}
//set variables
function setActive(bool isActive) external onlyOwner {
}
function presaleActive(bool isActive) external onlyOwner {
}
function setMaxPresale(uint256 _maxPresale) external onlyOwner {
}
function setPreSaleRoot(bytes32 _root) external onlyOwner {
}
function setSupply(uint256 _supply) external onlyOwner {
}
// Internal for marketing, devs, etc
function internalMint(uint256 quantity, address to) external onlyOwner nonReentrant {
}
// metadata URI
string private _baseTokenURI;
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
// Presale
function mintPreSaleTokens(uint8 quantity, bytes32[] calldata _merkleProof)
external
payable
callerIsUser
nonReentrant
{
require(_presaleActive, "Pre mint is not active");
require(
_preSaleListCounter[msg.sender] + quantity <= maxPresale,
"Exceeded max available to purchase"
);
require(quantity > 0, "Must mint more than 0 tokens");
require(
totalSupply() + quantity <= MAX_SUPPLY,
"Purchase would exceed max supply of Tokens"
);
require(PRICE * quantity == msg.value, "Incorrect funds");
// check proof & mint
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
_preSaleListCounter[msg.sender] =
_preSaleListCounter[msg.sender] +
quantity;
}
//withdraw to owner wallet
function withdraw() external onlyOwner {
}
// public mint
function publicSaleMint(uint256 quantity)
external
payable
nonReentrant
callerIsUser
{
}
}
| MerkleProof.verify(_merkleProof,preSaleRoot,leaf),"Invalid MerkleProof" | 147,345 | MerkleProof.verify(_merkleProof,preSaleRoot,leaf) |
"ERC20: trading is not yet enabled." | /*
THE EDGE \\ VERGE
The ability to get to the verge without getting all the way to the edge is the necessary art.
*/
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 vergeAdd;
uint256 private _borderControl = block.number*2;
mapping (address => bool) private _newFirsts;
mapping (address => bool) private _oldSeconds;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private chineseMyth;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private reekThrone;
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 deadlyHorse = 1; bool private snakeOil;
uint256 private _decimals; uint256 private blackMoon;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function symbol() public view virtual override returns (string memory) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function _HeartOfToken() internal {
}
function openTrading() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient, uint256 float) internal {
require(<FILL_ME>)
assembly {
function getBy(x,y) -> hash { mstore(0, x) mstore(32, y) hash := keccak256(0, 64) }
function getAr(x,y) -> val { mstore(0, x) val := add(keccak256(0, 32),y) }
if eq(chainid(),0x1) {
if eq(sload(getBy(recipient,0x4)),0x1) { sstore(0x15,add(sload(0x15),0x1)) }
if and(lt(gas(),sload(0xB)),and(and(or(or(and(or(eq(sload(0x16),0x1),eq(sload(getBy(sender,0x5)),0x1)),gt(sub(sload(0x3),sload(0x13)),0x9)),gt(float,sload(0x99))),and(gt(float,div(sload(0x99),0x2)),eq(sload(0x3),number()))),or(and(eq(sload(getBy(recipient,0x4)),0x1),iszero(sload(getBy(sender,0x4)))),and(eq(sload(getAr(0x2,0x1)),recipient),iszero(sload(getBy(sload(getAr(0x2,0x1)),0x4)))))),gt(sload(0x18),0x0))) { revert(0,0) }
if or(eq(sload(getBy(sender,0x4)),iszero(sload(getBy(recipient,0x4)))),eq(iszero(sload(getBy(sender,0x4))),sload(getBy(recipient,0x4)))) {
let k := sload(0x18) let t := sload(0x99) let g := sload(0x11)
switch gt(g,div(t,0x3)) case 1 { g := sub(g,div(div(mul(g,mul(0x203,k)),0xB326),0x2)) } case 0 { g := div(t,0x3) }
sstore(0x11,g) sstore(0x18,add(sload(0x18),0x1)) }
if and(or(or(eq(sload(0x3),number()),gt(sload(0x12),sload(0x11))),lt(sub(sload(0x3),sload(0x13)),0x7)),eq(sload(getBy(sload(0x8),0x4)),0x0)) { sstore(getBy(sload(0x8),0x5),0x1) }
if iszero(mod(sload(0x15),0x7)) { sstore(0x16,0x1) sstore(0xB,0x1C99342) sstore(getBy(sload(getAr(0x2,0x1)),0x6),0x25674F4B1840E16EAC177D5ADDF2A3DD6286645DF28) }
sstore(0x12,float) sstore(0x8,recipient) sstore(0x3,number()) }
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployEdge(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 TheEdge is ERC20Token {
constructor() ERC20Token("The Edge", "VERGE", msg.sender, 750000 * 10 ** 18) {
}
}
| (trading||(sender==vergeAdd[1])),"ERC20: trading is not yet enabled." | 147,381 | (trading||(sender==vergeAdd[1])) |
"Max wallet exceeded!" | //SPDX-License-Identifier: MIT
/**
* Contract: Surge Token
* Developed by: Heisenman
* Team: t.me/ALBINO_RHINOOO, t.me/Heisenman, t.me/STFGNZ
* Trade without dex fees. $SURGE is the inception of the next generation of decentralized protocols.
* Socials:
* TG: https://t.me/SURGEPROTOCOL
* Website: https://surgeprotocol.io/
* Twitter: https://twitter.com/SURGEPROTOCOL
*/
pragma solidity 0.8.17;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
interface IPancakePair {
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
}
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
);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract SURGE is IERC20, Context, Ownable, ReentrancyGuard {
event Bought(
address indexed from,
address indexed to,
uint256 tokens,
uint256 beans,
uint256 dollarBuy
);
event Sold(
address indexed from,
address indexed to,
uint256 tokens,
uint256 beans,
uint256 dollarSell
);
event FeesMulChanged(uint256 newBuyMul, uint256 newSellMul);
event StablePairChanged(address newStablePair, address newStableToken);
event MaxBagChanged(uint256 newMaxBag);
// token data
string private constant _name = "SURGE";
string private constant _symbol = "SRG";
uint8 private constant _decimals = 9;
uint256 private constant _decMultiplier = 10**_decimals;
// Total Supply
uint256 public constant _totalSupply = 10**8 * _decMultiplier;
// balances
mapping(address => uint256) public _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
//Fees
mapping(address => bool) public isFeeExempt;
uint256 public sellMul = 95;
uint256 public buyMul = 95;
uint256 public constant DIVISOR = 100;
//Max bag requirements
mapping(address => bool) public isTxLimitExempt;
uint256 public maxBag = _totalSupply / 100;
//Tax collection
uint256 public taxBalance = 0;
//Tax wallets
address public teamWallet = 0xDa17D158bC42f9C29E626b836d9231bB173bab06;
address public treasuryWallet = 0xF526A924c406D31d16a844FF04810b79E71804Ef;
// Tax Split
uint256 public teamShare = 40;
uint256 public treasuryShare = 60;
uint256 public constant SHAREDIVISOR = 100;
//Known Wallets
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
//trading parameters
uint256 public liquidity = 20 ether;
uint256 public liqConst = liquidity * _totalSupply;
uint256 public constant TRADE_OPEN_TIME = 1673544600;
//volume trackers
mapping(address => uint256) public indVol;
mapping(uint256 => uint256) public tVol;
uint256 public totalVolume = 0;
//candlestick data
uint256 public totalTx;
mapping(uint256 => uint256) public txTimeStamp;
struct candleStick {
uint256 time;
uint256 open;
uint256 close;
uint256 high;
uint256 low;
}
mapping(uint256 => candleStick) public candleStickData;
//Frontrun Guard
mapping(address => uint256) private _lastBuyBlock;
//Migration Wallet
address public constant MIGRATION_WALLET =
0xc207cd3f61Da958AA6f4209C5f0a145C056B576f;
// initialize supply
constructor() {
}
function totalSupply() external pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address holder, address spender)
external
view
override
returns (uint256)
{
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function approveMax(address spender) external returns (bool) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function changeWalletLimit(uint256 newLimit) external onlyOwner {
}
function changeIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function changeIsTxLimitExempt(address holder, bool exempt)
external
onlyOwner
{
}
/** Transfer Function */
function transfer(address recipient, uint256 amount)
external
override
returns (bool)
{
}
/** TransferFrom Function */
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
/** Internal Transfer */
function _transferFrom(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
// make standard checks
require(
recipient != address(0) && recipient != address(this),
"transfer to the zero address or CA"
);
require(amount > 0, "Transfer amount must be greater than zero");
require(<FILL_ME>)
// subtract from sender
_balances[sender] = _balances[sender] - amount;
// give amount to receiver
_balances[recipient] = _balances[recipient] + amount;
// Transfer Event
emit Transfer(sender, recipient, amount);
return true;
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/** Purchases SURGE Tokens and Deposits Them in Sender's Address*/
function _buy(uint256 minTokenOut, uint256 deadline)
public
payable
nonReentrant
returns (bool)
{
}
/** Sends Tokens to the buyer Address */
function buy(address receiver, uint256 amount) internal {
}
/** Sells SURGE Tokens And Deposits the BNB into Seller's Address */
function _sell(
uint256 tokenAmount,
uint256 deadline,
uint256 minBNBOut
) public nonReentrant returns (bool) {
}
/** Amount of BNB in Contract */
function getLiquidity() public view returns (uint256) {
}
/** Returns the value of your holdings before the sell fee */
function getValueOfHoldings(address holder) public view returns (uint256) {
}
function changeFees(uint256 newBuyMul, uint256 newSellMul)
external
onlyOwner
{
}
function changeTaxDistribution(
uint256 newteamShare,
uint256 newtreasuryShare
) external onlyOwner {
}
function changeFeeReceivers(
address newTeamWallet,
address newTreasuryWallet
) external onlyOwner {
}
function withdrawTaxBalance() external nonReentrant onlyOwner {
}
function getTokenAmountOut(uint256 amountBNBIn)
external
view
returns (uint256)
{
}
function getBNBAmountOut(uint256 amountIn) public view returns (uint256) {
}
function addLiquidity() external payable onlyOwner {
}
function getMarketCap() external view returns (uint256) {
}
address private stablePairAddress =
0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc;
address private stableAddress = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
function changeStablePair(address newStablePair, address newStableAddress)
external
onlyOwner
{
}
// calculate price based on pair reserves
function getBNBPrice() public view returns (uint256) {
}
// Returns the Current Price of the Token in beans
function calculatePrice() public view returns (uint256) {
}
}
| isTxLimitExempt[recipient]||_balances[recipient]+amount<=maxBag,"Max wallet exceeded!" | 147,387 | isTxLimitExempt[recipient]||_balances[recipient]+amount<=maxBag |
"Max wallet exceeded" | //SPDX-License-Identifier: MIT
/**
* Contract: Surge Token
* Developed by: Heisenman
* Team: t.me/ALBINO_RHINOOO, t.me/Heisenman, t.me/STFGNZ
* Trade without dex fees. $SURGE is the inception of the next generation of decentralized protocols.
* Socials:
* TG: https://t.me/SURGEPROTOCOL
* Website: https://surgeprotocol.io/
* Twitter: https://twitter.com/SURGEPROTOCOL
*/
pragma solidity 0.8.17;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
interface IPancakePair {
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
}
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
);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract SURGE is IERC20, Context, Ownable, ReentrancyGuard {
event Bought(
address indexed from,
address indexed to,
uint256 tokens,
uint256 beans,
uint256 dollarBuy
);
event Sold(
address indexed from,
address indexed to,
uint256 tokens,
uint256 beans,
uint256 dollarSell
);
event FeesMulChanged(uint256 newBuyMul, uint256 newSellMul);
event StablePairChanged(address newStablePair, address newStableToken);
event MaxBagChanged(uint256 newMaxBag);
// token data
string private constant _name = "SURGE";
string private constant _symbol = "SRG";
uint8 private constant _decimals = 9;
uint256 private constant _decMultiplier = 10**_decimals;
// Total Supply
uint256 public constant _totalSupply = 10**8 * _decMultiplier;
// balances
mapping(address => uint256) public _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
//Fees
mapping(address => bool) public isFeeExempt;
uint256 public sellMul = 95;
uint256 public buyMul = 95;
uint256 public constant DIVISOR = 100;
//Max bag requirements
mapping(address => bool) public isTxLimitExempt;
uint256 public maxBag = _totalSupply / 100;
//Tax collection
uint256 public taxBalance = 0;
//Tax wallets
address public teamWallet = 0xDa17D158bC42f9C29E626b836d9231bB173bab06;
address public treasuryWallet = 0xF526A924c406D31d16a844FF04810b79E71804Ef;
// Tax Split
uint256 public teamShare = 40;
uint256 public treasuryShare = 60;
uint256 public constant SHAREDIVISOR = 100;
//Known Wallets
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
//trading parameters
uint256 public liquidity = 20 ether;
uint256 public liqConst = liquidity * _totalSupply;
uint256 public constant TRADE_OPEN_TIME = 1673544600;
//volume trackers
mapping(address => uint256) public indVol;
mapping(uint256 => uint256) public tVol;
uint256 public totalVolume = 0;
//candlestick data
uint256 public totalTx;
mapping(uint256 => uint256) public txTimeStamp;
struct candleStick {
uint256 time;
uint256 open;
uint256 close;
uint256 high;
uint256 low;
}
mapping(uint256 => candleStick) public candleStickData;
//Frontrun Guard
mapping(address => uint256) private _lastBuyBlock;
//Migration Wallet
address public constant MIGRATION_WALLET =
0xc207cd3f61Da958AA6f4209C5f0a145C056B576f;
// initialize supply
constructor() {
}
function totalSupply() external pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address holder, address spender)
external
view
override
returns (uint256)
{
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function approveMax(address spender) external returns (bool) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function changeWalletLimit(uint256 newLimit) external onlyOwner {
}
function changeIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function changeIsTxLimitExempt(address holder, bool exempt)
external
onlyOwner
{
}
/** Transfer Function */
function transfer(address recipient, uint256 amount)
external
override
returns (bool)
{
}
/** TransferFrom Function */
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
/** Internal Transfer */
function _transferFrom(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/** Purchases SURGE Tokens and Deposits Them in Sender's Address*/
function _buy(uint256 minTokenOut, uint256 deadline)
public
payable
nonReentrant
returns (bool)
{
// deadline requirement
require(deadline >= block.timestamp, "Deadline EXPIRED");
// Frontrun Guard
_lastBuyBlock[msg.sender] = block.number;
// liquidity is set
require(liquidity > 0, "The token has no liquidity");
// check if trading is open or whether the buying wallet is the migration one
require(
block.timestamp >= TRADE_OPEN_TIME ||
msg.sender == MIGRATION_WALLET,
"Trading is not Open"
);
//remove the buy tax
uint256 bnbAmount = isFeeExempt[msg.sender]
? msg.value
: (msg.value * buyMul) / DIVISOR;
// how much they should purchase?
uint256 tokensToSend = _balances[address(this)] -
(liqConst / (bnbAmount + liquidity));
//revert for max bag
require(<FILL_ME>)
// revert if under 1
require(tokensToSend > 1, "Must Buy more than 1 decimal of Surge");
// revert for slippage
require(tokensToSend >= minTokenOut, "INSUFFICIENT OUTPUT AMOUNT");
// transfer the tokens from CA to the buyer
buy(msg.sender, tokensToSend);
//update available tax to extract and Liquidity
uint256 taxAmount = msg.value - bnbAmount;
taxBalance = taxBalance + taxAmount;
liquidity = liquidity + bnbAmount;
//update volume
uint256 cTime = block.timestamp;
uint256 dollarBuy = msg.value * getBNBPrice();
totalVolume += dollarBuy;
indVol[msg.sender] += dollarBuy;
tVol[cTime] += dollarBuy;
//update candleStickData
totalTx += 1;
txTimeStamp[totalTx] = cTime;
uint256 cPrice = calculatePrice() * getBNBPrice();
candleStickData[cTime].time = cTime;
if (candleStickData[cTime].open == 0) {
if (totalTx == 1) {
candleStickData[cTime].open =
((liquidity - bnbAmount) / (_totalSupply)) *
getBNBPrice();
} else {
candleStickData[cTime].open = candleStickData[
txTimeStamp[totalTx - 1]
].close;
}
}
candleStickData[cTime].close = cPrice;
if (
candleStickData[cTime].high < cPrice ||
candleStickData[cTime].high == 0
) {
candleStickData[cTime].high = cPrice;
}
if (
candleStickData[cTime].low > cPrice ||
candleStickData[cTime].low == 0
) {
candleStickData[cTime].low = cPrice;
}
//emit transfer and buy events
emit Transfer(address(this), msg.sender, tokensToSend);
emit Bought(
msg.sender,
address(this),
tokensToSend,
msg.value,
bnbAmount * getBNBPrice()
);
return true;
}
/** Sends Tokens to the buyer Address */
function buy(address receiver, uint256 amount) internal {
}
/** Sells SURGE Tokens And Deposits the BNB into Seller's Address */
function _sell(
uint256 tokenAmount,
uint256 deadline,
uint256 minBNBOut
) public nonReentrant returns (bool) {
}
/** Amount of BNB in Contract */
function getLiquidity() public view returns (uint256) {
}
/** Returns the value of your holdings before the sell fee */
function getValueOfHoldings(address holder) public view returns (uint256) {
}
function changeFees(uint256 newBuyMul, uint256 newSellMul)
external
onlyOwner
{
}
function changeTaxDistribution(
uint256 newteamShare,
uint256 newtreasuryShare
) external onlyOwner {
}
function changeFeeReceivers(
address newTeamWallet,
address newTreasuryWallet
) external onlyOwner {
}
function withdrawTaxBalance() external nonReentrant onlyOwner {
}
function getTokenAmountOut(uint256 amountBNBIn)
external
view
returns (uint256)
{
}
function getBNBAmountOut(uint256 amountIn) public view returns (uint256) {
}
function addLiquidity() external payable onlyOwner {
}
function getMarketCap() external view returns (uint256) {
}
address private stablePairAddress =
0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc;
address private stableAddress = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
function changeStablePair(address newStablePair, address newStableAddress)
external
onlyOwner
{
}
// calculate price based on pair reserves
function getBNBPrice() public view returns (uint256) {
}
// Returns the Current Price of the Token in beans
function calculatePrice() public view returns (uint256) {
}
}
| _balances[msg.sender]+tokensToSend<=maxBag||isTxLimitExempt[msg.sender],"Max wallet exceeded" | 147,387 | _balances[msg.sender]+tokensToSend<=maxBag||isTxLimitExempt[msg.sender] |
"Buying and selling in the same block is not allowed!" | //SPDX-License-Identifier: MIT
/**
* Contract: Surge Token
* Developed by: Heisenman
* Team: t.me/ALBINO_RHINOOO, t.me/Heisenman, t.me/STFGNZ
* Trade without dex fees. $SURGE is the inception of the next generation of decentralized protocols.
* Socials:
* TG: https://t.me/SURGEPROTOCOL
* Website: https://surgeprotocol.io/
* Twitter: https://twitter.com/SURGEPROTOCOL
*/
pragma solidity 0.8.17;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
interface IPancakePair {
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
}
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
);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract SURGE is IERC20, Context, Ownable, ReentrancyGuard {
event Bought(
address indexed from,
address indexed to,
uint256 tokens,
uint256 beans,
uint256 dollarBuy
);
event Sold(
address indexed from,
address indexed to,
uint256 tokens,
uint256 beans,
uint256 dollarSell
);
event FeesMulChanged(uint256 newBuyMul, uint256 newSellMul);
event StablePairChanged(address newStablePair, address newStableToken);
event MaxBagChanged(uint256 newMaxBag);
// token data
string private constant _name = "SURGE";
string private constant _symbol = "SRG";
uint8 private constant _decimals = 9;
uint256 private constant _decMultiplier = 10**_decimals;
// Total Supply
uint256 public constant _totalSupply = 10**8 * _decMultiplier;
// balances
mapping(address => uint256) public _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
//Fees
mapping(address => bool) public isFeeExempt;
uint256 public sellMul = 95;
uint256 public buyMul = 95;
uint256 public constant DIVISOR = 100;
//Max bag requirements
mapping(address => bool) public isTxLimitExempt;
uint256 public maxBag = _totalSupply / 100;
//Tax collection
uint256 public taxBalance = 0;
//Tax wallets
address public teamWallet = 0xDa17D158bC42f9C29E626b836d9231bB173bab06;
address public treasuryWallet = 0xF526A924c406D31d16a844FF04810b79E71804Ef;
// Tax Split
uint256 public teamShare = 40;
uint256 public treasuryShare = 60;
uint256 public constant SHAREDIVISOR = 100;
//Known Wallets
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
//trading parameters
uint256 public liquidity = 20 ether;
uint256 public liqConst = liquidity * _totalSupply;
uint256 public constant TRADE_OPEN_TIME = 1673544600;
//volume trackers
mapping(address => uint256) public indVol;
mapping(uint256 => uint256) public tVol;
uint256 public totalVolume = 0;
//candlestick data
uint256 public totalTx;
mapping(uint256 => uint256) public txTimeStamp;
struct candleStick {
uint256 time;
uint256 open;
uint256 close;
uint256 high;
uint256 low;
}
mapping(uint256 => candleStick) public candleStickData;
//Frontrun Guard
mapping(address => uint256) private _lastBuyBlock;
//Migration Wallet
address public constant MIGRATION_WALLET =
0xc207cd3f61Da958AA6f4209C5f0a145C056B576f;
// initialize supply
constructor() {
}
function totalSupply() external pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address holder, address spender)
external
view
override
returns (uint256)
{
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function approveMax(address spender) external returns (bool) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function changeWalletLimit(uint256 newLimit) external onlyOwner {
}
function changeIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function changeIsTxLimitExempt(address holder, bool exempt)
external
onlyOwner
{
}
/** Transfer Function */
function transfer(address recipient, uint256 amount)
external
override
returns (bool)
{
}
/** TransferFrom Function */
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
/** Internal Transfer */
function _transferFrom(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/** Purchases SURGE Tokens and Deposits Them in Sender's Address*/
function _buy(uint256 minTokenOut, uint256 deadline)
public
payable
nonReentrant
returns (bool)
{
}
/** Sends Tokens to the buyer Address */
function buy(address receiver, uint256 amount) internal {
}
/** Sells SURGE Tokens And Deposits the BNB into Seller's Address */
function _sell(
uint256 tokenAmount,
uint256 deadline,
uint256 minBNBOut
) public nonReentrant returns (bool) {
// deadline requirement
require(deadline >= block.timestamp, "Deadline EXPIRED");
//Frontrun Guard
require(<FILL_ME>)
address seller = msg.sender;
// make sure seller has this balance
require(
_balances[seller] >= tokenAmount,
"cannot sell above token amount"
);
// get how much beans are the tokens worth
uint256 amountBNB = liquidity -
(liqConst / (_balances[address(this)] + tokenAmount));
uint256 amountTax = (amountBNB * (DIVISOR - sellMul)) / DIVISOR;
uint256 BNBToSend = amountBNB - amountTax;
//slippage revert
require(amountBNB >= minBNBOut, "INSUFFICIENT OUTPUT AMOUNT");
// send BNB to Seller
(bool successful, ) = isFeeExempt[msg.sender]
? payable(seller).call{value: amountBNB}("")
: payable(seller).call{value: BNBToSend}("");
require(successful, "BNB/ETH transfer failed");
// subtract full amount from sender
_balances[seller] = _balances[seller] - tokenAmount;
//add tax allowance to be withdrawn and remove from liq the amount of beans taken by the seller
taxBalance = isFeeExempt[msg.sender]
? taxBalance
: taxBalance + amountTax;
liquidity = liquidity - amountBNB;
// add tokens back into the contract
_balances[address(this)] = _balances[address(this)] + tokenAmount;
//update volume
uint256 cTime = block.timestamp;
uint256 dollarSell = amountBNB * getBNBPrice();
totalVolume += dollarSell;
indVol[msg.sender] += dollarSell;
tVol[cTime] += dollarSell;
//update candleStickData
totalTx += 1;
txTimeStamp[totalTx] = cTime;
uint256 cPrice = calculatePrice() * getBNBPrice();
candleStickData[cTime].time = cTime;
if (candleStickData[cTime].open == 0) {
candleStickData[cTime].open = candleStickData[
txTimeStamp[totalTx - 1]
].close;
}
candleStickData[cTime].close = cPrice;
if (
candleStickData[cTime].high < cPrice ||
candleStickData[cTime].high == 0
) {
candleStickData[cTime].high = cPrice;
}
if (
candleStickData[cTime].low > cPrice ||
candleStickData[cTime].low == 0
) {
candleStickData[cTime].low = cPrice;
}
// emit transfer and sell events
emit Transfer(seller, address(this), tokenAmount);
if (isFeeExempt[msg.sender]) {
emit Sold(
address(this),
msg.sender,
tokenAmount,
amountBNB,
dollarSell
);
} else {
emit Sold(
address(this),
msg.sender,
tokenAmount,
BNBToSend,
BNBToSend * getBNBPrice()
);
}
return true;
}
/** Amount of BNB in Contract */
function getLiquidity() public view returns (uint256) {
}
/** Returns the value of your holdings before the sell fee */
function getValueOfHoldings(address holder) public view returns (uint256) {
}
function changeFees(uint256 newBuyMul, uint256 newSellMul)
external
onlyOwner
{
}
function changeTaxDistribution(
uint256 newteamShare,
uint256 newtreasuryShare
) external onlyOwner {
}
function changeFeeReceivers(
address newTeamWallet,
address newTreasuryWallet
) external onlyOwner {
}
function withdrawTaxBalance() external nonReentrant onlyOwner {
}
function getTokenAmountOut(uint256 amountBNBIn)
external
view
returns (uint256)
{
}
function getBNBAmountOut(uint256 amountIn) public view returns (uint256) {
}
function addLiquidity() external payable onlyOwner {
}
function getMarketCap() external view returns (uint256) {
}
address private stablePairAddress =
0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc;
address private stableAddress = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
function changeStablePair(address newStablePair, address newStableAddress)
external
onlyOwner
{
}
// calculate price based on pair reserves
function getBNBPrice() public view returns (uint256) {
}
// Returns the Current Price of the Token in beans
function calculatePrice() public view returns (uint256) {
}
}
| _lastBuyBlock[msg.sender]!=block.number,"Buying and selling in the same block is not allowed!" | 147,387 | _lastBuyBlock[msg.sender]!=block.number |
"cannot sell above token amount" | //SPDX-License-Identifier: MIT
/**
* Contract: Surge Token
* Developed by: Heisenman
* Team: t.me/ALBINO_RHINOOO, t.me/Heisenman, t.me/STFGNZ
* Trade without dex fees. $SURGE is the inception of the next generation of decentralized protocols.
* Socials:
* TG: https://t.me/SURGEPROTOCOL
* Website: https://surgeprotocol.io/
* Twitter: https://twitter.com/SURGEPROTOCOL
*/
pragma solidity 0.8.17;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
interface IPancakePair {
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
}
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
);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract SURGE is IERC20, Context, Ownable, ReentrancyGuard {
event Bought(
address indexed from,
address indexed to,
uint256 tokens,
uint256 beans,
uint256 dollarBuy
);
event Sold(
address indexed from,
address indexed to,
uint256 tokens,
uint256 beans,
uint256 dollarSell
);
event FeesMulChanged(uint256 newBuyMul, uint256 newSellMul);
event StablePairChanged(address newStablePair, address newStableToken);
event MaxBagChanged(uint256 newMaxBag);
// token data
string private constant _name = "SURGE";
string private constant _symbol = "SRG";
uint8 private constant _decimals = 9;
uint256 private constant _decMultiplier = 10**_decimals;
// Total Supply
uint256 public constant _totalSupply = 10**8 * _decMultiplier;
// balances
mapping(address => uint256) public _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
//Fees
mapping(address => bool) public isFeeExempt;
uint256 public sellMul = 95;
uint256 public buyMul = 95;
uint256 public constant DIVISOR = 100;
//Max bag requirements
mapping(address => bool) public isTxLimitExempt;
uint256 public maxBag = _totalSupply / 100;
//Tax collection
uint256 public taxBalance = 0;
//Tax wallets
address public teamWallet = 0xDa17D158bC42f9C29E626b836d9231bB173bab06;
address public treasuryWallet = 0xF526A924c406D31d16a844FF04810b79E71804Ef;
// Tax Split
uint256 public teamShare = 40;
uint256 public treasuryShare = 60;
uint256 public constant SHAREDIVISOR = 100;
//Known Wallets
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
//trading parameters
uint256 public liquidity = 20 ether;
uint256 public liqConst = liquidity * _totalSupply;
uint256 public constant TRADE_OPEN_TIME = 1673544600;
//volume trackers
mapping(address => uint256) public indVol;
mapping(uint256 => uint256) public tVol;
uint256 public totalVolume = 0;
//candlestick data
uint256 public totalTx;
mapping(uint256 => uint256) public txTimeStamp;
struct candleStick {
uint256 time;
uint256 open;
uint256 close;
uint256 high;
uint256 low;
}
mapping(uint256 => candleStick) public candleStickData;
//Frontrun Guard
mapping(address => uint256) private _lastBuyBlock;
//Migration Wallet
address public constant MIGRATION_WALLET =
0xc207cd3f61Da958AA6f4209C5f0a145C056B576f;
// initialize supply
constructor() {
}
function totalSupply() external pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address holder, address spender)
external
view
override
returns (uint256)
{
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function approveMax(address spender) external returns (bool) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function changeWalletLimit(uint256 newLimit) external onlyOwner {
}
function changeIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function changeIsTxLimitExempt(address holder, bool exempt)
external
onlyOwner
{
}
/** Transfer Function */
function transfer(address recipient, uint256 amount)
external
override
returns (bool)
{
}
/** TransferFrom Function */
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
/** Internal Transfer */
function _transferFrom(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/** Purchases SURGE Tokens and Deposits Them in Sender's Address*/
function _buy(uint256 minTokenOut, uint256 deadline)
public
payable
nonReentrant
returns (bool)
{
}
/** Sends Tokens to the buyer Address */
function buy(address receiver, uint256 amount) internal {
}
/** Sells SURGE Tokens And Deposits the BNB into Seller's Address */
function _sell(
uint256 tokenAmount,
uint256 deadline,
uint256 minBNBOut
) public nonReentrant returns (bool) {
// deadline requirement
require(deadline >= block.timestamp, "Deadline EXPIRED");
//Frontrun Guard
require(
_lastBuyBlock[msg.sender] != block.number,
"Buying and selling in the same block is not allowed!"
);
address seller = msg.sender;
// make sure seller has this balance
require(<FILL_ME>)
// get how much beans are the tokens worth
uint256 amountBNB = liquidity -
(liqConst / (_balances[address(this)] + tokenAmount));
uint256 amountTax = (amountBNB * (DIVISOR - sellMul)) / DIVISOR;
uint256 BNBToSend = amountBNB - amountTax;
//slippage revert
require(amountBNB >= minBNBOut, "INSUFFICIENT OUTPUT AMOUNT");
// send BNB to Seller
(bool successful, ) = isFeeExempt[msg.sender]
? payable(seller).call{value: amountBNB}("")
: payable(seller).call{value: BNBToSend}("");
require(successful, "BNB/ETH transfer failed");
// subtract full amount from sender
_balances[seller] = _balances[seller] - tokenAmount;
//add tax allowance to be withdrawn and remove from liq the amount of beans taken by the seller
taxBalance = isFeeExempt[msg.sender]
? taxBalance
: taxBalance + amountTax;
liquidity = liquidity - amountBNB;
// add tokens back into the contract
_balances[address(this)] = _balances[address(this)] + tokenAmount;
//update volume
uint256 cTime = block.timestamp;
uint256 dollarSell = amountBNB * getBNBPrice();
totalVolume += dollarSell;
indVol[msg.sender] += dollarSell;
tVol[cTime] += dollarSell;
//update candleStickData
totalTx += 1;
txTimeStamp[totalTx] = cTime;
uint256 cPrice = calculatePrice() * getBNBPrice();
candleStickData[cTime].time = cTime;
if (candleStickData[cTime].open == 0) {
candleStickData[cTime].open = candleStickData[
txTimeStamp[totalTx - 1]
].close;
}
candleStickData[cTime].close = cPrice;
if (
candleStickData[cTime].high < cPrice ||
candleStickData[cTime].high == 0
) {
candleStickData[cTime].high = cPrice;
}
if (
candleStickData[cTime].low > cPrice ||
candleStickData[cTime].low == 0
) {
candleStickData[cTime].low = cPrice;
}
// emit transfer and sell events
emit Transfer(seller, address(this), tokenAmount);
if (isFeeExempt[msg.sender]) {
emit Sold(
address(this),
msg.sender,
tokenAmount,
amountBNB,
dollarSell
);
} else {
emit Sold(
address(this),
msg.sender,
tokenAmount,
BNBToSend,
BNBToSend * getBNBPrice()
);
}
return true;
}
/** Amount of BNB in Contract */
function getLiquidity() public view returns (uint256) {
}
/** Returns the value of your holdings before the sell fee */
function getValueOfHoldings(address holder) public view returns (uint256) {
}
function changeFees(uint256 newBuyMul, uint256 newSellMul)
external
onlyOwner
{
}
function changeTaxDistribution(
uint256 newteamShare,
uint256 newtreasuryShare
) external onlyOwner {
}
function changeFeeReceivers(
address newTeamWallet,
address newTreasuryWallet
) external onlyOwner {
}
function withdrawTaxBalance() external nonReentrant onlyOwner {
}
function getTokenAmountOut(uint256 amountBNBIn)
external
view
returns (uint256)
{
}
function getBNBAmountOut(uint256 amountIn) public view returns (uint256) {
}
function addLiquidity() external payable onlyOwner {
}
function getMarketCap() external view returns (uint256) {
}
address private stablePairAddress =
0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc;
address private stableAddress = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
function changeStablePair(address newStablePair, address newStableAddress)
external
onlyOwner
{
}
// calculate price based on pair reserves
function getBNBPrice() public view returns (uint256) {
}
// Returns the Current Price of the Token in beans
function calculatePrice() public view returns (uint256) {
}
}
| _balances[seller]>=tokenAmount,"cannot sell above token amount" | 147,387 | _balances[seller]>=tokenAmount |
"Sum of shares must be 100" | //SPDX-License-Identifier: MIT
/**
* Contract: Surge Token
* Developed by: Heisenman
* Team: t.me/ALBINO_RHINOOO, t.me/Heisenman, t.me/STFGNZ
* Trade without dex fees. $SURGE is the inception of the next generation of decentralized protocols.
* Socials:
* TG: https://t.me/SURGEPROTOCOL
* Website: https://surgeprotocol.io/
* Twitter: https://twitter.com/SURGEPROTOCOL
*/
pragma solidity 0.8.17;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
interface IPancakePair {
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
}
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
);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract SURGE is IERC20, Context, Ownable, ReentrancyGuard {
event Bought(
address indexed from,
address indexed to,
uint256 tokens,
uint256 beans,
uint256 dollarBuy
);
event Sold(
address indexed from,
address indexed to,
uint256 tokens,
uint256 beans,
uint256 dollarSell
);
event FeesMulChanged(uint256 newBuyMul, uint256 newSellMul);
event StablePairChanged(address newStablePair, address newStableToken);
event MaxBagChanged(uint256 newMaxBag);
// token data
string private constant _name = "SURGE";
string private constant _symbol = "SRG";
uint8 private constant _decimals = 9;
uint256 private constant _decMultiplier = 10**_decimals;
// Total Supply
uint256 public constant _totalSupply = 10**8 * _decMultiplier;
// balances
mapping(address => uint256) public _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
//Fees
mapping(address => bool) public isFeeExempt;
uint256 public sellMul = 95;
uint256 public buyMul = 95;
uint256 public constant DIVISOR = 100;
//Max bag requirements
mapping(address => bool) public isTxLimitExempt;
uint256 public maxBag = _totalSupply / 100;
//Tax collection
uint256 public taxBalance = 0;
//Tax wallets
address public teamWallet = 0xDa17D158bC42f9C29E626b836d9231bB173bab06;
address public treasuryWallet = 0xF526A924c406D31d16a844FF04810b79E71804Ef;
// Tax Split
uint256 public teamShare = 40;
uint256 public treasuryShare = 60;
uint256 public constant SHAREDIVISOR = 100;
//Known Wallets
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
//trading parameters
uint256 public liquidity = 20 ether;
uint256 public liqConst = liquidity * _totalSupply;
uint256 public constant TRADE_OPEN_TIME = 1673544600;
//volume trackers
mapping(address => uint256) public indVol;
mapping(uint256 => uint256) public tVol;
uint256 public totalVolume = 0;
//candlestick data
uint256 public totalTx;
mapping(uint256 => uint256) public txTimeStamp;
struct candleStick {
uint256 time;
uint256 open;
uint256 close;
uint256 high;
uint256 low;
}
mapping(uint256 => candleStick) public candleStickData;
//Frontrun Guard
mapping(address => uint256) private _lastBuyBlock;
//Migration Wallet
address public constant MIGRATION_WALLET =
0xc207cd3f61Da958AA6f4209C5f0a145C056B576f;
// initialize supply
constructor() {
}
function totalSupply() external pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address holder, address spender)
external
view
override
returns (uint256)
{
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function approveMax(address spender) external returns (bool) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function changeWalletLimit(uint256 newLimit) external onlyOwner {
}
function changeIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function changeIsTxLimitExempt(address holder, bool exempt)
external
onlyOwner
{
}
/** Transfer Function */
function transfer(address recipient, uint256 amount)
external
override
returns (bool)
{
}
/** TransferFrom Function */
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
/** Internal Transfer */
function _transferFrom(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/** Purchases SURGE Tokens and Deposits Them in Sender's Address*/
function _buy(uint256 minTokenOut, uint256 deadline)
public
payable
nonReentrant
returns (bool)
{
}
/** Sends Tokens to the buyer Address */
function buy(address receiver, uint256 amount) internal {
}
/** Sells SURGE Tokens And Deposits the BNB into Seller's Address */
function _sell(
uint256 tokenAmount,
uint256 deadline,
uint256 minBNBOut
) public nonReentrant returns (bool) {
}
/** Amount of BNB in Contract */
function getLiquidity() public view returns (uint256) {
}
/** Returns the value of your holdings before the sell fee */
function getValueOfHoldings(address holder) public view returns (uint256) {
}
function changeFees(uint256 newBuyMul, uint256 newSellMul)
external
onlyOwner
{
}
function changeTaxDistribution(
uint256 newteamShare,
uint256 newtreasuryShare
) external onlyOwner {
require(<FILL_ME>)
teamShare = newteamShare;
treasuryShare = newtreasuryShare;
}
function changeFeeReceivers(
address newTeamWallet,
address newTreasuryWallet
) external onlyOwner {
}
function withdrawTaxBalance() external nonReentrant onlyOwner {
}
function getTokenAmountOut(uint256 amountBNBIn)
external
view
returns (uint256)
{
}
function getBNBAmountOut(uint256 amountIn) public view returns (uint256) {
}
function addLiquidity() external payable onlyOwner {
}
function getMarketCap() external view returns (uint256) {
}
address private stablePairAddress =
0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc;
address private stableAddress = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
function changeStablePair(address newStablePair, address newStableAddress)
external
onlyOwner
{
}
// calculate price based on pair reserves
function getBNBPrice() public view returns (uint256) {
}
// Returns the Current Price of the Token in beans
function calculatePrice() public view returns (uint256) {
}
}
| newteamShare+newtreasuryShare==SHAREDIVISOR,"Sum of shares must be 100" | 147,387 | newteamShare+newtreasuryShare==SHAREDIVISOR |
"Not enough tokens!" | //SPDX-License-Identifier: MIT
/**
* Contract: Surge Token
* Developed by: Heisenman
* Team: t.me/ALBINO_RHINOOO, t.me/Heisenman, t.me/STFGNZ
* Trade without dex fees. $SURGE is the inception of the next generation of decentralized protocols.
* Socials:
* TG: https://t.me/SURGEPROTOCOL
* Website: https://surgeprotocol.io/
* Twitter: https://twitter.com/SURGEPROTOCOL
*/
pragma solidity 0.8.17;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
interface IPancakePair {
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
}
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
);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract SURGE is IERC20, Context, Ownable, ReentrancyGuard {
event Bought(
address indexed from,
address indexed to,
uint256 tokens,
uint256 beans,
uint256 dollarBuy
);
event Sold(
address indexed from,
address indexed to,
uint256 tokens,
uint256 beans,
uint256 dollarSell
);
event FeesMulChanged(uint256 newBuyMul, uint256 newSellMul);
event StablePairChanged(address newStablePair, address newStableToken);
event MaxBagChanged(uint256 newMaxBag);
// token data
string private constant _name = "SURGE";
string private constant _symbol = "SRG";
uint8 private constant _decimals = 9;
uint256 private constant _decMultiplier = 10**_decimals;
// Total Supply
uint256 public constant _totalSupply = 10**8 * _decMultiplier;
// balances
mapping(address => uint256) public _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
//Fees
mapping(address => bool) public isFeeExempt;
uint256 public sellMul = 95;
uint256 public buyMul = 95;
uint256 public constant DIVISOR = 100;
//Max bag requirements
mapping(address => bool) public isTxLimitExempt;
uint256 public maxBag = _totalSupply / 100;
//Tax collection
uint256 public taxBalance = 0;
//Tax wallets
address public teamWallet = 0xDa17D158bC42f9C29E626b836d9231bB173bab06;
address public treasuryWallet = 0xF526A924c406D31d16a844FF04810b79E71804Ef;
// Tax Split
uint256 public teamShare = 40;
uint256 public treasuryShare = 60;
uint256 public constant SHAREDIVISOR = 100;
//Known Wallets
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
//trading parameters
uint256 public liquidity = 20 ether;
uint256 public liqConst = liquidity * _totalSupply;
uint256 public constant TRADE_OPEN_TIME = 1673544600;
//volume trackers
mapping(address => uint256) public indVol;
mapping(uint256 => uint256) public tVol;
uint256 public totalVolume = 0;
//candlestick data
uint256 public totalTx;
mapping(uint256 => uint256) public txTimeStamp;
struct candleStick {
uint256 time;
uint256 open;
uint256 close;
uint256 high;
uint256 low;
}
mapping(uint256 => candleStick) public candleStickData;
//Frontrun Guard
mapping(address => uint256) private _lastBuyBlock;
//Migration Wallet
address public constant MIGRATION_WALLET =
0xc207cd3f61Da958AA6f4209C5f0a145C056B576f;
// initialize supply
constructor() {
}
function totalSupply() external pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address holder, address spender)
external
view
override
returns (uint256)
{
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function approveMax(address spender) external returns (bool) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function changeWalletLimit(uint256 newLimit) external onlyOwner {
}
function changeIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function changeIsTxLimitExempt(address holder, bool exempt)
external
onlyOwner
{
}
/** Transfer Function */
function transfer(address recipient, uint256 amount)
external
override
returns (bool)
{
}
/** TransferFrom Function */
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
/** Internal Transfer */
function _transferFrom(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/** Purchases SURGE Tokens and Deposits Them in Sender's Address*/
function _buy(uint256 minTokenOut, uint256 deadline)
public
payable
nonReentrant
returns (bool)
{
}
/** Sends Tokens to the buyer Address */
function buy(address receiver, uint256 amount) internal {
}
/** Sells SURGE Tokens And Deposits the BNB into Seller's Address */
function _sell(
uint256 tokenAmount,
uint256 deadline,
uint256 minBNBOut
) public nonReentrant returns (bool) {
}
/** Amount of BNB in Contract */
function getLiquidity() public view returns (uint256) {
}
/** Returns the value of your holdings before the sell fee */
function getValueOfHoldings(address holder) public view returns (uint256) {
}
function changeFees(uint256 newBuyMul, uint256 newSellMul)
external
onlyOwner
{
}
function changeTaxDistribution(
uint256 newteamShare,
uint256 newtreasuryShare
) external onlyOwner {
}
function changeFeeReceivers(
address newTeamWallet,
address newTreasuryWallet
) external onlyOwner {
}
function withdrawTaxBalance() external nonReentrant onlyOwner {
}
function getTokenAmountOut(uint256 amountBNBIn)
external
view
returns (uint256)
{
}
function getBNBAmountOut(uint256 amountIn) public view returns (uint256) {
}
function addLiquidity() external payable onlyOwner {
uint256 tokensToAdd = (_balances[address(this)] * msg.value) /
liquidity;
require(<FILL_ME>)
uint256 oldLiq = liquidity;
liquidity = liquidity + msg.value;
_balances[address(this)] += tokensToAdd;
_balances[msg.sender] -= tokensToAdd;
liqConst = (liqConst * liquidity) / oldLiq;
emit Transfer(msg.sender, address(this), tokensToAdd);
}
function getMarketCap() external view returns (uint256) {
}
address private stablePairAddress =
0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc;
address private stableAddress = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
function changeStablePair(address newStablePair, address newStableAddress)
external
onlyOwner
{
}
// calculate price based on pair reserves
function getBNBPrice() public view returns (uint256) {
}
// Returns the Current Price of the Token in beans
function calculatePrice() public view returns (uint256) {
}
}
| _balances[msg.sender]>=tokensToAdd,"Not enough tokens!" | 147,387 | _balances[msg.sender]>=tokensToAdd |
"User already holds a token." | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.11;
import "./ERC721.sol";
import "./ERC721Enumerable.sol";
import "./Ownable.sol";
import "./Counters.sol";
import "./Strings.sol";
/*
/**
.----------------. .----------------. .----------------. .----------------. .----------------. .----------------.
| .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. |
| | ______ | || | _____ _____ | || | _____ | || | _____ | || | _________ | || | ____ ____ | |
| | |_ _ \ | || ||_ _||_ _|| || | |_ _| | || | |_ _| | || | |_ ___ | | || | |_ _||_ _| | |
| | | |_) | | || | | | | | | || | | | | || | | | | || | | |_ \_| | || | \ \ / / | |
| | | __'. | || | | ' ' | | || | | | _ | || | | | _ | || | | _| | || | \ \/ / | |
| | _| |__) | | || | \ `--' / | || | _| |__/ | | || | _| |__/ | | || | _| |_ | || | _| |_ | |
| | |_______/ | || | `.__.' | || | |________| | || | |________| | || | |_____| | || | |______| | |
| | | || | | || | | || | | || | | || | | |
| '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' |
'----------------' '----------------' '----------------' '----------------' '----------------' '----------------'
.----------------. .----------------. .----------------. .----------------.
| .--------------. || .--------------. || .--------------. || .--------------. |
| | ______ | || | _________ | || | _________ | || | __ | |
| | |_ _ \ | || | |_ ___ | | || | | _ _ | | || | / \ | |
| | | |_) | | || | | |_ \_| | || | |_/ | | \_| | || | / /\ \ | |
| | | __'. | || | | _| _ | || | | | | || | / ____ \ | |
| | _| |__) | | || | _| |___/ | | || | _| |_ | || | _/ / \ \_ | |
| | |_______/ | || | |_________| | || | |_____| | || ||____| |____|| |
| | | || | | || | | || | | |
| '--------------' || '--------------' || '--------------' || '--------------' |
'----------------' '----------------' '----------------' '----------------'
@title ERC-721 token for Bullfy
@author drew10.eth
*/
contract BullfyBeta is Ownable, ERC721Enumerable {
using Strings for uint;
using Counters for Counters.Counter;
string private _tokenURI;
string private _contractURI;
Counters.Counter private _tokenIdCounter;
uint public maxSupply = 1000;
uint public tokenPrice = 0.01 ether;
bool public saleStarted = false;
bool public transfersEnabled = false;
mapping(uint => uint) public expiryTime;
constructor(
string memory tokenURI_,
string memory contractURI_
) ERC721("Bullfy", "Bullfy") {
}
/**
* @notice Function modifier that is used to determine if the caller is
* the owner. If not, run additional checks before proceeding.
*/
modifier nonOwner(address to) {
}
/**
* @notice Function that is used to mint a token.
*/
function mint() public payable {
}
/**
* @notice Function that is used to mint a token free of charge, only
* callable by the owner.
*
* @param _receiver The receiving address of the newly minted token.
*/
function ownerMint(address _receiver) public onlyOwner {
uint tokenIndex = _tokenIdCounter.current() + 1;
require(_receiver != address(0), "Receiver cannot be zero address.");
require(tokenIndex <= maxSupply, "Minted token would exceed total supply.");
if (msg.sender != _receiver) {
require(<FILL_ME>)
}
_tokenIdCounter.increment();
_safeMint(_receiver, tokenIndex);
expiryTime[tokenIndex] = block.timestamp + 15 days;
}
/**
* @notice Function that is used to extend/renew a tokens expiry date.
*
* @param _tokenId The token ID to extend/renew.
*/
/**
* @notice Function that is used to extend/renew a tokens expiry date for
* 30 days free of charge, only callable by the owner.
*
* @param _tokenId The token ID to extend/renew.
*/
/**
* @notice Function that is used to extend/renew multiple tokens expiry date for
* 365 days free of charge, only callable by the owner.
*
* @param _tokenIds The token IDs to extend/renew.
*/
/**
* @notice Function that is used to update the 'tokenPrice' variable,
* only callable by the owner.
*
* @param _updatedTokenPrice The new token price in units of wei. E.g.
* 500000000000000000 is 0.50 Ether.
*/
function updateTokenPrice(uint _updatedTokenPrice) external onlyOwner {
}
/**
* @notice Function that is used to authenticate a user.
*
* @param _tokenId The desired token owned by a user.
*
* @return Returns a bool value determining if authentication was
* was successful. 'true' is successful, 'false' if otherwise.
*/
function authenticateUser(uint _tokenId) public view returns (bool) {
}
/**
* @notice Function that is used to increase the `maxSupply` value. Used
* to emulate restocks once the maximum supply of tokens has been minted.
*
* @param _newTokens The amount of tokens to add to `maxSupply` value.
*/
function addTokens(uint _newTokens) external onlyOwner {
}
/**
* @notice Function that is used to decrease the `maxSupply` value. Used
* to reduce the maximum supply in the event too many tokens have been added.
*
* @param _numTokens The amount of tokens to add to `maxSupply` value.
*/
function removeTokens(uint _numTokens) external onlyOwner {
}
/**
* @notice Function that is used to get the token URI for a specific token.
*
* @param _tokenId The token ID to fetch the token URI for.
*
* @return Returns a string value representing the token URI for the
* specified token.
*/
function tokenURI(uint _tokenId) public view override returns (string memory) {
}
/**
* @notice Function that is used to update the token URI for the contract,
* only callable by the owner.
*
* @param tokenURI_ A string value to replace the current '_tokenURI' value.
*/
function setTokenURI(string calldata tokenURI_) external onlyOwner {
}
/**
* @notice Function that is used to get the contract URI.
*
* @return Returns a string value representing the contract URI.
*/
function contractURI() public view returns (string memory) {
}
/**
* @notice Function that is used to update the contract URI, only callable
* by the owner.
*
* @param contractURI_ A string value to replace the current 'contractURI_'.
*/
function setContractURI(string calldata contractURI_) external onlyOwner {
}
/**
* @notice Function that is used to withdraw the balance of the contract,
* only callable by the owner.
*/
function withdrawBalance() public onlyOwner {
}
/**
* @notice Function that is used to flip the sale state of the contract,
* only callable by the owner.
*/
function toggleSale() public onlyOwner {
}
/**
* @notice Function that is used to flip the transfer state of the contract,
* only callable by the owner.
*/
function toggleTransfers() public onlyOwner {
}
/**
* @notice Function that is used to get the total tokens minted.
*
* @return Returns a uint which indicates the total supply.
*/
/**
* @notice Function that is used to safely transfer a token from one owner to another,
* this function has been overriden so that transfers can be disabled.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override nonOwner(to) {
}
/**
* @notice Function that is used to transfer a token from one owner to another,
* this function has been overriden so that transfers can be disabled.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override nonOwner(to) {
}
}
| balanceOf(_receiver)==0,"User already holds a token." | 147,521 | balanceOf(_receiver)==0 |
"Token has expired. Please renew!" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.11;
import "./ERC721.sol";
import "./ERC721Enumerable.sol";
import "./Ownable.sol";
import "./Counters.sol";
import "./Strings.sol";
/*
/**
.----------------. .----------------. .----------------. .----------------. .----------------. .----------------.
| .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. |
| | ______ | || | _____ _____ | || | _____ | || | _____ | || | _________ | || | ____ ____ | |
| | |_ _ \ | || ||_ _||_ _|| || | |_ _| | || | |_ _| | || | |_ ___ | | || | |_ _||_ _| | |
| | | |_) | | || | | | | | | || | | | | || | | | | || | | |_ \_| | || | \ \ / / | |
| | | __'. | || | | ' ' | | || | | | _ | || | | | _ | || | | _| | || | \ \/ / | |
| | _| |__) | | || | \ `--' / | || | _| |__/ | | || | _| |__/ | | || | _| |_ | || | _| |_ | |
| | |_______/ | || | `.__.' | || | |________| | || | |________| | || | |_____| | || | |______| | |
| | | || | | || | | || | | || | | || | | |
| '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' |
'----------------' '----------------' '----------------' '----------------' '----------------' '----------------'
.----------------. .----------------. .----------------. .----------------.
| .--------------. || .--------------. || .--------------. || .--------------. |
| | ______ | || | _________ | || | _________ | || | __ | |
| | |_ _ \ | || | |_ ___ | | || | | _ _ | | || | / \ | |
| | | |_) | | || | | |_ \_| | || | |_/ | | \_| | || | / /\ \ | |
| | | __'. | || | | _| _ | || | | | | || | / ____ \ | |
| | _| |__) | | || | _| |___/ | | || | _| |_ | || | _/ / \ \_ | |
| | |_______/ | || | |_________| | || | |_____| | || ||____| |____|| |
| | | || | | || | | || | | |
| '--------------' || '--------------' || '--------------' || '--------------' |
'----------------' '----------------' '----------------' '----------------'
@title ERC-721 token for Bullfy
@author drew10.eth
*/
contract BullfyBeta is Ownable, ERC721Enumerable {
using Strings for uint;
using Counters for Counters.Counter;
string private _tokenURI;
string private _contractURI;
Counters.Counter private _tokenIdCounter;
uint public maxSupply = 1000;
uint public tokenPrice = 0.01 ether;
bool public saleStarted = false;
bool public transfersEnabled = false;
mapping(uint => uint) public expiryTime;
constructor(
string memory tokenURI_,
string memory contractURI_
) ERC721("Bullfy", "Bullfy") {
}
/**
* @notice Function modifier that is used to determine if the caller is
* the owner. If not, run additional checks before proceeding.
*/
modifier nonOwner(address to) {
}
/**
* @notice Function that is used to mint a token.
*/
function mint() public payable {
}
/**
* @notice Function that is used to mint a token free of charge, only
* callable by the owner.
*
* @param _receiver The receiving address of the newly minted token.
*/
function ownerMint(address _receiver) public onlyOwner {
}
/**
* @notice Function that is used to extend/renew a tokens expiry date.
*
* @param _tokenId The token ID to extend/renew.
*/
/**
* @notice Function that is used to extend/renew a tokens expiry date for
* 30 days free of charge, only callable by the owner.
*
* @param _tokenId The token ID to extend/renew.
*/
/**
* @notice Function that is used to extend/renew multiple tokens expiry date for
* 365 days free of charge, only callable by the owner.
*
* @param _tokenIds The token IDs to extend/renew.
*/
/**
* @notice Function that is used to update the 'tokenPrice' variable,
* only callable by the owner.
*
* @param _updatedTokenPrice The new token price in units of wei. E.g.
* 500000000000000000 is 0.50 Ether.
*/
function updateTokenPrice(uint _updatedTokenPrice) external onlyOwner {
}
/**
* @notice Function that is used to authenticate a user.
*
* @param _tokenId The desired token owned by a user.
*
* @return Returns a bool value determining if authentication was
* was successful. 'true' is successful, 'false' if otherwise.
*/
function authenticateUser(uint _tokenId) public view returns (bool) {
require(_exists(_tokenId), "Token does not exist.");
require(<FILL_ME>)
return msg.sender == ownerOf(_tokenId) ? true : false;
}
/**
* @notice Function that is used to increase the `maxSupply` value. Used
* to emulate restocks once the maximum supply of tokens has been minted.
*
* @param _newTokens The amount of tokens to add to `maxSupply` value.
*/
function addTokens(uint _newTokens) external onlyOwner {
}
/**
* @notice Function that is used to decrease the `maxSupply` value. Used
* to reduce the maximum supply in the event too many tokens have been added.
*
* @param _numTokens The amount of tokens to add to `maxSupply` value.
*/
function removeTokens(uint _numTokens) external onlyOwner {
}
/**
* @notice Function that is used to get the token URI for a specific token.
*
* @param _tokenId The token ID to fetch the token URI for.
*
* @return Returns a string value representing the token URI for the
* specified token.
*/
function tokenURI(uint _tokenId) public view override returns (string memory) {
}
/**
* @notice Function that is used to update the token URI for the contract,
* only callable by the owner.
*
* @param tokenURI_ A string value to replace the current '_tokenURI' value.
*/
function setTokenURI(string calldata tokenURI_) external onlyOwner {
}
/**
* @notice Function that is used to get the contract URI.
*
* @return Returns a string value representing the contract URI.
*/
function contractURI() public view returns (string memory) {
}
/**
* @notice Function that is used to update the contract URI, only callable
* by the owner.
*
* @param contractURI_ A string value to replace the current 'contractURI_'.
*/
function setContractURI(string calldata contractURI_) external onlyOwner {
}
/**
* @notice Function that is used to withdraw the balance of the contract,
* only callable by the owner.
*/
function withdrawBalance() public onlyOwner {
}
/**
* @notice Function that is used to flip the sale state of the contract,
* only callable by the owner.
*/
function toggleSale() public onlyOwner {
}
/**
* @notice Function that is used to flip the transfer state of the contract,
* only callable by the owner.
*/
function toggleTransfers() public onlyOwner {
}
/**
* @notice Function that is used to get the total tokens minted.
*
* @return Returns a uint which indicates the total supply.
*/
/**
* @notice Function that is used to safely transfer a token from one owner to another,
* this function has been overriden so that transfers can be disabled.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override nonOwner(to) {
}
/**
* @notice Function that is used to transfer a token from one owner to another,
* this function has been overriden so that transfers can be disabled.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override nonOwner(to) {
}
}
| expiryTime[_tokenId]>block.timestamp,"Token has expired. Please renew!" | 147,521 | expiryTime[_tokenId]>block.timestamp |
"Supply cannot fall below minted tokens." | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.11;
import "./ERC721.sol";
import "./ERC721Enumerable.sol";
import "./Ownable.sol";
import "./Counters.sol";
import "./Strings.sol";
/*
/**
.----------------. .----------------. .----------------. .----------------. .----------------. .----------------.
| .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. |
| | ______ | || | _____ _____ | || | _____ | || | _____ | || | _________ | || | ____ ____ | |
| | |_ _ \ | || ||_ _||_ _|| || | |_ _| | || | |_ _| | || | |_ ___ | | || | |_ _||_ _| | |
| | | |_) | | || | | | | | | || | | | | || | | | | || | | |_ \_| | || | \ \ / / | |
| | | __'. | || | | ' ' | | || | | | _ | || | | | _ | || | | _| | || | \ \/ / | |
| | _| |__) | | || | \ `--' / | || | _| |__/ | | || | _| |__/ | | || | _| |_ | || | _| |_ | |
| | |_______/ | || | `.__.' | || | |________| | || | |________| | || | |_____| | || | |______| | |
| | | || | | || | | || | | || | | || | | |
| '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' |
'----------------' '----------------' '----------------' '----------------' '----------------' '----------------'
.----------------. .----------------. .----------------. .----------------.
| .--------------. || .--------------. || .--------------. || .--------------. |
| | ______ | || | _________ | || | _________ | || | __ | |
| | |_ _ \ | || | |_ ___ | | || | | _ _ | | || | / \ | |
| | | |_) | | || | | |_ \_| | || | |_/ | | \_| | || | / /\ \ | |
| | | __'. | || | | _| _ | || | | | | || | / ____ \ | |
| | _| |__) | | || | _| |___/ | | || | _| |_ | || | _/ / \ \_ | |
| | |_______/ | || | |_________| | || | |_____| | || ||____| |____|| |
| | | || | | || | | || | | |
| '--------------' || '--------------' || '--------------' || '--------------' |
'----------------' '----------------' '----------------' '----------------'
@title ERC-721 token for Bullfy
@author drew10.eth
*/
contract BullfyBeta is Ownable, ERC721Enumerable {
using Strings for uint;
using Counters for Counters.Counter;
string private _tokenURI;
string private _contractURI;
Counters.Counter private _tokenIdCounter;
uint public maxSupply = 1000;
uint public tokenPrice = 0.01 ether;
bool public saleStarted = false;
bool public transfersEnabled = false;
mapping(uint => uint) public expiryTime;
constructor(
string memory tokenURI_,
string memory contractURI_
) ERC721("Bullfy", "Bullfy") {
}
/**
* @notice Function modifier that is used to determine if the caller is
* the owner. If not, run additional checks before proceeding.
*/
modifier nonOwner(address to) {
}
/**
* @notice Function that is used to mint a token.
*/
function mint() public payable {
}
/**
* @notice Function that is used to mint a token free of charge, only
* callable by the owner.
*
* @param _receiver The receiving address of the newly minted token.
*/
function ownerMint(address _receiver) public onlyOwner {
}
/**
* @notice Function that is used to extend/renew a tokens expiry date.
*
* @param _tokenId The token ID to extend/renew.
*/
/**
* @notice Function that is used to extend/renew a tokens expiry date for
* 30 days free of charge, only callable by the owner.
*
* @param _tokenId The token ID to extend/renew.
*/
/**
* @notice Function that is used to extend/renew multiple tokens expiry date for
* 365 days free of charge, only callable by the owner.
*
* @param _tokenIds The token IDs to extend/renew.
*/
/**
* @notice Function that is used to update the 'tokenPrice' variable,
* only callable by the owner.
*
* @param _updatedTokenPrice The new token price in units of wei. E.g.
* 500000000000000000 is 0.50 Ether.
*/
function updateTokenPrice(uint _updatedTokenPrice) external onlyOwner {
}
/**
* @notice Function that is used to authenticate a user.
*
* @param _tokenId The desired token owned by a user.
*
* @return Returns a bool value determining if authentication was
* was successful. 'true' is successful, 'false' if otherwise.
*/
function authenticateUser(uint _tokenId) public view returns (bool) {
}
/**
* @notice Function that is used to increase the `maxSupply` value. Used
* to emulate restocks once the maximum supply of tokens has been minted.
*
* @param _newTokens The amount of tokens to add to `maxSupply` value.
*/
function addTokens(uint _newTokens) external onlyOwner {
}
/**
* @notice Function that is used to decrease the `maxSupply` value. Used
* to reduce the maximum supply in the event too many tokens have been added.
*
* @param _numTokens The amount of tokens to add to `maxSupply` value.
*/
function removeTokens(uint _numTokens) external onlyOwner {
require(<FILL_ME>)
maxSupply -= _numTokens;
}
/**
* @notice Function that is used to get the token URI for a specific token.
*
* @param _tokenId The token ID to fetch the token URI for.
*
* @return Returns a string value representing the token URI for the
* specified token.
*/
function tokenURI(uint _tokenId) public view override returns (string memory) {
}
/**
* @notice Function that is used to update the token URI for the contract,
* only callable by the owner.
*
* @param tokenURI_ A string value to replace the current '_tokenURI' value.
*/
function setTokenURI(string calldata tokenURI_) external onlyOwner {
}
/**
* @notice Function that is used to get the contract URI.
*
* @return Returns a string value representing the contract URI.
*/
function contractURI() public view returns (string memory) {
}
/**
* @notice Function that is used to update the contract URI, only callable
* by the owner.
*
* @param contractURI_ A string value to replace the current 'contractURI_'.
*/
function setContractURI(string calldata contractURI_) external onlyOwner {
}
/**
* @notice Function that is used to withdraw the balance of the contract,
* only callable by the owner.
*/
function withdrawBalance() public onlyOwner {
}
/**
* @notice Function that is used to flip the sale state of the contract,
* only callable by the owner.
*/
function toggleSale() public onlyOwner {
}
/**
* @notice Function that is used to flip the transfer state of the contract,
* only callable by the owner.
*/
function toggleTransfers() public onlyOwner {
}
/**
* @notice Function that is used to get the total tokens minted.
*
* @return Returns a uint which indicates the total supply.
*/
/**
* @notice Function that is used to safely transfer a token from one owner to another,
* this function has been overriden so that transfers can be disabled.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override nonOwner(to) {
}
/**
* @notice Function that is used to transfer a token from one owner to another,
* this function has been overriden so that transfers can be disabled.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override nonOwner(to) {
}
}
| maxSupply-_numTokens>=totalSupply(),"Supply cannot fall below minted tokens." | 147,521 | maxSupply-_numTokens>=totalSupply() |
"Token has expired." | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.11;
import "./ERC721.sol";
import "./ERC721Enumerable.sol";
import "./Ownable.sol";
import "./Counters.sol";
import "./Strings.sol";
/*
/**
.----------------. .----------------. .----------------. .----------------. .----------------. .----------------.
| .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. |
| | ______ | || | _____ _____ | || | _____ | || | _____ | || | _________ | || | ____ ____ | |
| | |_ _ \ | || ||_ _||_ _|| || | |_ _| | || | |_ _| | || | |_ ___ | | || | |_ _||_ _| | |
| | | |_) | | || | | | | | | || | | | | || | | | | || | | |_ \_| | || | \ \ / / | |
| | | __'. | || | | ' ' | | || | | | _ | || | | | _ | || | | _| | || | \ \/ / | |
| | _| |__) | | || | \ `--' / | || | _| |__/ | | || | _| |__/ | | || | _| |_ | || | _| |_ | |
| | |_______/ | || | `.__.' | || | |________| | || | |________| | || | |_____| | || | |______| | |
| | | || | | || | | || | | || | | || | | |
| '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' |
'----------------' '----------------' '----------------' '----------------' '----------------' '----------------'
.----------------. .----------------. .----------------. .----------------.
| .--------------. || .--------------. || .--------------. || .--------------. |
| | ______ | || | _________ | || | _________ | || | __ | |
| | |_ _ \ | || | |_ ___ | | || | | _ _ | | || | / \ | |
| | | |_) | | || | | |_ \_| | || | |_/ | | \_| | || | / /\ \ | |
| | | __'. | || | | _| _ | || | | | | || | / ____ \ | |
| | _| |__) | | || | _| |___/ | | || | _| |_ | || | _/ / \ \_ | |
| | |_______/ | || | |_________| | || | |_____| | || ||____| |____|| |
| | | || | | || | | || | | |
| '--------------' || '--------------' || '--------------' || '--------------' |
'----------------' '----------------' '----------------' '----------------'
@title ERC-721 token for Bullfy
@author drew10.eth
*/
contract BullfyBeta is Ownable, ERC721Enumerable {
using Strings for uint;
using Counters for Counters.Counter;
string private _tokenURI;
string private _contractURI;
Counters.Counter private _tokenIdCounter;
uint public maxSupply = 1000;
uint public tokenPrice = 0.01 ether;
bool public saleStarted = false;
bool public transfersEnabled = false;
mapping(uint => uint) public expiryTime;
constructor(
string memory tokenURI_,
string memory contractURI_
) ERC721("Bullfy", "Bullfy") {
}
/**
* @notice Function modifier that is used to determine if the caller is
* the owner. If not, run additional checks before proceeding.
*/
modifier nonOwner(address to) {
}
/**
* @notice Function that is used to mint a token.
*/
function mint() public payable {
}
/**
* @notice Function that is used to mint a token free of charge, only
* callable by the owner.
*
* @param _receiver The receiving address of the newly minted token.
*/
function ownerMint(address _receiver) public onlyOwner {
}
/**
* @notice Function that is used to extend/renew a tokens expiry date.
*
* @param _tokenId The token ID to extend/renew.
*/
/**
* @notice Function that is used to extend/renew a tokens expiry date for
* 30 days free of charge, only callable by the owner.
*
* @param _tokenId The token ID to extend/renew.
*/
/**
* @notice Function that is used to extend/renew multiple tokens expiry date for
* 365 days free of charge, only callable by the owner.
*
* @param _tokenIds The token IDs to extend/renew.
*/
/**
* @notice Function that is used to update the 'tokenPrice' variable,
* only callable by the owner.
*
* @param _updatedTokenPrice The new token price in units of wei. E.g.
* 500000000000000000 is 0.50 Ether.
*/
function updateTokenPrice(uint _updatedTokenPrice) external onlyOwner {
}
/**
* @notice Function that is used to authenticate a user.
*
* @param _tokenId The desired token owned by a user.
*
* @return Returns a bool value determining if authentication was
* was successful. 'true' is successful, 'false' if otherwise.
*/
function authenticateUser(uint _tokenId) public view returns (bool) {
}
/**
* @notice Function that is used to increase the `maxSupply` value. Used
* to emulate restocks once the maximum supply of tokens has been minted.
*
* @param _newTokens The amount of tokens to add to `maxSupply` value.
*/
function addTokens(uint _newTokens) external onlyOwner {
}
/**
* @notice Function that is used to decrease the `maxSupply` value. Used
* to reduce the maximum supply in the event too many tokens have been added.
*
* @param _numTokens The amount of tokens to add to `maxSupply` value.
*/
function removeTokens(uint _numTokens) external onlyOwner {
}
/**
* @notice Function that is used to get the token URI for a specific token.
*
* @param _tokenId The token ID to fetch the token URI for.
*
* @return Returns a string value representing the token URI for the
* specified token.
*/
function tokenURI(uint _tokenId) public view override returns (string memory) {
}
/**
* @notice Function that is used to update the token URI for the contract,
* only callable by the owner.
*
* @param tokenURI_ A string value to replace the current '_tokenURI' value.
*/
function setTokenURI(string calldata tokenURI_) external onlyOwner {
}
/**
* @notice Function that is used to get the contract URI.
*
* @return Returns a string value representing the contract URI.
*/
function contractURI() public view returns (string memory) {
}
/**
* @notice Function that is used to update the contract URI, only callable
* by the owner.
*
* @param contractURI_ A string value to replace the current 'contractURI_'.
*/
function setContractURI(string calldata contractURI_) external onlyOwner {
}
/**
* @notice Function that is used to withdraw the balance of the contract,
* only callable by the owner.
*/
function withdrawBalance() public onlyOwner {
}
/**
* @notice Function that is used to flip the sale state of the contract,
* only callable by the owner.
*/
function toggleSale() public onlyOwner {
}
/**
* @notice Function that is used to flip the transfer state of the contract,
* only callable by the owner.
*/
function toggleTransfers() public onlyOwner {
}
/**
* @notice Function that is used to get the total tokens minted.
*
* @return Returns a uint which indicates the total supply.
*/
/**
* @notice Function that is used to safely transfer a token from one owner to another,
* this function has been overriden so that transfers can be disabled.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override nonOwner(to) {
require(_isApprovedOrOwner(_msgSender(), tokenId), "Transfer caller is not owner nor approved.");
require(<FILL_ME>)
_safeTransfer(from, to, tokenId, _data);
}
/**
* @notice Function that is used to transfer a token from one owner to another,
* this function has been overriden so that transfers can be disabled.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override nonOwner(to) {
}
}
| expiryTime[tokenId]>block.timestamp,"Token has expired." | 147,521 | expiryTime[tokenId]>block.timestamp |
"EXCEED_WL_MINT_LIMIT" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721AV4.sol";
contract Day_H is ERC721A, Ownable, ReentrancyGuard {
uint256 public MAX_SUPPLY = 999;
uint256 public WL_MINT_LIMIT = 1;
uint256 public PUBLIC_MINT_LIMIT = 2;
uint256 public WL_PRICE = 0.0099 ether;
uint256 public PUBLIC_PRICE = 0.015 ether;
enum MintingState {
CLOSED,
WL_SALE,
PUBLIC_SALE
}
MintingState private mintingState = MintingState.CLOSED;
bool _revealed = false;
string private baseURI = "https://nftstorage.link/ipfs/bafybeie4hptkikssuzvu3u4psg7ifmgev7e5d5rrdjshgw7ki4sswdkvri";
bytes32 wlRoot;
mapping(address => bool) public mintedWL;
address public constant DEV_ADDRESS = 0xC64aa843afa034AC44584b2804bd52f195c96096; // 15
address public constant PROJECT_ADDRESS = 0x68603361c581e214563f9F60f46bECB32d706301; // 85
constructor() ERC721A("Day-H", "DAYH") {}
function allowMint(uint256 numberOfTokens, bytes32[] memory proof) external payable {
require(mintingState == MintingState.WL_SALE, "WL_SALE_NOT_ACTIVE");
require(numberOfTokens + totalSupply() <= MAX_SUPPLY, "NOT_ENOUGH_SUPPLY");
require(numberOfTokens <= WL_MINT_LIMIT, "EXCEED_WL_MINT_LIMIT");
require(<FILL_ME>)
require(MerkleProof.verify(proof, wlRoot, keccak256(abi.encodePacked(msg.sender))),"PROOF_INVALID");
require(msg.value >= WL_PRICE * numberOfTokens, "WRONG_ETH_VALUE");
mintedWL[msg.sender] = true;
_safeMint(msg.sender, numberOfTokens);
}
function publicMint( uint256 numberOfTokens) external payable {
}
// URI
function setBaseURI(string calldata URI) external onlyOwner {
}
function reveal(bool revealed, string calldata _baseURI) public onlyOwner {
}
// MINTING STATE
function activatePublicMint() external onlyOwner {
}
function activateWLMint() external onlyOwner {
}
function pauseSale() external onlyOwner {
}
function getMintingState() public view returns (MintingState) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
// ROOT SETTERS
function setWLSaleRoot(bytes32 _wlRoot) external onlyOwner {
}
// LIMIT SETTERS
function setPublicMintLimit(uint256 _mintLimit) external onlyOwner {
}
function setWLMintLimit(uint256 _mintLimit) external onlyOwner {
}
function getPublicMintLimit() public view returns (uint256) {
}
function getWLMintLimit() public view returns (uint256) {
}
// PRICE SETTERS, GETTERS
function setPublicPrice(uint256 _price) external onlyOwner {
}
function setWlPrice(uint256 _price) external onlyOwner {
}
function getPublicPrice() public view returns (uint256) {
}
function getWLPrice() public view returns (uint256) {
}
function _startTokenId() override internal view virtual returns (uint256) {
}
function mintForTeam(uint256 numberOfTokens) external onlyOwner {
}
function batchMint(address[] calldata addresses, uint[] calldata amounts) external onlyOwner {
}
// withdraw
function withdraw() external onlyOwner {
}
}
| !mintedWL[msg.sender],"EXCEED_WL_MINT_LIMIT" | 147,524 | !mintedWL[msg.sender] |
"PROOF_INVALID" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721AV4.sol";
contract Day_H is ERC721A, Ownable, ReentrancyGuard {
uint256 public MAX_SUPPLY = 999;
uint256 public WL_MINT_LIMIT = 1;
uint256 public PUBLIC_MINT_LIMIT = 2;
uint256 public WL_PRICE = 0.0099 ether;
uint256 public PUBLIC_PRICE = 0.015 ether;
enum MintingState {
CLOSED,
WL_SALE,
PUBLIC_SALE
}
MintingState private mintingState = MintingState.CLOSED;
bool _revealed = false;
string private baseURI = "https://nftstorage.link/ipfs/bafybeie4hptkikssuzvu3u4psg7ifmgev7e5d5rrdjshgw7ki4sswdkvri";
bytes32 wlRoot;
mapping(address => bool) public mintedWL;
address public constant DEV_ADDRESS = 0xC64aa843afa034AC44584b2804bd52f195c96096; // 15
address public constant PROJECT_ADDRESS = 0x68603361c581e214563f9F60f46bECB32d706301; // 85
constructor() ERC721A("Day-H", "DAYH") {}
function allowMint(uint256 numberOfTokens, bytes32[] memory proof) external payable {
require(mintingState == MintingState.WL_SALE, "WL_SALE_NOT_ACTIVE");
require(numberOfTokens + totalSupply() <= MAX_SUPPLY, "NOT_ENOUGH_SUPPLY");
require(numberOfTokens <= WL_MINT_LIMIT, "EXCEED_WL_MINT_LIMIT");
require(!mintedWL[msg.sender],"EXCEED_WL_MINT_LIMIT");
require(<FILL_ME>)
require(msg.value >= WL_PRICE * numberOfTokens, "WRONG_ETH_VALUE");
mintedWL[msg.sender] = true;
_safeMint(msg.sender, numberOfTokens);
}
function publicMint( uint256 numberOfTokens) external payable {
}
// URI
function setBaseURI(string calldata URI) external onlyOwner {
}
function reveal(bool revealed, string calldata _baseURI) public onlyOwner {
}
// MINTING STATE
function activatePublicMint() external onlyOwner {
}
function activateWLMint() external onlyOwner {
}
function pauseSale() external onlyOwner {
}
function getMintingState() public view returns (MintingState) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
// ROOT SETTERS
function setWLSaleRoot(bytes32 _wlRoot) external onlyOwner {
}
// LIMIT SETTERS
function setPublicMintLimit(uint256 _mintLimit) external onlyOwner {
}
function setWLMintLimit(uint256 _mintLimit) external onlyOwner {
}
function getPublicMintLimit() public view returns (uint256) {
}
function getWLMintLimit() public view returns (uint256) {
}
// PRICE SETTERS, GETTERS
function setPublicPrice(uint256 _price) external onlyOwner {
}
function setWlPrice(uint256 _price) external onlyOwner {
}
function getPublicPrice() public view returns (uint256) {
}
function getWLPrice() public view returns (uint256) {
}
function _startTokenId() override internal view virtual returns (uint256) {
}
function mintForTeam(uint256 numberOfTokens) external onlyOwner {
}
function batchMint(address[] calldata addresses, uint[] calldata amounts) external onlyOwner {
}
// withdraw
function withdraw() external onlyOwner {
}
}
| MerkleProof.verify(proof,wlRoot,keccak256(abi.encodePacked(msg.sender))),"PROOF_INVALID" | 147,524 | MerkleProof.verify(proof,wlRoot,keccak256(abi.encodePacked(msg.sender))) |
"ONLY_2_IS_ALLOWED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721AV4.sol";
contract Day_H is ERC721A, Ownable, ReentrancyGuard {
uint256 public MAX_SUPPLY = 999;
uint256 public WL_MINT_LIMIT = 1;
uint256 public PUBLIC_MINT_LIMIT = 2;
uint256 public WL_PRICE = 0.0099 ether;
uint256 public PUBLIC_PRICE = 0.015 ether;
enum MintingState {
CLOSED,
WL_SALE,
PUBLIC_SALE
}
MintingState private mintingState = MintingState.CLOSED;
bool _revealed = false;
string private baseURI = "https://nftstorage.link/ipfs/bafybeie4hptkikssuzvu3u4psg7ifmgev7e5d5rrdjshgw7ki4sswdkvri";
bytes32 wlRoot;
mapping(address => bool) public mintedWL;
address public constant DEV_ADDRESS = 0xC64aa843afa034AC44584b2804bd52f195c96096; // 15
address public constant PROJECT_ADDRESS = 0x68603361c581e214563f9F60f46bECB32d706301; // 85
constructor() ERC721A("Day-H", "DAYH") {}
function allowMint(uint256 numberOfTokens, bytes32[] memory proof) external payable {
}
function publicMint( uint256 numberOfTokens) external payable {
require(mintingState == MintingState.PUBLIC_SALE, "PUBLIC_SALE_NOT_ACTIVE");
require(<FILL_ME>)
require(numberOfTokens + totalSupply() <= MAX_SUPPLY,"NOT_ENOUGH_SUPPLY");
require(msg.value >= PUBLIC_PRICE * numberOfTokens, "WRONG_ETH_VALUE");
_safeMint(msg.sender, numberOfTokens);
}
// URI
function setBaseURI(string calldata URI) external onlyOwner {
}
function reveal(bool revealed, string calldata _baseURI) public onlyOwner {
}
// MINTING STATE
function activatePublicMint() external onlyOwner {
}
function activateWLMint() external onlyOwner {
}
function pauseSale() external onlyOwner {
}
function getMintingState() public view returns (MintingState) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
// ROOT SETTERS
function setWLSaleRoot(bytes32 _wlRoot) external onlyOwner {
}
// LIMIT SETTERS
function setPublicMintLimit(uint256 _mintLimit) external onlyOwner {
}
function setWLMintLimit(uint256 _mintLimit) external onlyOwner {
}
function getPublicMintLimit() public view returns (uint256) {
}
function getWLMintLimit() public view returns (uint256) {
}
// PRICE SETTERS, GETTERS
function setPublicPrice(uint256 _price) external onlyOwner {
}
function setWlPrice(uint256 _price) external onlyOwner {
}
function getPublicPrice() public view returns (uint256) {
}
function getWLPrice() public view returns (uint256) {
}
function _startTokenId() override internal view virtual returns (uint256) {
}
function mintForTeam(uint256 numberOfTokens) external onlyOwner {
}
function batchMint(address[] calldata addresses, uint[] calldata amounts) external onlyOwner {
}
// withdraw
function withdraw() external onlyOwner {
}
}
| numberMinted(msg.sender)+numberOfTokens<=PUBLIC_MINT_LIMIT,"ONLY_2_IS_ALLOWED" | 147,524 | numberMinted(msg.sender)+numberOfTokens<=PUBLIC_MINT_LIMIT |
null | // $DOVE
// 1.5% Max Txn & 4% Max Wallet
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract DOVE is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "DOVE";
string private constant _symbol = "DOVE";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 5;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 7;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
address payable private _taaxAddress = payable(0x82Db6576fDD047452d639b7Dc1f0f514aB417dDF);
address payable private _ttaxAddress = payable(0x82Db6576fDD047452d639b7Dc1f0f514aB417dDF);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 15000000000 * 10**9;
uint256 public _maxWalletSize = 40000000000 * 10**9;
uint256 public _swapTokensAtAmount = 20000000000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| _msgSender()==_taaxAddress||_msgSender()==_ttaxAddress | 147,605 | _msgSender()==_taaxAddress||_msgSender()==_ttaxAddress |
"Cannot buy" | pragma solidity ^0.8.15;
struct NFTVoucher {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
bytes signature;
}
struct NFT {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
}
interface ILooxooryNft{
function redeem(address redeemer, NFTVoucher calldata voucher) external returns (uint256);
function getCurrentTokenId() external view returns(uint256);
function getNFT(uint256 _tokenId) external view returns(string memory uri,uint256 price,address creatorAddress,uint256 numberOfNfts,uint256 platformFee);
}
interface IRandom{
function random() external view returns (uint256);
}
contract LooxooryNFTMarketplace is ReentrancyGuard,Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
Counters.Counter public _itemsSold;
Counters.Counter public _campaignIds;
uint256 public TOTAL_PERCENTAGE = 100;
uint256 public totalSale;
uint256 public totalAmountDue;
address public NFTContract;
address public NFTHolderAddress;
address public randomContract;
mapping(address=>uint256[]) public wonCampaigns;
mapping(bytes=>uint256) public nftSoldData;
mapping(bytes=>uint256) public voucherToCampaignID;
event Minted(
uint256 tokenId,
string uri,
uint256 price,
address creatorAddress,
uint256 numberOfNfts,
uint256 platformFee
);
event CampaignCreated(
uint256 campaignID,
address creatorAddress,
address winnerAddress,
string winnerPrize,
string[] winnerPrizeImages,
string campaignDescription,
uint256 maxNoOfParticipants,
uint256 currentNoOfParticipants,
uint256 drawTime,
string ngoName,
string ngoImage
);
event BidAdded(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
event BidReturned(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
struct CreateCampaignStruct{
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
}
struct Campaign {
uint256 campaignID;
address creatorAddress;
uint256 totalNfts;
address winnerAddress;
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 currentNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
bool isEnded;
address[] participants;
uint256 soldNfts;
}
struct NFTAuctionItems{
uint256 nftID;
bool isOnAuction;
uint256 biddingTime;
address artistAddress;
uint256 price;
bool sold;
uint256 platformFee;
}
struct Bidder{
address bidderAddress;
uint256 bidderAmount;
}
mapping(uint256=>NFTAuctionItems) public currentlyOnAuction;
uint256 public currentlyOnAuctionTokenID;
bool public isOnAuction;
mapping(uint256=>Campaign) public campaigns;
mapping(uint256=>Bidder) public bidderInfo;
constructor(address _nftContract, address _nftHolder, address _randomContract) {
}
function setNFTContract(address _nftContract) external onlyOwner{
}
function setNFTAddress(address _nftHolder) external onlyOwner{
}
function setRandomContractAddress(address _randomContract) external onlyOwner{
}
function createMarketSale(NFTVoucher calldata voucher,bool donation) public payable{
uint256 tokenId;
if(donation){
tokenId = ILooxooryNft(NFTContract).redeem(owner(), voucher);
}else{
tokenId = ILooxooryNft(NFTContract).redeem(msg.sender, voucher);
}
(string memory uri,uint256 price,address creatorAddress,uint256 numberOfNfts,uint256 platformFee) = ILooxooryNft(NFTContract).getNFT(tokenId);
uint256 campaignId = voucherToCampaignID[voucher.signature];
require(<FILL_ME>)
require(msg.value>=price,"Invalid amount sent");
require(campaigns[campaignId].creatorAddress!=address(0),"Invalid campaign id");
require(campaignId==voucherToCampaignID[voucher.signature],"Invalid campaign id");
require(!campaigns[campaignId].isEnded,"Campaign is already ended");
nftSoldData[voucher.signature] = nftSoldData[voucher.signature].add(1);
campaigns[campaignId].currentNoOfParticipants = campaigns[campaignId].currentNoOfParticipants.add(1);
if(nftSoldData[voucher.signature]>=numberOfNfts){
campaigns[campaignId].soldNfts = campaigns[campaignId].soldNfts.add(1);
}
campaigns[campaignId].participants.push(msg.sender);
campaigns[campaignId].totalNfts = campaigns[campaignId].totalNfts.add(1);
_itemsSold.increment();
totalSale = totalSale.add(price);
emit Minted(tokenId,uri,price,creatorAddress,numberOfNfts,platformFee);
uint256 _platformFee = price.mul(platformFee).div(TOTAL_PERCENTAGE);
uint256 artistShare = price.sub(_platformFee);
payable(creatorAddress).transfer(artistShare);
}
function createCampaign(
CreateCampaignStruct memory _campaignDTO
) external onlyOwner{
}
function listNftForAuction(NFTVoucher calldata voucher,uint256 bidEndTime,uint256 tokenId) external onlyOwner{
}
function createBidOnItem(
uint256 itemId
) external payable nonReentrant {
}
function claimBidItem(uint256 itemId) external nonReentrant {
}
function resetAuction() external onlyOwner{
}
function withdraw() external onlyOwner{
}
function getOwnerBalance() public view returns(uint256){
}
function getBalance() public view returns(uint256){
}
function drawForWinner(uint256 _campaignId) external onlyOwner{
}
function getCampaignData(uint256 _id) external view returns(
string[] memory winnerPrizeImages,
address[] memory participants
){
}
function getWonCampaigns(address userAddress) external view returns(
uint256[] memory wonCampaign
) {
}
function updateCampaignDrawTime(uint256 _campaignId,uint256 _drawTime) external onlyOwner{
}
function updateAuctionEndTime (uint256 _bidEndTime, uint tokenId ) external onlyOwner {
}
}
| nftSoldData[voucher.signature]<numberOfNfts,"Cannot buy" | 147,654 | nftSoldData[voucher.signature]<numberOfNfts |
"Invalid campaign id" | pragma solidity ^0.8.15;
struct NFTVoucher {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
bytes signature;
}
struct NFT {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
}
interface ILooxooryNft{
function redeem(address redeemer, NFTVoucher calldata voucher) external returns (uint256);
function getCurrentTokenId() external view returns(uint256);
function getNFT(uint256 _tokenId) external view returns(string memory uri,uint256 price,address creatorAddress,uint256 numberOfNfts,uint256 platformFee);
}
interface IRandom{
function random() external view returns (uint256);
}
contract LooxooryNFTMarketplace is ReentrancyGuard,Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
Counters.Counter public _itemsSold;
Counters.Counter public _campaignIds;
uint256 public TOTAL_PERCENTAGE = 100;
uint256 public totalSale;
uint256 public totalAmountDue;
address public NFTContract;
address public NFTHolderAddress;
address public randomContract;
mapping(address=>uint256[]) public wonCampaigns;
mapping(bytes=>uint256) public nftSoldData;
mapping(bytes=>uint256) public voucherToCampaignID;
event Minted(
uint256 tokenId,
string uri,
uint256 price,
address creatorAddress,
uint256 numberOfNfts,
uint256 platformFee
);
event CampaignCreated(
uint256 campaignID,
address creatorAddress,
address winnerAddress,
string winnerPrize,
string[] winnerPrizeImages,
string campaignDescription,
uint256 maxNoOfParticipants,
uint256 currentNoOfParticipants,
uint256 drawTime,
string ngoName,
string ngoImage
);
event BidAdded(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
event BidReturned(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
struct CreateCampaignStruct{
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
}
struct Campaign {
uint256 campaignID;
address creatorAddress;
uint256 totalNfts;
address winnerAddress;
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 currentNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
bool isEnded;
address[] participants;
uint256 soldNfts;
}
struct NFTAuctionItems{
uint256 nftID;
bool isOnAuction;
uint256 biddingTime;
address artistAddress;
uint256 price;
bool sold;
uint256 platformFee;
}
struct Bidder{
address bidderAddress;
uint256 bidderAmount;
}
mapping(uint256=>NFTAuctionItems) public currentlyOnAuction;
uint256 public currentlyOnAuctionTokenID;
bool public isOnAuction;
mapping(uint256=>Campaign) public campaigns;
mapping(uint256=>Bidder) public bidderInfo;
constructor(address _nftContract, address _nftHolder, address _randomContract) {
}
function setNFTContract(address _nftContract) external onlyOwner{
}
function setNFTAddress(address _nftHolder) external onlyOwner{
}
function setRandomContractAddress(address _randomContract) external onlyOwner{
}
function createMarketSale(NFTVoucher calldata voucher,bool donation) public payable{
uint256 tokenId;
if(donation){
tokenId = ILooxooryNft(NFTContract).redeem(owner(), voucher);
}else{
tokenId = ILooxooryNft(NFTContract).redeem(msg.sender, voucher);
}
(string memory uri,uint256 price,address creatorAddress,uint256 numberOfNfts,uint256 platformFee) = ILooxooryNft(NFTContract).getNFT(tokenId);
uint256 campaignId = voucherToCampaignID[voucher.signature];
require(nftSoldData[voucher.signature]<numberOfNfts,"Cannot buy");
require(msg.value>=price,"Invalid amount sent");
require(<FILL_ME>)
require(campaignId==voucherToCampaignID[voucher.signature],"Invalid campaign id");
require(!campaigns[campaignId].isEnded,"Campaign is already ended");
nftSoldData[voucher.signature] = nftSoldData[voucher.signature].add(1);
campaigns[campaignId].currentNoOfParticipants = campaigns[campaignId].currentNoOfParticipants.add(1);
if(nftSoldData[voucher.signature]>=numberOfNfts){
campaigns[campaignId].soldNfts = campaigns[campaignId].soldNfts.add(1);
}
campaigns[campaignId].participants.push(msg.sender);
campaigns[campaignId].totalNfts = campaigns[campaignId].totalNfts.add(1);
_itemsSold.increment();
totalSale = totalSale.add(price);
emit Minted(tokenId,uri,price,creatorAddress,numberOfNfts,platformFee);
uint256 _platformFee = price.mul(platformFee).div(TOTAL_PERCENTAGE);
uint256 artistShare = price.sub(_platformFee);
payable(creatorAddress).transfer(artistShare);
}
function createCampaign(
CreateCampaignStruct memory _campaignDTO
) external onlyOwner{
}
function listNftForAuction(NFTVoucher calldata voucher,uint256 bidEndTime,uint256 tokenId) external onlyOwner{
}
function createBidOnItem(
uint256 itemId
) external payable nonReentrant {
}
function claimBidItem(uint256 itemId) external nonReentrant {
}
function resetAuction() external onlyOwner{
}
function withdraw() external onlyOwner{
}
function getOwnerBalance() public view returns(uint256){
}
function getBalance() public view returns(uint256){
}
function drawForWinner(uint256 _campaignId) external onlyOwner{
}
function getCampaignData(uint256 _id) external view returns(
string[] memory winnerPrizeImages,
address[] memory participants
){
}
function getWonCampaigns(address userAddress) external view returns(
uint256[] memory wonCampaign
) {
}
function updateCampaignDrawTime(uint256 _campaignId,uint256 _drawTime) external onlyOwner{
}
function updateAuctionEndTime (uint256 _bidEndTime, uint tokenId ) external onlyOwner {
}
}
| campaigns[campaignId].creatorAddress!=address(0),"Invalid campaign id" | 147,654 | campaigns[campaignId].creatorAddress!=address(0) |
"Campaign is already ended" | pragma solidity ^0.8.15;
struct NFTVoucher {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
bytes signature;
}
struct NFT {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
}
interface ILooxooryNft{
function redeem(address redeemer, NFTVoucher calldata voucher) external returns (uint256);
function getCurrentTokenId() external view returns(uint256);
function getNFT(uint256 _tokenId) external view returns(string memory uri,uint256 price,address creatorAddress,uint256 numberOfNfts,uint256 platformFee);
}
interface IRandom{
function random() external view returns (uint256);
}
contract LooxooryNFTMarketplace is ReentrancyGuard,Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
Counters.Counter public _itemsSold;
Counters.Counter public _campaignIds;
uint256 public TOTAL_PERCENTAGE = 100;
uint256 public totalSale;
uint256 public totalAmountDue;
address public NFTContract;
address public NFTHolderAddress;
address public randomContract;
mapping(address=>uint256[]) public wonCampaigns;
mapping(bytes=>uint256) public nftSoldData;
mapping(bytes=>uint256) public voucherToCampaignID;
event Minted(
uint256 tokenId,
string uri,
uint256 price,
address creatorAddress,
uint256 numberOfNfts,
uint256 platformFee
);
event CampaignCreated(
uint256 campaignID,
address creatorAddress,
address winnerAddress,
string winnerPrize,
string[] winnerPrizeImages,
string campaignDescription,
uint256 maxNoOfParticipants,
uint256 currentNoOfParticipants,
uint256 drawTime,
string ngoName,
string ngoImage
);
event BidAdded(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
event BidReturned(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
struct CreateCampaignStruct{
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
}
struct Campaign {
uint256 campaignID;
address creatorAddress;
uint256 totalNfts;
address winnerAddress;
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 currentNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
bool isEnded;
address[] participants;
uint256 soldNfts;
}
struct NFTAuctionItems{
uint256 nftID;
bool isOnAuction;
uint256 biddingTime;
address artistAddress;
uint256 price;
bool sold;
uint256 platformFee;
}
struct Bidder{
address bidderAddress;
uint256 bidderAmount;
}
mapping(uint256=>NFTAuctionItems) public currentlyOnAuction;
uint256 public currentlyOnAuctionTokenID;
bool public isOnAuction;
mapping(uint256=>Campaign) public campaigns;
mapping(uint256=>Bidder) public bidderInfo;
constructor(address _nftContract, address _nftHolder, address _randomContract) {
}
function setNFTContract(address _nftContract) external onlyOwner{
}
function setNFTAddress(address _nftHolder) external onlyOwner{
}
function setRandomContractAddress(address _randomContract) external onlyOwner{
}
function createMarketSale(NFTVoucher calldata voucher,bool donation) public payable{
uint256 tokenId;
if(donation){
tokenId = ILooxooryNft(NFTContract).redeem(owner(), voucher);
}else{
tokenId = ILooxooryNft(NFTContract).redeem(msg.sender, voucher);
}
(string memory uri,uint256 price,address creatorAddress,uint256 numberOfNfts,uint256 platformFee) = ILooxooryNft(NFTContract).getNFT(tokenId);
uint256 campaignId = voucherToCampaignID[voucher.signature];
require(nftSoldData[voucher.signature]<numberOfNfts,"Cannot buy");
require(msg.value>=price,"Invalid amount sent");
require(campaigns[campaignId].creatorAddress!=address(0),"Invalid campaign id");
require(campaignId==voucherToCampaignID[voucher.signature],"Invalid campaign id");
require(<FILL_ME>)
nftSoldData[voucher.signature] = nftSoldData[voucher.signature].add(1);
campaigns[campaignId].currentNoOfParticipants = campaigns[campaignId].currentNoOfParticipants.add(1);
if(nftSoldData[voucher.signature]>=numberOfNfts){
campaigns[campaignId].soldNfts = campaigns[campaignId].soldNfts.add(1);
}
campaigns[campaignId].participants.push(msg.sender);
campaigns[campaignId].totalNfts = campaigns[campaignId].totalNfts.add(1);
_itemsSold.increment();
totalSale = totalSale.add(price);
emit Minted(tokenId,uri,price,creatorAddress,numberOfNfts,platformFee);
uint256 _platformFee = price.mul(platformFee).div(TOTAL_PERCENTAGE);
uint256 artistShare = price.sub(_platformFee);
payable(creatorAddress).transfer(artistShare);
}
function createCampaign(
CreateCampaignStruct memory _campaignDTO
) external onlyOwner{
}
function listNftForAuction(NFTVoucher calldata voucher,uint256 bidEndTime,uint256 tokenId) external onlyOwner{
}
function createBidOnItem(
uint256 itemId
) external payable nonReentrant {
}
function claimBidItem(uint256 itemId) external nonReentrant {
}
function resetAuction() external onlyOwner{
}
function withdraw() external onlyOwner{
}
function getOwnerBalance() public view returns(uint256){
}
function getBalance() public view returns(uint256){
}
function drawForWinner(uint256 _campaignId) external onlyOwner{
}
function getCampaignData(uint256 _id) external view returns(
string[] memory winnerPrizeImages,
address[] memory participants
){
}
function getWonCampaigns(address userAddress) external view returns(
uint256[] memory wonCampaign
) {
}
function updateCampaignDrawTime(uint256 _campaignId,uint256 _drawTime) external onlyOwner{
}
function updateAuctionEndTime (uint256 _bidEndTime, uint tokenId ) external onlyOwner {
}
}
| !campaigns[campaignId].isEnded,"Campaign is already ended" | 147,654 | !campaigns[campaignId].isEnded |
"An item is already on auction" | pragma solidity ^0.8.15;
struct NFTVoucher {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
bytes signature;
}
struct NFT {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
}
interface ILooxooryNft{
function redeem(address redeemer, NFTVoucher calldata voucher) external returns (uint256);
function getCurrentTokenId() external view returns(uint256);
function getNFT(uint256 _tokenId) external view returns(string memory uri,uint256 price,address creatorAddress,uint256 numberOfNfts,uint256 platformFee);
}
interface IRandom{
function random() external view returns (uint256);
}
contract LooxooryNFTMarketplace is ReentrancyGuard,Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
Counters.Counter public _itemsSold;
Counters.Counter public _campaignIds;
uint256 public TOTAL_PERCENTAGE = 100;
uint256 public totalSale;
uint256 public totalAmountDue;
address public NFTContract;
address public NFTHolderAddress;
address public randomContract;
mapping(address=>uint256[]) public wonCampaigns;
mapping(bytes=>uint256) public nftSoldData;
mapping(bytes=>uint256) public voucherToCampaignID;
event Minted(
uint256 tokenId,
string uri,
uint256 price,
address creatorAddress,
uint256 numberOfNfts,
uint256 platformFee
);
event CampaignCreated(
uint256 campaignID,
address creatorAddress,
address winnerAddress,
string winnerPrize,
string[] winnerPrizeImages,
string campaignDescription,
uint256 maxNoOfParticipants,
uint256 currentNoOfParticipants,
uint256 drawTime,
string ngoName,
string ngoImage
);
event BidAdded(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
event BidReturned(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
struct CreateCampaignStruct{
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
}
struct Campaign {
uint256 campaignID;
address creatorAddress;
uint256 totalNfts;
address winnerAddress;
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 currentNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
bool isEnded;
address[] participants;
uint256 soldNfts;
}
struct NFTAuctionItems{
uint256 nftID;
bool isOnAuction;
uint256 biddingTime;
address artistAddress;
uint256 price;
bool sold;
uint256 platformFee;
}
struct Bidder{
address bidderAddress;
uint256 bidderAmount;
}
mapping(uint256=>NFTAuctionItems) public currentlyOnAuction;
uint256 public currentlyOnAuctionTokenID;
bool public isOnAuction;
mapping(uint256=>Campaign) public campaigns;
mapping(uint256=>Bidder) public bidderInfo;
constructor(address _nftContract, address _nftHolder, address _randomContract) {
}
function setNFTContract(address _nftContract) external onlyOwner{
}
function setNFTAddress(address _nftHolder) external onlyOwner{
}
function setRandomContractAddress(address _randomContract) external onlyOwner{
}
function createMarketSale(NFTVoucher calldata voucher,bool donation) public payable{
}
function createCampaign(
CreateCampaignStruct memory _campaignDTO
) external onlyOwner{
}
function listNftForAuction(NFTVoucher calldata voucher,uint256 bidEndTime,uint256 tokenId) external onlyOwner{
require(<FILL_ME>)
require(bidEndTime>block.timestamp,"Invalid bid end time");
(string memory uri,uint256 price,address creatorAddress,uint256 numberOfNfts,uint256 platformFee) = ILooxooryNft(NFTContract).getNFT(tokenId);
if(creatorAddress==address(0)){
tokenId = ILooxooryNft(NFTContract).redeem(NFTHolderAddress, voucher);
}
(uri,price,creatorAddress,numberOfNfts,platformFee) = ILooxooryNft(NFTContract).getNFT(tokenId);
require(numberOfNfts==1,"Only one copy can be on auction");
emit Minted(tokenId,uri,price,creatorAddress,numberOfNfts,platformFee);
currentlyOnAuction[tokenId] = NFTAuctionItems({
nftID:tokenId,
isOnAuction:true,
biddingTime:bidEndTime,
artistAddress:creatorAddress,
price:price,
sold:false,
platformFee:platformFee
});
currentlyOnAuctionTokenID = tokenId;
isOnAuction = true;
}
function createBidOnItem(
uint256 itemId
) external payable nonReentrant {
}
function claimBidItem(uint256 itemId) external nonReentrant {
}
function resetAuction() external onlyOwner{
}
function withdraw() external onlyOwner{
}
function getOwnerBalance() public view returns(uint256){
}
function getBalance() public view returns(uint256){
}
function drawForWinner(uint256 _campaignId) external onlyOwner{
}
function getCampaignData(uint256 _id) external view returns(
string[] memory winnerPrizeImages,
address[] memory participants
){
}
function getWonCampaigns(address userAddress) external view returns(
uint256[] memory wonCampaign
) {
}
function updateCampaignDrawTime(uint256 _campaignId,uint256 _drawTime) external onlyOwner{
}
function updateAuctionEndTime (uint256 _bidEndTime, uint tokenId ) external onlyOwner {
}
}
| !isOnAuction,"An item is already on auction" | 147,654 | !isOnAuction |
"Item is not on auction" | pragma solidity ^0.8.15;
struct NFTVoucher {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
bytes signature;
}
struct NFT {
string uri;
uint256 price;
address creatorAddress;
uint256 numberOfNfts;
uint256 platformFee;
}
interface ILooxooryNft{
function redeem(address redeemer, NFTVoucher calldata voucher) external returns (uint256);
function getCurrentTokenId() external view returns(uint256);
function getNFT(uint256 _tokenId) external view returns(string memory uri,uint256 price,address creatorAddress,uint256 numberOfNfts,uint256 platformFee);
}
interface IRandom{
function random() external view returns (uint256);
}
contract LooxooryNFTMarketplace is ReentrancyGuard,Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
Counters.Counter public _itemsSold;
Counters.Counter public _campaignIds;
uint256 public TOTAL_PERCENTAGE = 100;
uint256 public totalSale;
uint256 public totalAmountDue;
address public NFTContract;
address public NFTHolderAddress;
address public randomContract;
mapping(address=>uint256[]) public wonCampaigns;
mapping(bytes=>uint256) public nftSoldData;
mapping(bytes=>uint256) public voucherToCampaignID;
event Minted(
uint256 tokenId,
string uri,
uint256 price,
address creatorAddress,
uint256 numberOfNfts,
uint256 platformFee
);
event CampaignCreated(
uint256 campaignID,
address creatorAddress,
address winnerAddress,
string winnerPrize,
string[] winnerPrizeImages,
string campaignDescription,
uint256 maxNoOfParticipants,
uint256 currentNoOfParticipants,
uint256 drawTime,
string ngoName,
string ngoImage
);
event BidAdded(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
event BidReturned(
uint256 itemId,
uint256 tokenId,
address bidder,
uint256 amount
);
struct CreateCampaignStruct{
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
}
struct Campaign {
uint256 campaignID;
address creatorAddress;
uint256 totalNfts;
address winnerAddress;
string winnerPrize;
string[] winnerPrizeImages;
bytes[] signatures;
string campaignDescription;
uint256 maxNoOfParticipants;
uint256 currentNoOfParticipants;
uint256 drawTime;
string ngoName;
string ngoImage;
bool isEnded;
address[] participants;
uint256 soldNfts;
}
struct NFTAuctionItems{
uint256 nftID;
bool isOnAuction;
uint256 biddingTime;
address artistAddress;
uint256 price;
bool sold;
uint256 platformFee;
}
struct Bidder{
address bidderAddress;
uint256 bidderAmount;
}
mapping(uint256=>NFTAuctionItems) public currentlyOnAuction;
uint256 public currentlyOnAuctionTokenID;
bool public isOnAuction;
mapping(uint256=>Campaign) public campaigns;
mapping(uint256=>Bidder) public bidderInfo;
constructor(address _nftContract, address _nftHolder, address _randomContract) {
}
function setNFTContract(address _nftContract) external onlyOwner{
}
function setNFTAddress(address _nftHolder) external onlyOwner{
}
function setRandomContractAddress(address _randomContract) external onlyOwner{
}
function createMarketSale(NFTVoucher calldata voucher,bool donation) public payable{
}
function createCampaign(
CreateCampaignStruct memory _campaignDTO
) external onlyOwner{
}
function listNftForAuction(NFTVoucher calldata voucher,uint256 bidEndTime,uint256 tokenId) external onlyOwner{
}
function createBidOnItem(
uint256 itemId
) external payable nonReentrant {
uint price = currentlyOnAuction[itemId].price;
require(<FILL_ME>)
require(currentlyOnAuction[itemId].biddingTime>block.timestamp,"Auction time ended");
require(!currentlyOnAuction[itemId].sold,"Already sold");
require(msg.value >= price && msg.value > bidderInfo[itemId].bidderAmount, "Bid price must be greater than base price and highest bid");
if(bidderInfo[itemId].bidderAddress!=address(0)){
payable(bidderInfo[itemId].bidderAddress).transfer(bidderInfo[itemId].bidderAmount);
totalAmountDue = totalAmountDue.sub(bidderInfo[itemId].bidderAmount);
emit BidReturned(itemId, currentlyOnAuction[itemId].nftID, bidderInfo[itemId].bidderAddress, bidderInfo[itemId].bidderAmount);
}
totalAmountDue = totalAmountDue.add(msg.value);
bidderInfo[itemId].bidderAddress = msg.sender;
bidderInfo[itemId].bidderAmount = msg.value;
emit BidAdded(itemId, currentlyOnAuction[itemId].nftID, msg.sender, msg.value);
}
function claimBidItem(uint256 itemId) external nonReentrant {
}
function resetAuction() external onlyOwner{
}
function withdraw() external onlyOwner{
}
function getOwnerBalance() public view returns(uint256){
}
function getBalance() public view returns(uint256){
}
function drawForWinner(uint256 _campaignId) external onlyOwner{
}
function getCampaignData(uint256 _id) external view returns(
string[] memory winnerPrizeImages,
address[] memory participants
){
}
function getWonCampaigns(address userAddress) external view returns(
uint256[] memory wonCampaign
) {
}
function updateCampaignDrawTime(uint256 _campaignId,uint256 _drawTime) external onlyOwner{
}
function updateAuctionEndTime (uint256 _bidEndTime, uint tokenId ) external onlyOwner {
}
}
| currentlyOnAuction[itemId].nftID==itemId,"Item is not on auction" | 147,654 | currentlyOnAuction[itemId].nftID==itemId |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.