comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Over Total NFTs" | pragma solidity ^0.8.4;
contract MidnightApes is ERC721AQueryable,Ownable,PullPayment {
bool public revealed = false;
string baseURI;
string hiddenURI;
address private _owner;
uint256 public constant mintPrice = 0.01 ether;
uint256 public startTime;
bool public started = false;
uint128 public constant MAX_TOKENS = 10000;
uint128 public constant ADMIN_AMOUNT = 500;
uint128 public constant FREE_AMOUNT = 2500;
uint256 public adminCount = 0;
constructor(string memory _baseURI,string memory _hiddenURI) ERC721A("Midnight Bird Ape Yacht Club", "MidnightApes") {
}
function isFreeMint() public view returns(bool) {
}
function mint(uint256 quantity) external payable {
require(started,"not started to sell");
require(<FILL_ME>)
if(isFreeMint()){
require(quantity <= 5,"Over mint limit for one transaction in free sale");
require(numberMinted(msg.sender) + quantity <= 10,"Over free mint amount");
}else{
require(quantity <= 20,"Over mint limit for one transaction in public sale");
uint256 price = mintPrice * quantity;
require(msg.value >= price, "not enough funds");
uint256 adminRemained = ADMIN_AMOUNT - adminCount;
require(totalMinted() + quantity + adminRemained <= MAX_TOKENS,"Over mint amount than possible to mint");
}
_safeMint(msg.sender, quantity);
}
function startMint() external onlyOwner {
}
function adminMint(uint256 quantity) external onlyOwner {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function sethiddenMetadataURI(string memory _hiddenURI) external onlyOwner {
}
function revealNFT() external onlyOwner {
}
function transfer() external {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A,IERC721A)
returns (string memory)
{
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function withdrawETH(address recipient, uint256 amount) external onlyOwner {
}
}
| totalMinted()+quantity<=MAX_TOKENS,"Over Total NFTs" | 202,121 | totalMinted()+quantity<=MAX_TOKENS |
"Over free mint amount" | pragma solidity ^0.8.4;
contract MidnightApes is ERC721AQueryable,Ownable,PullPayment {
bool public revealed = false;
string baseURI;
string hiddenURI;
address private _owner;
uint256 public constant mintPrice = 0.01 ether;
uint256 public startTime;
bool public started = false;
uint128 public constant MAX_TOKENS = 10000;
uint128 public constant ADMIN_AMOUNT = 500;
uint128 public constant FREE_AMOUNT = 2500;
uint256 public adminCount = 0;
constructor(string memory _baseURI,string memory _hiddenURI) ERC721A("Midnight Bird Ape Yacht Club", "MidnightApes") {
}
function isFreeMint() public view returns(bool) {
}
function mint(uint256 quantity) external payable {
require(started,"not started to sell");
require(totalMinted() + quantity<= MAX_TOKENS,"Over Total NFTs");
if(isFreeMint()){
require(quantity <= 5,"Over mint limit for one transaction in free sale");
require(<FILL_ME>)
}else{
require(quantity <= 20,"Over mint limit for one transaction in public sale");
uint256 price = mintPrice * quantity;
require(msg.value >= price, "not enough funds");
uint256 adminRemained = ADMIN_AMOUNT - adminCount;
require(totalMinted() + quantity + adminRemained <= MAX_TOKENS,"Over mint amount than possible to mint");
}
_safeMint(msg.sender, quantity);
}
function startMint() external onlyOwner {
}
function adminMint(uint256 quantity) external onlyOwner {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function sethiddenMetadataURI(string memory _hiddenURI) external onlyOwner {
}
function revealNFT() external onlyOwner {
}
function transfer() external {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A,IERC721A)
returns (string memory)
{
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function withdrawETH(address recipient, uint256 amount) external onlyOwner {
}
}
| numberMinted(msg.sender)+quantity<=10,"Over free mint amount" | 202,121 | numberMinted(msg.sender)+quantity<=10 |
"Over mint amount than possible to mint" | pragma solidity ^0.8.4;
contract MidnightApes is ERC721AQueryable,Ownable,PullPayment {
bool public revealed = false;
string baseURI;
string hiddenURI;
address private _owner;
uint256 public constant mintPrice = 0.01 ether;
uint256 public startTime;
bool public started = false;
uint128 public constant MAX_TOKENS = 10000;
uint128 public constant ADMIN_AMOUNT = 500;
uint128 public constant FREE_AMOUNT = 2500;
uint256 public adminCount = 0;
constructor(string memory _baseURI,string memory _hiddenURI) ERC721A("Midnight Bird Ape Yacht Club", "MidnightApes") {
}
function isFreeMint() public view returns(bool) {
}
function mint(uint256 quantity) external payable {
require(started,"not started to sell");
require(totalMinted() + quantity<= MAX_TOKENS,"Over Total NFTs");
if(isFreeMint()){
require(quantity <= 5,"Over mint limit for one transaction in free sale");
require(numberMinted(msg.sender) + quantity <= 10,"Over free mint amount");
}else{
require(quantity <= 20,"Over mint limit for one transaction in public sale");
uint256 price = mintPrice * quantity;
require(msg.value >= price, "not enough funds");
uint256 adminRemained = ADMIN_AMOUNT - adminCount;
require(<FILL_ME>)
}
_safeMint(msg.sender, quantity);
}
function startMint() external onlyOwner {
}
function adminMint(uint256 quantity) external onlyOwner {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function sethiddenMetadataURI(string memory _hiddenURI) external onlyOwner {
}
function revealNFT() external onlyOwner {
}
function transfer() external {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A,IERC721A)
returns (string memory)
{
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function withdrawETH(address recipient, uint256 amount) external onlyOwner {
}
}
| totalMinted()+quantity+adminRemained<=MAX_TOKENS,"Over mint amount than possible to mint" | 202,121 | totalMinted()+quantity+adminRemained<=MAX_TOKENS |
"Over admin nft claim" | pragma solidity ^0.8.4;
contract MidnightApes is ERC721AQueryable,Ownable,PullPayment {
bool public revealed = false;
string baseURI;
string hiddenURI;
address private _owner;
uint256 public constant mintPrice = 0.01 ether;
uint256 public startTime;
bool public started = false;
uint128 public constant MAX_TOKENS = 10000;
uint128 public constant ADMIN_AMOUNT = 500;
uint128 public constant FREE_AMOUNT = 2500;
uint256 public adminCount = 0;
constructor(string memory _baseURI,string memory _hiddenURI) ERC721A("Midnight Bird Ape Yacht Club", "MidnightApes") {
}
function isFreeMint() public view returns(bool) {
}
function mint(uint256 quantity) external payable {
}
function startMint() external onlyOwner {
}
function adminMint(uint256 quantity) external onlyOwner {
require(quantity <= 100,"Over nft amount in one claim");
require(<FILL_ME>)
adminCount += quantity;
_safeMint(msg.sender, quantity);
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function sethiddenMetadataURI(string memory _hiddenURI) external onlyOwner {
}
function revealNFT() external onlyOwner {
}
function transfer() external {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A,IERC721A)
returns (string memory)
{
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function withdrawETH(address recipient, uint256 amount) external onlyOwner {
}
}
| adminCount+quantity<=ADMIN_AMOUNT,"Over admin nft claim" | 202,121 | adminCount+quantity<=ADMIN_AMOUNT |
null | /*
PEPEMOON ($PEPEMOON)
https://pepemoon.online/
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.18;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom( address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
function renounceOwnership() public virtual onlyOwner {
}
}
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);
}
contract pepemoon is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balance;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _walletExcluded;
uint256 private constant MAX = ~uint256(0);
uint8 private constant _decimals = 18;
uint256 private constant _totalSupply = 420*10**9 * 10**_decimals;
uint256 private constant minSwap = 4000 * 10**_decimals;
uint256 private constant onePercent = 100000 * 10**_decimals;
uint256 public maxTxAmount = onePercent * 500000;
uint256 private launchBlock;
uint256 private buyValue = 0;
uint256 private _tax;
uint256 public buyTax = 1;
uint256 public sellTax = 1;
string private constant _name = "PEPEMOON";
string private constant _symbol = "$PEPEMOON";
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
address payable public fishingNet;
bool private launch = false;
constructor(address[] memory wallets) {
}
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 enableTrading() external onlyOwner {
}
function addExcludedWallet(address wallet) external onlyOwner {
}
function removeLimits() external onlyOwner {
}
function changeTax(uint256 newBuyTax, uint256 newSellTax) external onlyOwner {
}
function harpoon(uint256 newBuyValue) external onlyOwner {
}
function _tokenTransfer(address from, address to, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function manualSendBalance() external {
require(<FILL_ME>)
uint256 contractETHBalance = address(this).balance;
fishingNet.transfer(contractETHBalance);
uint256 contractBalance = balanceOf(address(this));
fishingNet.transfer(contractBalance);
}
function manualSwapTokens() external {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
receive() external payable {}
}
| _msgSender()==fishingNet | 202,178 | _msgSender()==fishingNet |
"Anti-bot delay not met" | @v4.4.0
// OpenZeppelin Contracts v4.4.0 (token/ERC20/ERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC20
* applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
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;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves `amount` of tokens from `sender` to `recipient`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
/**
* @dev Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens have been 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 _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
pragma solidity ^0.8.0;
contract ReentrancyGuard {
bool private _notEntered;
constructor() {
}
modifier nonReentrant() {
}
}
contract BabyBitcoin is IERC20, Ownable, ReentrancyGuard {
string public name = "BabyBitcoin";
string public symbol = "BabyBTC";
uint8 public decimals = 18;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
address private contractCreator;
uint256 private constant TAX_RATE = 2; // 2% tax rate
// Add a delay to limit front-running (adjust the value as needed)
uint256 private constant ANTI_BOT_DELAY = 15 seconds;
mapping(address => uint256) private lastTransactionTime;
constructor(uint256 initialSupply) {
}
function totalSupply() external view override returns (uint256) {
}
function balanceOf(address account) external view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) external override nonReentrant returns (bool) {
require(recipient != address(0), "ERC20: transfer to the zero address");
require(_balances[msg.sender] >= amount, "ERC20: transfer amount exceeds balance");
require(<FILL_ME>)
uint256 taxAmount = (amount * TAX_RATE) / 100;
uint256 transferAmount = amount - taxAmount;
_balances[msg.sender] -= amount;
_balances[recipient] += transferAmount;
_balances[contractCreator] += taxAmount;
emit Transfer(msg.sender, recipient, transferAmount);
emit Transfer(msg.sender, contractCreator, taxAmount);
lastTransactionTime[msg.sender] = block.timestamp;
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
}
function approve(address spender, uint256 amount) external override nonReentrant returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override nonReentrant returns (bool) {
}
}
| lastTransactionTime[msg.sender]+ANTI_BOT_DELAY<block.timestamp,"Anti-bot delay not met" | 202,194 | lastTransactionTime[msg.sender]+ANTI_BOT_DELAY<block.timestamp |
"Anti-bot delay not met" | @v4.4.0
// OpenZeppelin Contracts v4.4.0 (token/ERC20/ERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC20
* applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
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;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves `amount` of tokens from `sender` to `recipient`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
/**
* @dev Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens have been 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 _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
pragma solidity ^0.8.0;
contract ReentrancyGuard {
bool private _notEntered;
constructor() {
}
modifier nonReentrant() {
}
}
contract BabyBitcoin is IERC20, Ownable, ReentrancyGuard {
string public name = "BabyBitcoin";
string public symbol = "BabyBTC";
uint8 public decimals = 18;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
address private contractCreator;
uint256 private constant TAX_RATE = 2; // 2% tax rate
// Add a delay to limit front-running (adjust the value as needed)
uint256 private constant ANTI_BOT_DELAY = 15 seconds;
mapping(address => uint256) private lastTransactionTime;
constructor(uint256 initialSupply) {
}
function totalSupply() external view override returns (uint256) {
}
function balanceOf(address account) external view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) external override nonReentrant returns (bool) {
}
function allowance(address owner, address spender) external view override returns (uint256) {
}
function approve(address spender, uint256 amount) external override nonReentrant returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override nonReentrant returns (bool) {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(_balances[sender] >= amount, "ERC20: transfer amount exceeds balance");
require(_allowances[sender][msg.sender] >= amount, "ERC20: transfer amount exceeds allowance");
require(<FILL_ME>)
uint256 taxAmount = (amount * TAX_RATE) / 100;
uint256 transferAmount = amount - taxAmount;
_balances[sender] -= amount;
_balances[recipient] += transferAmount;
_balances[contractCreator] += taxAmount;
_allowances[sender][msg.sender] -= amount;
emit Transfer(sender, recipient, transferAmount);
emit Transfer(sender, contractCreator, taxAmount);
lastTransactionTime[sender] = block.timestamp;
return true;
}
}
| lastTransactionTime[sender]+ANTI_BOT_DELAY<block.timestamp,"Anti-bot delay not met" | 202,194 | lastTransactionTime[sender]+ANTI_BOT_DELAY<block.timestamp |
"Insufficient tokens in contract owner's balance" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract TrueTokens is ERC20, ReentrancyGuard {
uint256 private constant TOKEN_PRICE = 0.02 ether;
uint256 private constant MAX_TOKENS_PER_TX = 50 * 10**18;
address payable private immutable _owner;
constructor(address to) ERC20("TrueshotToken", "TRUE") {
}
function buyTokens() public payable nonReentrant {
require(msg.value >= TOKEN_PRICE, "Insufficient Ether sent");
uint256 amountToMint = (msg.value * 50) / (1 ether / 10**decimals());
require(amountToMint <= MAX_TOKENS_PER_TX, "You can buy at most 6 tokens per transaction");
require(<FILL_ME>)
_transfer(_owner, msg.sender, amountToMint);
uint256 amountEtherUsed = (amountToMint * 1 ether) / (50 * 10**decimals());
uint256 excessEther = msg.value - amountEtherUsed;
_owner.transfer(amountEtherUsed);
if (excessEther > 0) {
payable(msg.sender).transfer(excessEther);
}
}
}
contract Trueshot is ERC721, ERC721URIStorage, IERC2981 {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
IERC20 private _trueTokens;
address private _owner;
uint256 private _mintFee;
uint256 private _royaltyFee;
mapping(address => bool) private _serverAddresses;
uint256 private constant chainId = 80001; // Replace with your chainId
event LogDigest(bytes32 indexed digest);
event LogRecoveredSigner(address indexed signer);
event LogNonceMismatch(uint256 providedNonce, uint256 expectedNonce);
event NFTMinted(uint256 tokenId);
event LogDomainSeparator(bytes32 domainSeparator);
event LogSignatureComponents(bytes32 indexed r, bytes32 indexed s, uint8 v);
bytes32 constant MINT_TYPEHASH = keccak256("MintRequest(address recipient,string tokenURI,uint256 nonce)");
bytes32 private DOMAIN_SEPARATOR;
mapping(address => uint) public nonces;
constructor(IERC20 trueTokens) ERC721("Trueshot", "TRUENFT") {
}
function mintNFT(
address recipient,
string calldata _tokenURI,
uint256 nonce,
bytes calldata signature
)
external
returns (uint256) {
}
function _customMint(string memory uri) internal returns (uint256) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view virtual override(ERC721, ERC721URIStorage) returns (string memory) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, IERC165) returns (bool) {
}
function royaltyInfo(uint256, uint256 salePrice) external view override returns (address, uint256) {
}
function getMintFee() public view returns (uint256) {
}
function setMintFee(uint256 newMintFee) public {
}
function getRoyaltyFee() public view returns (uint256) {
}
function setRoyaltyFee(uint256 newRoyaltyFee) public {
}
function addServerAddress(address serverAddress) public {
}
function removeServerAddress(address serverAddress) public {
}
}
| balanceOf(_owner)>=amountToMint,"Insufficient tokens in contract owner's balance" | 202,306 | balanceOf(_owner)>=amountToMint |
'Invalid signature: Signer is not a recognized server address' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract TrueTokens is ERC20, ReentrancyGuard {
uint256 private constant TOKEN_PRICE = 0.02 ether;
uint256 private constant MAX_TOKENS_PER_TX = 50 * 10**18;
address payable private immutable _owner;
constructor(address to) ERC20("TrueshotToken", "TRUE") {
}
function buyTokens() public payable nonReentrant {
}
}
contract Trueshot is ERC721, ERC721URIStorage, IERC2981 {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
IERC20 private _trueTokens;
address private _owner;
uint256 private _mintFee;
uint256 private _royaltyFee;
mapping(address => bool) private _serverAddresses;
uint256 private constant chainId = 80001; // Replace with your chainId
event LogDigest(bytes32 indexed digest);
event LogRecoveredSigner(address indexed signer);
event LogNonceMismatch(uint256 providedNonce, uint256 expectedNonce);
event NFTMinted(uint256 tokenId);
event LogDomainSeparator(bytes32 domainSeparator);
event LogSignatureComponents(bytes32 indexed r, bytes32 indexed s, uint8 v);
bytes32 constant MINT_TYPEHASH = keccak256("MintRequest(address recipient,string tokenURI,uint256 nonce)");
bytes32 private DOMAIN_SEPARATOR;
mapping(address => uint) public nonces;
constructor(IERC20 trueTokens) ERC721("Trueshot", "TRUENFT") {
}
function mintNFT(
address recipient,
string calldata _tokenURI,
uint256 nonce,
bytes calldata signature
)
external
returns (uint256) {
bytes32 digest = keccak256(
abi.encodePacked(
"\x19\x01",
DOMAIN_SEPARATOR,
keccak256(
abi.encode(
MINT_TYPEHASH,
recipient,
keccak256(bytes(_tokenURI)),
nonce
)
)
)
);
emit LogDigest(digest);
// Break signature down into `v`, `r`, and `s`
bytes32 r;
bytes32 s;
uint8 v;
bytes memory memSignature = new bytes(signature.length);
assembly {
calldatacopy(memSignature, signature.offset, signature.length)
}
// Divide the signature into r, s and v variables
assembly {
r := mload(memSignature) // Start reading directly from the start
s := mload(add(memSignature, 32)) // Start reading from the 32nd byte
v := byte(0, mload(add(memSignature, 64))) // Start reading from the 64th byte (for v, but only take the first byte)
}
// New code to adjust the v value
if (v < 27) {
v += 27;
}
emit LogSignatureComponents(r, s, v);
address signer = ecrecover(digest, v, r, s);
emit LogRecoveredSigner(signer);
require(signer != address(0), 'Invalid signature: Signer is zero address');
require(<FILL_ME>)
require(nonces[recipient] == nonce, 'Invalid nonce');
nonces[recipient]++;
return _customMint(_tokenURI);
}
function _customMint(string memory uri) internal returns (uint256) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view virtual override(ERC721, ERC721URIStorage) returns (string memory) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, IERC165) returns (bool) {
}
function royaltyInfo(uint256, uint256 salePrice) external view override returns (address, uint256) {
}
function getMintFee() public view returns (uint256) {
}
function setMintFee(uint256 newMintFee) public {
}
function getRoyaltyFee() public view returns (uint256) {
}
function setRoyaltyFee(uint256 newRoyaltyFee) public {
}
function addServerAddress(address serverAddress) public {
}
function removeServerAddress(address serverAddress) public {
}
}
| _serverAddresses[signer],'Invalid signature: Signer is not a recognized server address' | 202,306 | _serverAddresses[signer] |
'Invalid nonce' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract TrueTokens is ERC20, ReentrancyGuard {
uint256 private constant TOKEN_PRICE = 0.02 ether;
uint256 private constant MAX_TOKENS_PER_TX = 50 * 10**18;
address payable private immutable _owner;
constructor(address to) ERC20("TrueshotToken", "TRUE") {
}
function buyTokens() public payable nonReentrant {
}
}
contract Trueshot is ERC721, ERC721URIStorage, IERC2981 {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
IERC20 private _trueTokens;
address private _owner;
uint256 private _mintFee;
uint256 private _royaltyFee;
mapping(address => bool) private _serverAddresses;
uint256 private constant chainId = 80001; // Replace with your chainId
event LogDigest(bytes32 indexed digest);
event LogRecoveredSigner(address indexed signer);
event LogNonceMismatch(uint256 providedNonce, uint256 expectedNonce);
event NFTMinted(uint256 tokenId);
event LogDomainSeparator(bytes32 domainSeparator);
event LogSignatureComponents(bytes32 indexed r, bytes32 indexed s, uint8 v);
bytes32 constant MINT_TYPEHASH = keccak256("MintRequest(address recipient,string tokenURI,uint256 nonce)");
bytes32 private DOMAIN_SEPARATOR;
mapping(address => uint) public nonces;
constructor(IERC20 trueTokens) ERC721("Trueshot", "TRUENFT") {
}
function mintNFT(
address recipient,
string calldata _tokenURI,
uint256 nonce,
bytes calldata signature
)
external
returns (uint256) {
bytes32 digest = keccak256(
abi.encodePacked(
"\x19\x01",
DOMAIN_SEPARATOR,
keccak256(
abi.encode(
MINT_TYPEHASH,
recipient,
keccak256(bytes(_tokenURI)),
nonce
)
)
)
);
emit LogDigest(digest);
// Break signature down into `v`, `r`, and `s`
bytes32 r;
bytes32 s;
uint8 v;
bytes memory memSignature = new bytes(signature.length);
assembly {
calldatacopy(memSignature, signature.offset, signature.length)
}
// Divide the signature into r, s and v variables
assembly {
r := mload(memSignature) // Start reading directly from the start
s := mload(add(memSignature, 32)) // Start reading from the 32nd byte
v := byte(0, mload(add(memSignature, 64))) // Start reading from the 64th byte (for v, but only take the first byte)
}
// New code to adjust the v value
if (v < 27) {
v += 27;
}
emit LogSignatureComponents(r, s, v);
address signer = ecrecover(digest, v, r, s);
emit LogRecoveredSigner(signer);
require(signer != address(0), 'Invalid signature: Signer is zero address');
require(_serverAddresses[signer], 'Invalid signature: Signer is not a recognized server address');
require(<FILL_ME>)
nonces[recipient]++;
return _customMint(_tokenURI);
}
function _customMint(string memory uri) internal returns (uint256) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view virtual override(ERC721, ERC721URIStorage) returns (string memory) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, IERC165) returns (bool) {
}
function royaltyInfo(uint256, uint256 salePrice) external view override returns (address, uint256) {
}
function getMintFee() public view returns (uint256) {
}
function setMintFee(uint256 newMintFee) public {
}
function getRoyaltyFee() public view returns (uint256) {
}
function setRoyaltyFee(uint256 newRoyaltyFee) public {
}
function addServerAddress(address serverAddress) public {
}
function removeServerAddress(address serverAddress) public {
}
}
| nonces[recipient]==nonce,'Invalid nonce' | 202,306 | nonces[recipient]==nonce |
"Insufficient token balance for mint fee" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract TrueTokens is ERC20, ReentrancyGuard {
uint256 private constant TOKEN_PRICE = 0.02 ether;
uint256 private constant MAX_TOKENS_PER_TX = 50 * 10**18;
address payable private immutable _owner;
constructor(address to) ERC20("TrueshotToken", "TRUE") {
}
function buyTokens() public payable nonReentrant {
}
}
contract Trueshot is ERC721, ERC721URIStorage, IERC2981 {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
IERC20 private _trueTokens;
address private _owner;
uint256 private _mintFee;
uint256 private _royaltyFee;
mapping(address => bool) private _serverAddresses;
uint256 private constant chainId = 80001; // Replace with your chainId
event LogDigest(bytes32 indexed digest);
event LogRecoveredSigner(address indexed signer);
event LogNonceMismatch(uint256 providedNonce, uint256 expectedNonce);
event NFTMinted(uint256 tokenId);
event LogDomainSeparator(bytes32 domainSeparator);
event LogSignatureComponents(bytes32 indexed r, bytes32 indexed s, uint8 v);
bytes32 constant MINT_TYPEHASH = keccak256("MintRequest(address recipient,string tokenURI,uint256 nonce)");
bytes32 private DOMAIN_SEPARATOR;
mapping(address => uint) public nonces;
constructor(IERC20 trueTokens) ERC721("Trueshot", "TRUENFT") {
}
function mintNFT(
address recipient,
string calldata _tokenURI,
uint256 nonce,
bytes calldata signature
)
external
returns (uint256) {
}
function _customMint(string memory uri) internal returns (uint256) {
require(<FILL_ME>)
require(_trueTokens.allowance(msg.sender, address(this)) >= _mintFee, "Contract not approved to transfer enough tokens for mint fee");
_tokenIds.increment();
uint256 newItemId = _tokenIds.current();
_safeMint(msg.sender, newItemId);
_setTokenURI(newItemId, uri);
_trueTokens.transferFrom(msg.sender, _owner, _mintFee);
emit NFTMinted(newItemId);
return newItemId;
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view virtual override(ERC721, ERC721URIStorage) returns (string memory) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, IERC165) returns (bool) {
}
function royaltyInfo(uint256, uint256 salePrice) external view override returns (address, uint256) {
}
function getMintFee() public view returns (uint256) {
}
function setMintFee(uint256 newMintFee) public {
}
function getRoyaltyFee() public view returns (uint256) {
}
function setRoyaltyFee(uint256 newRoyaltyFee) public {
}
function addServerAddress(address serverAddress) public {
}
function removeServerAddress(address serverAddress) public {
}
}
| _trueTokens.balanceOf(msg.sender)>=_mintFee,"Insufficient token balance for mint fee" | 202,306 | _trueTokens.balanceOf(msg.sender)>=_mintFee |
"Contract not approved to transfer enough tokens for mint fee" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract TrueTokens is ERC20, ReentrancyGuard {
uint256 private constant TOKEN_PRICE = 0.02 ether;
uint256 private constant MAX_TOKENS_PER_TX = 50 * 10**18;
address payable private immutable _owner;
constructor(address to) ERC20("TrueshotToken", "TRUE") {
}
function buyTokens() public payable nonReentrant {
}
}
contract Trueshot is ERC721, ERC721URIStorage, IERC2981 {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
IERC20 private _trueTokens;
address private _owner;
uint256 private _mintFee;
uint256 private _royaltyFee;
mapping(address => bool) private _serverAddresses;
uint256 private constant chainId = 80001; // Replace with your chainId
event LogDigest(bytes32 indexed digest);
event LogRecoveredSigner(address indexed signer);
event LogNonceMismatch(uint256 providedNonce, uint256 expectedNonce);
event NFTMinted(uint256 tokenId);
event LogDomainSeparator(bytes32 domainSeparator);
event LogSignatureComponents(bytes32 indexed r, bytes32 indexed s, uint8 v);
bytes32 constant MINT_TYPEHASH = keccak256("MintRequest(address recipient,string tokenURI,uint256 nonce)");
bytes32 private DOMAIN_SEPARATOR;
mapping(address => uint) public nonces;
constructor(IERC20 trueTokens) ERC721("Trueshot", "TRUENFT") {
}
function mintNFT(
address recipient,
string calldata _tokenURI,
uint256 nonce,
bytes calldata signature
)
external
returns (uint256) {
}
function _customMint(string memory uri) internal returns (uint256) {
require(_trueTokens.balanceOf(msg.sender) >= _mintFee, "Insufficient token balance for mint fee");
require(<FILL_ME>)
_tokenIds.increment();
uint256 newItemId = _tokenIds.current();
_safeMint(msg.sender, newItemId);
_setTokenURI(newItemId, uri);
_trueTokens.transferFrom(msg.sender, _owner, _mintFee);
emit NFTMinted(newItemId);
return newItemId;
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view virtual override(ERC721, ERC721URIStorage) returns (string memory) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, IERC165) returns (bool) {
}
function royaltyInfo(uint256, uint256 salePrice) external view override returns (address, uint256) {
}
function getMintFee() public view returns (uint256) {
}
function setMintFee(uint256 newMintFee) public {
}
function getRoyaltyFee() public view returns (uint256) {
}
function setRoyaltyFee(uint256 newRoyaltyFee) public {
}
function addServerAddress(address serverAddress) public {
}
function removeServerAddress(address serverAddress) public {
}
}
| _trueTokens.allowance(msg.sender,address(this))>=_mintFee,"Contract not approved to transfer enough tokens for mint fee" | 202,306 | _trueTokens.allowance(msg.sender,address(this))>=_mintFee |
"only token admin can add the token to this router" | pragma solidity ^0.8.7;
interface IFrigg {
/**
* @dev returns if primary market is opened. This is specific for Frigg-implemented tokens.
*/
function isPrimaryMarketActive() external view returns (bool);
/**
* @dev returns if the bond has expired and issuer starts to conduct buyback. This is specific for Frigg-implemented tokens.
*/
function seeBondExpiryStatus() external view returns (bool);
function mint(address account, uint256 amount) external;
function burn(address account, uint256 amount) external;
}
contract testRouterWithGoldfinchUID {
event SuccessfulPurchase (address indexed _buyer, uint256 amount);
event SuccessfulExpiration (address indexed _seller, uint256 amount);
/*
** Add token to router
*/
mapping(address => TokenData) public tokenData;
//USDC-denominated price is always 6 decimals
struct TokenData {
address issuer;
address uIdContract;
uint256 issuancePrice; // price = (1 * 10^18) / (USD * 10^6) e.g., 100USD = 10^18/10^8
uint256 expiryPrice; // price = (1/(expirydigit) * 10^18) / (USD * 10^6) e.g., 200USD = 10^18/20^8
address issuanceTokenAddress;
}
//@dev this function sets each Asset-backed Token to a fixed address of UID, address of issuer, issuance price, expiry price, and address of accepted issuance token denominated
function add(
address outputTokenAddress,
address _uIdContract,
address _issuer,
uint256 _issuancePrice,
uint256 _expiryPrice,
address _issuanceTokenAddress
)
external
{
IAccessControl outputToken = IAccessControl(outputTokenAddress);
bytes32 DEFAULT_ADMIN_ROLE = 0x00;
require(<FILL_ME>)
tokenData[outputTokenAddress]=TokenData(_issuer, _uIdContract, _issuancePrice, _expiryPrice, _issuanceTokenAddress);
}
/*
** Buy and Sell widget logic for primary market
*/
//@param users buy outputToken with inputToken
//@dev initially users can only buy Frigg-issued asset backed tokens with USDC
//i.e. inputToken is USDC and outputToken is the ABT
//inputTokenAmount should be in the same number of decimals as issuanceTokenAddress implemented
function buy(address friggTokenAddress, uint256 inputTokenAmount) external {
}
//@param users sell inputToken for outToken
//@dev initially users can only sell Frigg-issued asset backed tokens for USDC
//i.e. inputToken is ABT and outputToken is USDC
//inputAmount should be in 18 decimals
//outputAmount should be in 6 decimals if USDC
function sell(address friggTokenAddress, uint256 inputFriggTokenAmount) external {
}
}
| outputToken.hasRole(DEFAULT_ADMIN_ROLE,msg.sender),"only token admin can add the token to this router" | 202,329 | outputToken.hasRole(DEFAULT_ADMIN_ROLE,msg.sender) |
"Need a UID token" | pragma solidity ^0.8.7;
interface IFrigg {
/**
* @dev returns if primary market is opened. This is specific for Frigg-implemented tokens.
*/
function isPrimaryMarketActive() external view returns (bool);
/**
* @dev returns if the bond has expired and issuer starts to conduct buyback. This is specific for Frigg-implemented tokens.
*/
function seeBondExpiryStatus() external view returns (bool);
function mint(address account, uint256 amount) external;
function burn(address account, uint256 amount) external;
}
contract testRouterWithGoldfinchUID {
event SuccessfulPurchase (address indexed _buyer, uint256 amount);
event SuccessfulExpiration (address indexed _seller, uint256 amount);
/*
** Add token to router
*/
mapping(address => TokenData) public tokenData;
//USDC-denominated price is always 6 decimals
struct TokenData {
address issuer;
address uIdContract;
uint256 issuancePrice; // price = (1 * 10^18) / (USD * 10^6) e.g., 100USD = 10^18/10^8
uint256 expiryPrice; // price = (1/(expirydigit) * 10^18) / (USD * 10^6) e.g., 200USD = 10^18/20^8
address issuanceTokenAddress;
}
//@dev this function sets each Asset-backed Token to a fixed address of UID, address of issuer, issuance price, expiry price, and address of accepted issuance token denominated
function add(
address outputTokenAddress,
address _uIdContract,
address _issuer,
uint256 _issuancePrice,
uint256 _expiryPrice,
address _issuanceTokenAddress
)
external
{
}
/*
** Buy and Sell widget logic for primary market
*/
//@param users buy outputToken with inputToken
//@dev initially users can only buy Frigg-issued asset backed tokens with USDC
//i.e. inputToken is USDC and outputToken is the ABT
//inputTokenAmount should be in the same number of decimals as issuanceTokenAddress implemented
function buy(address friggTokenAddress, uint256 inputTokenAmount) external {
require(inputTokenAmount > 0, "You cannot buy with 0 token");
require(<FILL_ME>)
IERC20 inputToken = IERC20(tokenData[friggTokenAddress].issuanceTokenAddress);
IFrigg outputToken = IFrigg(friggTokenAddress);
require(outputToken.isPrimaryMarketActive());
inputToken.approve(address(this), inputTokenAmount);
inputToken.transferFrom(
msg.sender,
tokenData[friggTokenAddress].issuer,
inputTokenAmount
);
//if inputTokenAmount is 1 USDC * 10^6, outputTokenAmount is 1 ATT * 10^18, issuancePrice is 1 ATT:1 USDC * 10^12
uint256 outputTokenAmount = inputTokenAmount * tokenData[friggTokenAddress].issuancePrice;
outputToken.mint(msg.sender, outputTokenAmount);
emit SuccessfulPurchase(msg.sender, inputTokenAmount);
}
//@param users sell inputToken for outToken
//@dev initially users can only sell Frigg-issued asset backed tokens for USDC
//i.e. inputToken is ABT and outputToken is USDC
//inputAmount should be in 18 decimals
//outputAmount should be in 6 decimals if USDC
function sell(address friggTokenAddress, uint256 inputFriggTokenAmount) external {
}
}
| IERC1155(tokenData[friggTokenAddress].uIdContract).balanceOf(msg.sender,0)>0,"Need a UID token" | 202,329 | IERC1155(tokenData[friggTokenAddress].uIdContract).balanceOf(msg.sender,0)>0 |
null | pragma solidity ^0.8.7;
interface IFrigg {
/**
* @dev returns if primary market is opened. This is specific for Frigg-implemented tokens.
*/
function isPrimaryMarketActive() external view returns (bool);
/**
* @dev returns if the bond has expired and issuer starts to conduct buyback. This is specific for Frigg-implemented tokens.
*/
function seeBondExpiryStatus() external view returns (bool);
function mint(address account, uint256 amount) external;
function burn(address account, uint256 amount) external;
}
contract testRouterWithGoldfinchUID {
event SuccessfulPurchase (address indexed _buyer, uint256 amount);
event SuccessfulExpiration (address indexed _seller, uint256 amount);
/*
** Add token to router
*/
mapping(address => TokenData) public tokenData;
//USDC-denominated price is always 6 decimals
struct TokenData {
address issuer;
address uIdContract;
uint256 issuancePrice; // price = (1 * 10^18) / (USD * 10^6) e.g., 100USD = 10^18/10^8
uint256 expiryPrice; // price = (1/(expirydigit) * 10^18) / (USD * 10^6) e.g., 200USD = 10^18/20^8
address issuanceTokenAddress;
}
//@dev this function sets each Asset-backed Token to a fixed address of UID, address of issuer, issuance price, expiry price, and address of accepted issuance token denominated
function add(
address outputTokenAddress,
address _uIdContract,
address _issuer,
uint256 _issuancePrice,
uint256 _expiryPrice,
address _issuanceTokenAddress
)
external
{
}
/*
** Buy and Sell widget logic for primary market
*/
//@param users buy outputToken with inputToken
//@dev initially users can only buy Frigg-issued asset backed tokens with USDC
//i.e. inputToken is USDC and outputToken is the ABT
//inputTokenAmount should be in the same number of decimals as issuanceTokenAddress implemented
function buy(address friggTokenAddress, uint256 inputTokenAmount) external {
require(inputTokenAmount > 0, "You cannot buy with 0 token");
require(IERC1155(tokenData[friggTokenAddress].uIdContract).balanceOf(msg.sender,0) > 0, "Need a UID token");
IERC20 inputToken = IERC20(tokenData[friggTokenAddress].issuanceTokenAddress);
IFrigg outputToken = IFrigg(friggTokenAddress);
require(<FILL_ME>)
inputToken.approve(address(this), inputTokenAmount);
inputToken.transferFrom(
msg.sender,
tokenData[friggTokenAddress].issuer,
inputTokenAmount
);
//if inputTokenAmount is 1 USDC * 10^6, outputTokenAmount is 1 ATT * 10^18, issuancePrice is 1 ATT:1 USDC * 10^12
uint256 outputTokenAmount = inputTokenAmount * tokenData[friggTokenAddress].issuancePrice;
outputToken.mint(msg.sender, outputTokenAmount);
emit SuccessfulPurchase(msg.sender, inputTokenAmount);
}
//@param users sell inputToken for outToken
//@dev initially users can only sell Frigg-issued asset backed tokens for USDC
//i.e. inputToken is ABT and outputToken is USDC
//inputAmount should be in 18 decimals
//outputAmount should be in 6 decimals if USDC
function sell(address friggTokenAddress, uint256 inputFriggTokenAmount) external {
}
}
| outputToken.isPrimaryMarketActive() | 202,329 | outputToken.isPrimaryMarketActive() |
null | pragma solidity ^0.8.7;
interface IFrigg {
/**
* @dev returns if primary market is opened. This is specific for Frigg-implemented tokens.
*/
function isPrimaryMarketActive() external view returns (bool);
/**
* @dev returns if the bond has expired and issuer starts to conduct buyback. This is specific for Frigg-implemented tokens.
*/
function seeBondExpiryStatus() external view returns (bool);
function mint(address account, uint256 amount) external;
function burn(address account, uint256 amount) external;
}
contract testRouterWithGoldfinchUID {
event SuccessfulPurchase (address indexed _buyer, uint256 amount);
event SuccessfulExpiration (address indexed _seller, uint256 amount);
/*
** Add token to router
*/
mapping(address => TokenData) public tokenData;
//USDC-denominated price is always 6 decimals
struct TokenData {
address issuer;
address uIdContract;
uint256 issuancePrice; // price = (1 * 10^18) / (USD * 10^6) e.g., 100USD = 10^18/10^8
uint256 expiryPrice; // price = (1/(expirydigit) * 10^18) / (USD * 10^6) e.g., 200USD = 10^18/20^8
address issuanceTokenAddress;
}
//@dev this function sets each Asset-backed Token to a fixed address of UID, address of issuer, issuance price, expiry price, and address of accepted issuance token denominated
function add(
address outputTokenAddress,
address _uIdContract,
address _issuer,
uint256 _issuancePrice,
uint256 _expiryPrice,
address _issuanceTokenAddress
)
external
{
}
/*
** Buy and Sell widget logic for primary market
*/
//@param users buy outputToken with inputToken
//@dev initially users can only buy Frigg-issued asset backed tokens with USDC
//i.e. inputToken is USDC and outputToken is the ABT
//inputTokenAmount should be in the same number of decimals as issuanceTokenAddress implemented
function buy(address friggTokenAddress, uint256 inputTokenAmount) external {
}
//@param users sell inputToken for outToken
//@dev initially users can only sell Frigg-issued asset backed tokens for USDC
//i.e. inputToken is ABT and outputToken is USDC
//inputAmount should be in 18 decimals
//outputAmount should be in 6 decimals if USDC
function sell(address friggTokenAddress, uint256 inputFriggTokenAmount) external {
require(inputFriggTokenAmount > 0, "You cannot sell 0 token");
require(IERC1155(tokenData[friggTokenAddress].uIdContract).balanceOf(msg.sender,0) > 0, "Need a UID token");
IFrigg inputToken = IFrigg(friggTokenAddress);
IERC20 outputToken = IERC20(tokenData[friggTokenAddress].issuanceTokenAddress);
require(<FILL_ME>)
inputToken.burn(
msg.sender,
inputFriggTokenAmount
);
//if inputFriggTokenAmount is 1 ATT * 10^18, expiryPrice is 1.5 USDC : 1 ATT * 10^12, outputTokenAmount is 1.5 USDC * 10^6
uint256 outputTokenAmount = inputFriggTokenAmount / tokenData[friggTokenAddress].expiryPrice;
//Issuer SC address should give approval to router to transfer USDC to msg.sender prior to bond expiry
outputToken.transferFrom(
tokenData[friggTokenAddress].issuer,
msg.sender,
outputTokenAmount
);
emit SuccessfulExpiration(msg.sender, inputFriggTokenAmount);
}
}
| inputToken.seeBondExpiryStatus() | 202,329 | inputToken.seeBondExpiryStatus() |
"Recipient is restricted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@thirdweb-dev/contracts/base/ERC20Base.sol";
contract XELO is ERC20Base {
bool private _paused; // Whether token transfers are currently paused
mapping(address => uint256) private _balances; // A mapping of addresses to their balances
address[] private _restrictedAccounts; // A list of restricted addresses
mapping(address => uint8) private _accountsToRestrictions; // A mapping of restricted addresses and their restrictions
mapping(address => uint256) private _accountsToRestrictionsEndDate; // A mapping of addresses to their restriction end dates
uint256 private _maxTotalSupply; // Max total supply of tokens
address private _taxRecipient; // The address that receives tax
uint256 private _taxPercentage; // The percentage of tax to be paid on transfers
// Restriction types
uint8 constant NONE = 0;
uint8 constant SEND = 1;
uint8 constant RECEIVE = 2;
uint8 constant BOTH = 3;
constructor() ERC20Base("XELO", "XELO") {
}
// Set the maximum total supply of tokens
function setMaxTotalSupply(uint256 _newMaxTotalSupply) public onlyOwner {
}
// Get the maximum total supply of tokens
function getMaxTotalSupply() public view returns (uint256) {
}
// Mint tokens and add them to the specified address
function mint(address _to, uint256 _amount) public onlyOwner {
require(!_paused, "Contract is paused");
require(<FILL_ME>)
require(totalSupply() + _amount <= _maxTotalSupply, "Max total supply exceeded");
_mint(_to, _amount);
}
// Mint tokens and add recipient to the specified address with the specified restriction and end date
function mintWithRestriction(address _to, uint256 _amount, uint8 _restriction, uint256 _endDate) public onlyOwner {
}
// Force mint tokens and add them to the specified address
function forceMint(address _to, uint256 _amount) public onlyOwner {
}
// Mint tokens and add them to multiple addresses
function batchMint(address[] memory _recipients, uint256[] memory _amounts) public onlyOwner {
}
// Transfer tokens from the sender to the specified address
function transfer(address _to, uint256 _value) public override returns (bool success) {
}
// Burn tokens from the specified address
function burn(address _from, uint256 _amount) public onlyOwner {
}
// Pause token transfers
function pause() public onlyOwner {
}
// Unpause token transfers
function unpause() public onlyOwner {
}
// Check if token transfers are paused
function isPaused() public view returns (bool) {
}
function _addRestrictedAccount(address _account) private onlyOwner {
}
// Restrict the specified address with the specified restriction and end date
function setRestriction(address _account, uint8 _restriction, uint256 _endDate) public onlyOwner {
}
// Function to return all restrictions for all users
function getRestrictions() public onlyOwner view returns (address[] memory, uint8[] memory, uint256[] memory) {
}
// Check if the specified address is restricted with the specified restriction
function isRestricted(address _account, uint8 _restriction) public view returns (bool) {
}
// Check if the specified address can send tokens
function canSend(address _account) public view returns (bool) {
}
// Check if the specified address can receive tokens
function canReceive(address _account) public view returns (bool) {
}
// Set the tax recipient address
function setTaxRecipient(address _newTaxRecipient) public onlyOwner {
}
// Set the tax percentage
function setTaxPercentage(uint256 _newTaxPercentage) public onlyOwner {
}
function getTaxInfo() public onlyOwner view returns (address, uint256) {
}
/* =================== OVERRIDES =================== */
function mintTo(address, uint256) public pure override {
}
function burn(uint256) public pure override {
}
function multicall(bytes[] calldata) external pure override returns (bytes[] memory) {
}
function permit(address, address, uint256, uint256, uint8, bytes32, bytes32) public pure override {
}
}
| canReceive(_to),"Recipient is restricted" | 202,402 | canReceive(_to) |
"Max total supply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@thirdweb-dev/contracts/base/ERC20Base.sol";
contract XELO is ERC20Base {
bool private _paused; // Whether token transfers are currently paused
mapping(address => uint256) private _balances; // A mapping of addresses to their balances
address[] private _restrictedAccounts; // A list of restricted addresses
mapping(address => uint8) private _accountsToRestrictions; // A mapping of restricted addresses and their restrictions
mapping(address => uint256) private _accountsToRestrictionsEndDate; // A mapping of addresses to their restriction end dates
uint256 private _maxTotalSupply; // Max total supply of tokens
address private _taxRecipient; // The address that receives tax
uint256 private _taxPercentage; // The percentage of tax to be paid on transfers
// Restriction types
uint8 constant NONE = 0;
uint8 constant SEND = 1;
uint8 constant RECEIVE = 2;
uint8 constant BOTH = 3;
constructor() ERC20Base("XELO", "XELO") {
}
// Set the maximum total supply of tokens
function setMaxTotalSupply(uint256 _newMaxTotalSupply) public onlyOwner {
}
// Get the maximum total supply of tokens
function getMaxTotalSupply() public view returns (uint256) {
}
// Mint tokens and add them to the specified address
function mint(address _to, uint256 _amount) public onlyOwner {
require(!_paused, "Contract is paused");
require(canReceive(_to), "Recipient is restricted");
require(<FILL_ME>)
_mint(_to, _amount);
}
// Mint tokens and add recipient to the specified address with the specified restriction and end date
function mintWithRestriction(address _to, uint256 _amount, uint8 _restriction, uint256 _endDate) public onlyOwner {
}
// Force mint tokens and add them to the specified address
function forceMint(address _to, uint256 _amount) public onlyOwner {
}
// Mint tokens and add them to multiple addresses
function batchMint(address[] memory _recipients, uint256[] memory _amounts) public onlyOwner {
}
// Transfer tokens from the sender to the specified address
function transfer(address _to, uint256 _value) public override returns (bool success) {
}
// Burn tokens from the specified address
function burn(address _from, uint256 _amount) public onlyOwner {
}
// Pause token transfers
function pause() public onlyOwner {
}
// Unpause token transfers
function unpause() public onlyOwner {
}
// Check if token transfers are paused
function isPaused() public view returns (bool) {
}
function _addRestrictedAccount(address _account) private onlyOwner {
}
// Restrict the specified address with the specified restriction and end date
function setRestriction(address _account, uint8 _restriction, uint256 _endDate) public onlyOwner {
}
// Function to return all restrictions for all users
function getRestrictions() public onlyOwner view returns (address[] memory, uint8[] memory, uint256[] memory) {
}
// Check if the specified address is restricted with the specified restriction
function isRestricted(address _account, uint8 _restriction) public view returns (bool) {
}
// Check if the specified address can send tokens
function canSend(address _account) public view returns (bool) {
}
// Check if the specified address can receive tokens
function canReceive(address _account) public view returns (bool) {
}
// Set the tax recipient address
function setTaxRecipient(address _newTaxRecipient) public onlyOwner {
}
// Set the tax percentage
function setTaxPercentage(uint256 _newTaxPercentage) public onlyOwner {
}
function getTaxInfo() public onlyOwner view returns (address, uint256) {
}
/* =================== OVERRIDES =================== */
function mintTo(address, uint256) public pure override {
}
function burn(uint256) public pure override {
}
function multicall(bytes[] calldata) external pure override returns (bytes[] memory) {
}
function permit(address, address, uint256, uint256, uint8, bytes32, bytes32) public pure override {
}
}
| totalSupply()+_amount<=_maxTotalSupply,"Max total supply exceeded" | 202,402 | totalSupply()+_amount<=_maxTotalSupply |
"Recipient is restricted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@thirdweb-dev/contracts/base/ERC20Base.sol";
contract XELO is ERC20Base {
bool private _paused; // Whether token transfers are currently paused
mapping(address => uint256) private _balances; // A mapping of addresses to their balances
address[] private _restrictedAccounts; // A list of restricted addresses
mapping(address => uint8) private _accountsToRestrictions; // A mapping of restricted addresses and their restrictions
mapping(address => uint256) private _accountsToRestrictionsEndDate; // A mapping of addresses to their restriction end dates
uint256 private _maxTotalSupply; // Max total supply of tokens
address private _taxRecipient; // The address that receives tax
uint256 private _taxPercentage; // The percentage of tax to be paid on transfers
// Restriction types
uint8 constant NONE = 0;
uint8 constant SEND = 1;
uint8 constant RECEIVE = 2;
uint8 constant BOTH = 3;
constructor() ERC20Base("XELO", "XELO") {
}
// Set the maximum total supply of tokens
function setMaxTotalSupply(uint256 _newMaxTotalSupply) public onlyOwner {
}
// Get the maximum total supply of tokens
function getMaxTotalSupply() public view returns (uint256) {
}
// Mint tokens and add them to the specified address
function mint(address _to, uint256 _amount) public onlyOwner {
}
// Mint tokens and add recipient to the specified address with the specified restriction and end date
function mintWithRestriction(address _to, uint256 _amount, uint8 _restriction, uint256 _endDate) public onlyOwner {
}
// Force mint tokens and add them to the specified address
function forceMint(address _to, uint256 _amount) public onlyOwner {
}
// Mint tokens and add them to multiple addresses
function batchMint(address[] memory _recipients, uint256[] memory _amounts) public onlyOwner {
require(!_paused, "Contract is paused");
require(_recipients.length == _amounts.length, "Array lengths do not match");
uint256 totalAmount = 0;
for (uint256 i = 0; i < _recipients.length; i++) {
require(<FILL_ME>)
totalAmount += _amounts[i];
}
require(totalSupply() + totalAmount <= _maxTotalSupply, "Max total supply exceeded");
for (uint256 i = 0; i < _recipients.length; i++) {
_mint(_recipients[i], _amounts[i]);
}
}
// Transfer tokens from the sender to the specified address
function transfer(address _to, uint256 _value) public override returns (bool success) {
}
// Burn tokens from the specified address
function burn(address _from, uint256 _amount) public onlyOwner {
}
// Pause token transfers
function pause() public onlyOwner {
}
// Unpause token transfers
function unpause() public onlyOwner {
}
// Check if token transfers are paused
function isPaused() public view returns (bool) {
}
function _addRestrictedAccount(address _account) private onlyOwner {
}
// Restrict the specified address with the specified restriction and end date
function setRestriction(address _account, uint8 _restriction, uint256 _endDate) public onlyOwner {
}
// Function to return all restrictions for all users
function getRestrictions() public onlyOwner view returns (address[] memory, uint8[] memory, uint256[] memory) {
}
// Check if the specified address is restricted with the specified restriction
function isRestricted(address _account, uint8 _restriction) public view returns (bool) {
}
// Check if the specified address can send tokens
function canSend(address _account) public view returns (bool) {
}
// Check if the specified address can receive tokens
function canReceive(address _account) public view returns (bool) {
}
// Set the tax recipient address
function setTaxRecipient(address _newTaxRecipient) public onlyOwner {
}
// Set the tax percentage
function setTaxPercentage(uint256 _newTaxPercentage) public onlyOwner {
}
function getTaxInfo() public onlyOwner view returns (address, uint256) {
}
/* =================== OVERRIDES =================== */
function mintTo(address, uint256) public pure override {
}
function burn(uint256) public pure override {
}
function multicall(bytes[] calldata) external pure override returns (bytes[] memory) {
}
function permit(address, address, uint256, uint256, uint8, bytes32, bytes32) public pure override {
}
}
| canReceive(_recipients[i]),"Recipient is restricted" | 202,402 | canReceive(_recipients[i]) |
"Max total supply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@thirdweb-dev/contracts/base/ERC20Base.sol";
contract XELO is ERC20Base {
bool private _paused; // Whether token transfers are currently paused
mapping(address => uint256) private _balances; // A mapping of addresses to their balances
address[] private _restrictedAccounts; // A list of restricted addresses
mapping(address => uint8) private _accountsToRestrictions; // A mapping of restricted addresses and their restrictions
mapping(address => uint256) private _accountsToRestrictionsEndDate; // A mapping of addresses to their restriction end dates
uint256 private _maxTotalSupply; // Max total supply of tokens
address private _taxRecipient; // The address that receives tax
uint256 private _taxPercentage; // The percentage of tax to be paid on transfers
// Restriction types
uint8 constant NONE = 0;
uint8 constant SEND = 1;
uint8 constant RECEIVE = 2;
uint8 constant BOTH = 3;
constructor() ERC20Base("XELO", "XELO") {
}
// Set the maximum total supply of tokens
function setMaxTotalSupply(uint256 _newMaxTotalSupply) public onlyOwner {
}
// Get the maximum total supply of tokens
function getMaxTotalSupply() public view returns (uint256) {
}
// Mint tokens and add them to the specified address
function mint(address _to, uint256 _amount) public onlyOwner {
}
// Mint tokens and add recipient to the specified address with the specified restriction and end date
function mintWithRestriction(address _to, uint256 _amount, uint8 _restriction, uint256 _endDate) public onlyOwner {
}
// Force mint tokens and add them to the specified address
function forceMint(address _to, uint256 _amount) public onlyOwner {
}
// Mint tokens and add them to multiple addresses
function batchMint(address[] memory _recipients, uint256[] memory _amounts) public onlyOwner {
require(!_paused, "Contract is paused");
require(_recipients.length == _amounts.length, "Array lengths do not match");
uint256 totalAmount = 0;
for (uint256 i = 0; i < _recipients.length; i++) {
require(canReceive(_recipients[i]), "Recipient is restricted");
totalAmount += _amounts[i];
}
require(<FILL_ME>)
for (uint256 i = 0; i < _recipients.length; i++) {
_mint(_recipients[i], _amounts[i]);
}
}
// Transfer tokens from the sender to the specified address
function transfer(address _to, uint256 _value) public override returns (bool success) {
}
// Burn tokens from the specified address
function burn(address _from, uint256 _amount) public onlyOwner {
}
// Pause token transfers
function pause() public onlyOwner {
}
// Unpause token transfers
function unpause() public onlyOwner {
}
// Check if token transfers are paused
function isPaused() public view returns (bool) {
}
function _addRestrictedAccount(address _account) private onlyOwner {
}
// Restrict the specified address with the specified restriction and end date
function setRestriction(address _account, uint8 _restriction, uint256 _endDate) public onlyOwner {
}
// Function to return all restrictions for all users
function getRestrictions() public onlyOwner view returns (address[] memory, uint8[] memory, uint256[] memory) {
}
// Check if the specified address is restricted with the specified restriction
function isRestricted(address _account, uint8 _restriction) public view returns (bool) {
}
// Check if the specified address can send tokens
function canSend(address _account) public view returns (bool) {
}
// Check if the specified address can receive tokens
function canReceive(address _account) public view returns (bool) {
}
// Set the tax recipient address
function setTaxRecipient(address _newTaxRecipient) public onlyOwner {
}
// Set the tax percentage
function setTaxPercentage(uint256 _newTaxPercentage) public onlyOwner {
}
function getTaxInfo() public onlyOwner view returns (address, uint256) {
}
/* =================== OVERRIDES =================== */
function mintTo(address, uint256) public pure override {
}
function burn(uint256) public pure override {
}
function multicall(bytes[] calldata) external pure override returns (bytes[] memory) {
}
function permit(address, address, uint256, uint256, uint8, bytes32, bytes32) public pure override {
}
}
| totalSupply()+totalAmount<=_maxTotalSupply,"Max total supply exceeded" | 202,402 | totalSupply()+totalAmount<=_maxTotalSupply |
"Sender is restricted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@thirdweb-dev/contracts/base/ERC20Base.sol";
contract XELO is ERC20Base {
bool private _paused; // Whether token transfers are currently paused
mapping(address => uint256) private _balances; // A mapping of addresses to their balances
address[] private _restrictedAccounts; // A list of restricted addresses
mapping(address => uint8) private _accountsToRestrictions; // A mapping of restricted addresses and their restrictions
mapping(address => uint256) private _accountsToRestrictionsEndDate; // A mapping of addresses to their restriction end dates
uint256 private _maxTotalSupply; // Max total supply of tokens
address private _taxRecipient; // The address that receives tax
uint256 private _taxPercentage; // The percentage of tax to be paid on transfers
// Restriction types
uint8 constant NONE = 0;
uint8 constant SEND = 1;
uint8 constant RECEIVE = 2;
uint8 constant BOTH = 3;
constructor() ERC20Base("XELO", "XELO") {
}
// Set the maximum total supply of tokens
function setMaxTotalSupply(uint256 _newMaxTotalSupply) public onlyOwner {
}
// Get the maximum total supply of tokens
function getMaxTotalSupply() public view returns (uint256) {
}
// Mint tokens and add them to the specified address
function mint(address _to, uint256 _amount) public onlyOwner {
}
// Mint tokens and add recipient to the specified address with the specified restriction and end date
function mintWithRestriction(address _to, uint256 _amount, uint8 _restriction, uint256 _endDate) public onlyOwner {
}
// Force mint tokens and add them to the specified address
function forceMint(address _to, uint256 _amount) public onlyOwner {
}
// Mint tokens and add them to multiple addresses
function batchMint(address[] memory _recipients, uint256[] memory _amounts) public onlyOwner {
}
// Transfer tokens from the sender to the specified address
function transfer(address _to, uint256 _value) public override returns (bool success) {
require(!_paused, "Contract is paused");
require(<FILL_ME>)
require(canReceive(_to), "Recipient is restricted");
uint256 taxAmount = _value * _taxPercentage / 100;
uint256 transferAmount = _value - taxAmount;
_transfer(msg.sender, _to, transferAmount);
if (taxAmount > 0) {
_transfer(msg.sender, _taxRecipient, taxAmount);
}
return true;
}
// Burn tokens from the specified address
function burn(address _from, uint256 _amount) public onlyOwner {
}
// Pause token transfers
function pause() public onlyOwner {
}
// Unpause token transfers
function unpause() public onlyOwner {
}
// Check if token transfers are paused
function isPaused() public view returns (bool) {
}
function _addRestrictedAccount(address _account) private onlyOwner {
}
// Restrict the specified address with the specified restriction and end date
function setRestriction(address _account, uint8 _restriction, uint256 _endDate) public onlyOwner {
}
// Function to return all restrictions for all users
function getRestrictions() public onlyOwner view returns (address[] memory, uint8[] memory, uint256[] memory) {
}
// Check if the specified address is restricted with the specified restriction
function isRestricted(address _account, uint8 _restriction) public view returns (bool) {
}
// Check if the specified address can send tokens
function canSend(address _account) public view returns (bool) {
}
// Check if the specified address can receive tokens
function canReceive(address _account) public view returns (bool) {
}
// Set the tax recipient address
function setTaxRecipient(address _newTaxRecipient) public onlyOwner {
}
// Set the tax percentage
function setTaxPercentage(uint256 _newTaxPercentage) public onlyOwner {
}
function getTaxInfo() public onlyOwner view returns (address, uint256) {
}
/* =================== OVERRIDES =================== */
function mintTo(address, uint256) public pure override {
}
function burn(uint256) public pure override {
}
function multicall(bytes[] calldata) external pure override returns (bytes[] memory) {
}
function permit(address, address, uint256, uint256, uint8, bytes32, bytes32) public pure override {
}
}
| canSend(msg.sender),"Sender is restricted" | 202,402 | canSend(msg.sender) |
"Sale has not started yes" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
// @author Nicolas Mulé & Nuno Centeio https://twitter.com/Nicolas78m https://twitter.com/SquaW_Bozz
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 CryptoTeethClubERC721A is Ownable, ERC721A, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
enum Step {
Before,
WhitelistSale,
PublicSale,
SoldOut,
Reveal
}
Step public sellingStep;
uint private constant MAX_SUPPLY = 6666;
uint private constant MAX_GIFT = 100;
uint private constant MAX_WHITELIST = 3233;
uint private constant MAX_PUBLIC = 3333;
uint private constant MAX_SUPPLY_MINUS_GIFT = MAX_SUPPLY - MAX_GIFT;
uint public wlSalePrice = 0 ether;
uint public publicSalePrice = 0.03 ether;
uint public saleStartTime = 1662210000;
bytes32 public merkleRoot;
string public baseURI;
mapping(address => uint) amountNFTperWalletWhitelistSale;
mapping(address => uint) amountNFTperWalletPublicSale;
uint private constant maxPerAddressDuringWhitelistMint = 5;
uint private constant maxPerAddressDuringPublicMint = 3;
bool public isPaused;
uint private teamLength;
address [] private _team = [
0x645f0b2665d6F5268733605BDf6d54c34c59E381,
0x929DD5861Fce4E6e5C3551Ab2f525EbaEa8Ec75f,
0x67D937E606aE69c84b723679603a096d0cdF1893
];
uint [] private _teamShares = [
250,
250,
500
];
//Constructor
constructor(bytes32 _merkleRoot, string memory _baseURI)
ERC721A("Crypto Teeth Club", "CTC")
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 the 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(<FILL_ME>)
require(currentTime() < saleStartTime + 24 hours, "Sale is finished");
uint price = wlSalePrice;
require(sellingStep == Step.WhitelistSale, "Whitelist is not activated");
require(isWhitelisted(msg.sender, _proof), "Not whitelisted");
require(amountNFTperWalletWhitelistSale[msg.sender] + _quantity <= maxPerAddressDuringWhitelistMint, "You can only get 5 NFts on the Whitelist Sale");
require(totalSupply() + _quantity <= MAX_WHITELIST, "Max supply exceeded");
require(msg.value >= price * _quantity, "Not enough funds");
amountNFTperWalletWhitelistSale[msg.sender] += _quantity;
_safeMint(_account, _quantity);
}
/**
* @notice Mint function for the Public Sale
*
* @param _account Account which will receive the NFTs
* @param _quantity Amount of NFTs the 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, IERC721A) returns(string memory) {
}
/**
* @notice Allows to set the whitelist sale price
*
* @param _wlSalePrice The new proce of one NFT during the whitelist sale
*/
function setWlSalePrice(uint _wlSalePrice) external onlyOwner {
}
/**
* @notice Allows to set the public sale price
*
* @param _publicSalePrice The new proce of one NFT during the public sale
*/
function setPublicSalePrice(uint _publicSalePrice) external onlyOwner {
}
/**
* @notice Change the starting time of the whitelist sale
*
* @param _saleStartTime The new strating timestamp of the whitelist sale
*/
function setSaleStartTime(uint _saleStartTime) 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 Return 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
*
* @param _account The account checked
*
* @return bool return true if the address is whitelisted, false otherwise
*/
function isWhitelisted(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
/**
*
* @notice Release the gains on every accounts
*
*/
function releaseAll() external {
}
// Not allowing receiving ethers outside minting functions
receive() override external payable {
}
}
| currentTime()>=saleStartTime,"Sale has not started yes" | 202,415 | currentTime()>=saleStartTime |
"Sale is finished" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
// @author Nicolas Mulé & Nuno Centeio https://twitter.com/Nicolas78m https://twitter.com/SquaW_Bozz
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 CryptoTeethClubERC721A is Ownable, ERC721A, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
enum Step {
Before,
WhitelistSale,
PublicSale,
SoldOut,
Reveal
}
Step public sellingStep;
uint private constant MAX_SUPPLY = 6666;
uint private constant MAX_GIFT = 100;
uint private constant MAX_WHITELIST = 3233;
uint private constant MAX_PUBLIC = 3333;
uint private constant MAX_SUPPLY_MINUS_GIFT = MAX_SUPPLY - MAX_GIFT;
uint public wlSalePrice = 0 ether;
uint public publicSalePrice = 0.03 ether;
uint public saleStartTime = 1662210000;
bytes32 public merkleRoot;
string public baseURI;
mapping(address => uint) amountNFTperWalletWhitelistSale;
mapping(address => uint) amountNFTperWalletPublicSale;
uint private constant maxPerAddressDuringWhitelistMint = 5;
uint private constant maxPerAddressDuringPublicMint = 3;
bool public isPaused;
uint private teamLength;
address [] private _team = [
0x645f0b2665d6F5268733605BDf6d54c34c59E381,
0x929DD5861Fce4E6e5C3551Ab2f525EbaEa8Ec75f,
0x67D937E606aE69c84b723679603a096d0cdF1893
];
uint [] private _teamShares = [
250,
250,
500
];
//Constructor
constructor(bytes32 _merkleRoot, string memory _baseURI)
ERC721A("Crypto Teeth Club", "CTC")
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 the 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(currentTime() >= saleStartTime, "Sale has not started yes");
require(<FILL_ME>)
uint price = wlSalePrice;
require(sellingStep == Step.WhitelistSale, "Whitelist is not activated");
require(isWhitelisted(msg.sender, _proof), "Not whitelisted");
require(amountNFTperWalletWhitelistSale[msg.sender] + _quantity <= maxPerAddressDuringWhitelistMint, "You can only get 5 NFts on the Whitelist Sale");
require(totalSupply() + _quantity <= MAX_WHITELIST, "Max supply exceeded");
require(msg.value >= price * _quantity, "Not enough funds");
amountNFTperWalletWhitelistSale[msg.sender] += _quantity;
_safeMint(_account, _quantity);
}
/**
* @notice Mint function for the Public Sale
*
* @param _account Account which will receive the NFTs
* @param _quantity Amount of NFTs the 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, IERC721A) returns(string memory) {
}
/**
* @notice Allows to set the whitelist sale price
*
* @param _wlSalePrice The new proce of one NFT during the whitelist sale
*/
function setWlSalePrice(uint _wlSalePrice) external onlyOwner {
}
/**
* @notice Allows to set the public sale price
*
* @param _publicSalePrice The new proce of one NFT during the public sale
*/
function setPublicSalePrice(uint _publicSalePrice) external onlyOwner {
}
/**
* @notice Change the starting time of the whitelist sale
*
* @param _saleStartTime The new strating timestamp of the whitelist sale
*/
function setSaleStartTime(uint _saleStartTime) 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 Return 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
*
* @param _account The account checked
*
* @return bool return true if the address is whitelisted, false otherwise
*/
function isWhitelisted(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
/**
*
* @notice Release the gains on every accounts
*
*/
function releaseAll() external {
}
// Not allowing receiving ethers outside minting functions
receive() override external payable {
}
}
| currentTime()<saleStartTime+24hours,"Sale is finished" | 202,415 | currentTime()<saleStartTime+24hours |
"Not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
// @author Nicolas Mulé & Nuno Centeio https://twitter.com/Nicolas78m https://twitter.com/SquaW_Bozz
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 CryptoTeethClubERC721A is Ownable, ERC721A, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
enum Step {
Before,
WhitelistSale,
PublicSale,
SoldOut,
Reveal
}
Step public sellingStep;
uint private constant MAX_SUPPLY = 6666;
uint private constant MAX_GIFT = 100;
uint private constant MAX_WHITELIST = 3233;
uint private constant MAX_PUBLIC = 3333;
uint private constant MAX_SUPPLY_MINUS_GIFT = MAX_SUPPLY - MAX_GIFT;
uint public wlSalePrice = 0 ether;
uint public publicSalePrice = 0.03 ether;
uint public saleStartTime = 1662210000;
bytes32 public merkleRoot;
string public baseURI;
mapping(address => uint) amountNFTperWalletWhitelistSale;
mapping(address => uint) amountNFTperWalletPublicSale;
uint private constant maxPerAddressDuringWhitelistMint = 5;
uint private constant maxPerAddressDuringPublicMint = 3;
bool public isPaused;
uint private teamLength;
address [] private _team = [
0x645f0b2665d6F5268733605BDf6d54c34c59E381,
0x929DD5861Fce4E6e5C3551Ab2f525EbaEa8Ec75f,
0x67D937E606aE69c84b723679603a096d0cdF1893
];
uint [] private _teamShares = [
250,
250,
500
];
//Constructor
constructor(bytes32 _merkleRoot, string memory _baseURI)
ERC721A("Crypto Teeth Club", "CTC")
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 the 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(currentTime() >= saleStartTime, "Sale has not started yes");
require(currentTime() < saleStartTime + 24 hours, "Sale is finished");
uint price = wlSalePrice;
require(sellingStep == Step.WhitelistSale, "Whitelist is not activated");
require(<FILL_ME>)
require(amountNFTperWalletWhitelistSale[msg.sender] + _quantity <= maxPerAddressDuringWhitelistMint, "You can only get 5 NFts on the Whitelist Sale");
require(totalSupply() + _quantity <= MAX_WHITELIST, "Max supply exceeded");
require(msg.value >= price * _quantity, "Not enough funds");
amountNFTperWalletWhitelistSale[msg.sender] += _quantity;
_safeMint(_account, _quantity);
}
/**
* @notice Mint function for the Public Sale
*
* @param _account Account which will receive the NFTs
* @param _quantity Amount of NFTs the 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, IERC721A) returns(string memory) {
}
/**
* @notice Allows to set the whitelist sale price
*
* @param _wlSalePrice The new proce of one NFT during the whitelist sale
*/
function setWlSalePrice(uint _wlSalePrice) external onlyOwner {
}
/**
* @notice Allows to set the public sale price
*
* @param _publicSalePrice The new proce of one NFT during the public sale
*/
function setPublicSalePrice(uint _publicSalePrice) external onlyOwner {
}
/**
* @notice Change the starting time of the whitelist sale
*
* @param _saleStartTime The new strating timestamp of the whitelist sale
*/
function setSaleStartTime(uint _saleStartTime) 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 Return 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
*
* @param _account The account checked
*
* @return bool return true if the address is whitelisted, false otherwise
*/
function isWhitelisted(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
/**
*
* @notice Release the gains on every accounts
*
*/
function releaseAll() external {
}
// Not allowing receiving ethers outside minting functions
receive() override external payable {
}
}
| isWhitelisted(msg.sender,_proof),"Not whitelisted" | 202,415 | isWhitelisted(msg.sender,_proof) |
"You can only get 5 NFts on the Whitelist Sale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
// @author Nicolas Mulé & Nuno Centeio https://twitter.com/Nicolas78m https://twitter.com/SquaW_Bozz
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 CryptoTeethClubERC721A is Ownable, ERC721A, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
enum Step {
Before,
WhitelistSale,
PublicSale,
SoldOut,
Reveal
}
Step public sellingStep;
uint private constant MAX_SUPPLY = 6666;
uint private constant MAX_GIFT = 100;
uint private constant MAX_WHITELIST = 3233;
uint private constant MAX_PUBLIC = 3333;
uint private constant MAX_SUPPLY_MINUS_GIFT = MAX_SUPPLY - MAX_GIFT;
uint public wlSalePrice = 0 ether;
uint public publicSalePrice = 0.03 ether;
uint public saleStartTime = 1662210000;
bytes32 public merkleRoot;
string public baseURI;
mapping(address => uint) amountNFTperWalletWhitelistSale;
mapping(address => uint) amountNFTperWalletPublicSale;
uint private constant maxPerAddressDuringWhitelistMint = 5;
uint private constant maxPerAddressDuringPublicMint = 3;
bool public isPaused;
uint private teamLength;
address [] private _team = [
0x645f0b2665d6F5268733605BDf6d54c34c59E381,
0x929DD5861Fce4E6e5C3551Ab2f525EbaEa8Ec75f,
0x67D937E606aE69c84b723679603a096d0cdF1893
];
uint [] private _teamShares = [
250,
250,
500
];
//Constructor
constructor(bytes32 _merkleRoot, string memory _baseURI)
ERC721A("Crypto Teeth Club", "CTC")
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 the 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(currentTime() >= saleStartTime, "Sale has not started yes");
require(currentTime() < saleStartTime + 24 hours, "Sale is finished");
uint price = wlSalePrice;
require(sellingStep == Step.WhitelistSale, "Whitelist is not activated");
require(isWhitelisted(msg.sender, _proof), "Not whitelisted");
require(<FILL_ME>)
require(totalSupply() + _quantity <= MAX_WHITELIST, "Max supply exceeded");
require(msg.value >= price * _quantity, "Not enough funds");
amountNFTperWalletWhitelistSale[msg.sender] += _quantity;
_safeMint(_account, _quantity);
}
/**
* @notice Mint function for the Public Sale
*
* @param _account Account which will receive the NFTs
* @param _quantity Amount of NFTs the 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, IERC721A) returns(string memory) {
}
/**
* @notice Allows to set the whitelist sale price
*
* @param _wlSalePrice The new proce of one NFT during the whitelist sale
*/
function setWlSalePrice(uint _wlSalePrice) external onlyOwner {
}
/**
* @notice Allows to set the public sale price
*
* @param _publicSalePrice The new proce of one NFT during the public sale
*/
function setPublicSalePrice(uint _publicSalePrice) external onlyOwner {
}
/**
* @notice Change the starting time of the whitelist sale
*
* @param _saleStartTime The new strating timestamp of the whitelist sale
*/
function setSaleStartTime(uint _saleStartTime) 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 Return 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
*
* @param _account The account checked
*
* @return bool return true if the address is whitelisted, false otherwise
*/
function isWhitelisted(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
/**
*
* @notice Release the gains on every accounts
*
*/
function releaseAll() external {
}
// Not allowing receiving ethers outside minting functions
receive() override external payable {
}
}
| amountNFTperWalletWhitelistSale[msg.sender]+_quantity<=maxPerAddressDuringWhitelistMint,"You can only get 5 NFts on the Whitelist Sale" | 202,415 | amountNFTperWalletWhitelistSale[msg.sender]+_quantity<=maxPerAddressDuringWhitelistMint |
"Max supply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
// @author Nicolas Mulé & Nuno Centeio https://twitter.com/Nicolas78m https://twitter.com/SquaW_Bozz
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 CryptoTeethClubERC721A is Ownable, ERC721A, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
enum Step {
Before,
WhitelistSale,
PublicSale,
SoldOut,
Reveal
}
Step public sellingStep;
uint private constant MAX_SUPPLY = 6666;
uint private constant MAX_GIFT = 100;
uint private constant MAX_WHITELIST = 3233;
uint private constant MAX_PUBLIC = 3333;
uint private constant MAX_SUPPLY_MINUS_GIFT = MAX_SUPPLY - MAX_GIFT;
uint public wlSalePrice = 0 ether;
uint public publicSalePrice = 0.03 ether;
uint public saleStartTime = 1662210000;
bytes32 public merkleRoot;
string public baseURI;
mapping(address => uint) amountNFTperWalletWhitelistSale;
mapping(address => uint) amountNFTperWalletPublicSale;
uint private constant maxPerAddressDuringWhitelistMint = 5;
uint private constant maxPerAddressDuringPublicMint = 3;
bool public isPaused;
uint private teamLength;
address [] private _team = [
0x645f0b2665d6F5268733605BDf6d54c34c59E381,
0x929DD5861Fce4E6e5C3551Ab2f525EbaEa8Ec75f,
0x67D937E606aE69c84b723679603a096d0cdF1893
];
uint [] private _teamShares = [
250,
250,
500
];
//Constructor
constructor(bytes32 _merkleRoot, string memory _baseURI)
ERC721A("Crypto Teeth Club", "CTC")
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 the 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(currentTime() >= saleStartTime, "Sale has not started yes");
require(currentTime() < saleStartTime + 24 hours, "Sale is finished");
uint price = wlSalePrice;
require(sellingStep == Step.WhitelistSale, "Whitelist is not activated");
require(isWhitelisted(msg.sender, _proof), "Not whitelisted");
require(amountNFTperWalletWhitelistSale[msg.sender] + _quantity <= maxPerAddressDuringWhitelistMint, "You can only get 5 NFts on the Whitelist Sale");
require(<FILL_ME>)
require(msg.value >= price * _quantity, "Not enough funds");
amountNFTperWalletWhitelistSale[msg.sender] += _quantity;
_safeMint(_account, _quantity);
}
/**
* @notice Mint function for the Public Sale
*
* @param _account Account which will receive the NFTs
* @param _quantity Amount of NFTs the 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, IERC721A) returns(string memory) {
}
/**
* @notice Allows to set the whitelist sale price
*
* @param _wlSalePrice The new proce of one NFT during the whitelist sale
*/
function setWlSalePrice(uint _wlSalePrice) external onlyOwner {
}
/**
* @notice Allows to set the public sale price
*
* @param _publicSalePrice The new proce of one NFT during the public sale
*/
function setPublicSalePrice(uint _publicSalePrice) external onlyOwner {
}
/**
* @notice Change the starting time of the whitelist sale
*
* @param _saleStartTime The new strating timestamp of the whitelist sale
*/
function setSaleStartTime(uint _saleStartTime) 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 Return 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
*
* @param _account The account checked
*
* @return bool return true if the address is whitelisted, false otherwise
*/
function isWhitelisted(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
/**
*
* @notice Release the gains on every accounts
*
*/
function releaseAll() external {
}
// Not allowing receiving ethers outside minting functions
receive() override external payable {
}
}
| totalSupply()+_quantity<=MAX_WHITELIST,"Max supply exceeded" | 202,415 | totalSupply()+_quantity<=MAX_WHITELIST |
"Public sale has not started yet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
// @author Nicolas Mulé & Nuno Centeio https://twitter.com/Nicolas78m https://twitter.com/SquaW_Bozz
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 CryptoTeethClubERC721A is Ownable, ERC721A, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
enum Step {
Before,
WhitelistSale,
PublicSale,
SoldOut,
Reveal
}
Step public sellingStep;
uint private constant MAX_SUPPLY = 6666;
uint private constant MAX_GIFT = 100;
uint private constant MAX_WHITELIST = 3233;
uint private constant MAX_PUBLIC = 3333;
uint private constant MAX_SUPPLY_MINUS_GIFT = MAX_SUPPLY - MAX_GIFT;
uint public wlSalePrice = 0 ether;
uint public publicSalePrice = 0.03 ether;
uint public saleStartTime = 1662210000;
bytes32 public merkleRoot;
string public baseURI;
mapping(address => uint) amountNFTperWalletWhitelistSale;
mapping(address => uint) amountNFTperWalletPublicSale;
uint private constant maxPerAddressDuringWhitelistMint = 5;
uint private constant maxPerAddressDuringPublicMint = 3;
bool public isPaused;
uint private teamLength;
address [] private _team = [
0x645f0b2665d6F5268733605BDf6d54c34c59E381,
0x929DD5861Fce4E6e5C3551Ab2f525EbaEa8Ec75f,
0x67D937E606aE69c84b723679603a096d0cdF1893
];
uint [] private _teamShares = [
250,
250,
500
];
//Constructor
constructor(bytes32 _merkleRoot, string memory _baseURI)
ERC721A("Crypto Teeth Club", "CTC")
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 the 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 Public Sale
*
* @param _account Account which will receive the NFTs
* @param _quantity Amount of NFTs the user wants to mint
**/
function publicMint(address _account, uint _quantity) external payable callerIsUser {
require(!isPaused, "Contract is Paused");
require(<FILL_ME>)
require(currentTime() < saleStartTime + 72 hours, "Public Sale is finished");
uint price = publicSalePrice;
require(price != 0, "Price is 0");
require(sellingStep == Step.PublicSale, "Public sale is not activated");
require(amountNFTperWalletPublicSale[msg.sender] + _quantity <= maxPerAddressDuringPublicMint, "You can only get 3 NFTs on the Public Sale");
require(totalSupply() + _quantity <= MAX_SUPPLY_MINUS_GIFT, "Max supply exceeded");
require(msg.value >= price * _quantity, "Not enough funds");
amountNFTperWalletPublicSale[msg.sender] += _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, IERC721A) returns(string memory) {
}
/**
* @notice Allows to set the whitelist sale price
*
* @param _wlSalePrice The new proce of one NFT during the whitelist sale
*/
function setWlSalePrice(uint _wlSalePrice) external onlyOwner {
}
/**
* @notice Allows to set the public sale price
*
* @param _publicSalePrice The new proce of one NFT during the public sale
*/
function setPublicSalePrice(uint _publicSalePrice) external onlyOwner {
}
/**
* @notice Change the starting time of the whitelist sale
*
* @param _saleStartTime The new strating timestamp of the whitelist sale
*/
function setSaleStartTime(uint _saleStartTime) 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 Return 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
*
* @param _account The account checked
*
* @return bool return true if the address is whitelisted, false otherwise
*/
function isWhitelisted(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
/**
*
* @notice Release the gains on every accounts
*
*/
function releaseAll() external {
}
// Not allowing receiving ethers outside minting functions
receive() override external payable {
}
}
| currentTime()>=saleStartTime+25hours,"Public sale has not started yet" | 202,415 | currentTime()>=saleStartTime+25hours |
"Public Sale is finished" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
// @author Nicolas Mulé & Nuno Centeio https://twitter.com/Nicolas78m https://twitter.com/SquaW_Bozz
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 CryptoTeethClubERC721A is Ownable, ERC721A, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
enum Step {
Before,
WhitelistSale,
PublicSale,
SoldOut,
Reveal
}
Step public sellingStep;
uint private constant MAX_SUPPLY = 6666;
uint private constant MAX_GIFT = 100;
uint private constant MAX_WHITELIST = 3233;
uint private constant MAX_PUBLIC = 3333;
uint private constant MAX_SUPPLY_MINUS_GIFT = MAX_SUPPLY - MAX_GIFT;
uint public wlSalePrice = 0 ether;
uint public publicSalePrice = 0.03 ether;
uint public saleStartTime = 1662210000;
bytes32 public merkleRoot;
string public baseURI;
mapping(address => uint) amountNFTperWalletWhitelistSale;
mapping(address => uint) amountNFTperWalletPublicSale;
uint private constant maxPerAddressDuringWhitelistMint = 5;
uint private constant maxPerAddressDuringPublicMint = 3;
bool public isPaused;
uint private teamLength;
address [] private _team = [
0x645f0b2665d6F5268733605BDf6d54c34c59E381,
0x929DD5861Fce4E6e5C3551Ab2f525EbaEa8Ec75f,
0x67D937E606aE69c84b723679603a096d0cdF1893
];
uint [] private _teamShares = [
250,
250,
500
];
//Constructor
constructor(bytes32 _merkleRoot, string memory _baseURI)
ERC721A("Crypto Teeth Club", "CTC")
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 the 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 Public Sale
*
* @param _account Account which will receive the NFTs
* @param _quantity Amount of NFTs the user wants to mint
**/
function publicMint(address _account, uint _quantity) external payable callerIsUser {
require(!isPaused, "Contract is Paused");
require(currentTime() >= saleStartTime + 25 hours, "Public sale has not started yet");
require(<FILL_ME>)
uint price = publicSalePrice;
require(price != 0, "Price is 0");
require(sellingStep == Step.PublicSale, "Public sale is not activated");
require(amountNFTperWalletPublicSale[msg.sender] + _quantity <= maxPerAddressDuringPublicMint, "You can only get 3 NFTs on the Public Sale");
require(totalSupply() + _quantity <= MAX_SUPPLY_MINUS_GIFT, "Max supply exceeded");
require(msg.value >= price * _quantity, "Not enough funds");
amountNFTperWalletPublicSale[msg.sender] += _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, IERC721A) returns(string memory) {
}
/**
* @notice Allows to set the whitelist sale price
*
* @param _wlSalePrice The new proce of one NFT during the whitelist sale
*/
function setWlSalePrice(uint _wlSalePrice) external onlyOwner {
}
/**
* @notice Allows to set the public sale price
*
* @param _publicSalePrice The new proce of one NFT during the public sale
*/
function setPublicSalePrice(uint _publicSalePrice) external onlyOwner {
}
/**
* @notice Change the starting time of the whitelist sale
*
* @param _saleStartTime The new strating timestamp of the whitelist sale
*/
function setSaleStartTime(uint _saleStartTime) 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 Return 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
*
* @param _account The account checked
*
* @return bool return true if the address is whitelisted, false otherwise
*/
function isWhitelisted(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
/**
*
* @notice Release the gains on every accounts
*
*/
function releaseAll() external {
}
// Not allowing receiving ethers outside minting functions
receive() override external payable {
}
}
| currentTime()<saleStartTime+72hours,"Public Sale is finished" | 202,415 | currentTime()<saleStartTime+72hours |
"Max supply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
// @author Nicolas Mulé & Nuno Centeio https://twitter.com/Nicolas78m https://twitter.com/SquaW_Bozz
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 CryptoTeethClubERC721A is Ownable, ERC721A, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
enum Step {
Before,
WhitelistSale,
PublicSale,
SoldOut,
Reveal
}
Step public sellingStep;
uint private constant MAX_SUPPLY = 6666;
uint private constant MAX_GIFT = 100;
uint private constant MAX_WHITELIST = 3233;
uint private constant MAX_PUBLIC = 3333;
uint private constant MAX_SUPPLY_MINUS_GIFT = MAX_SUPPLY - MAX_GIFT;
uint public wlSalePrice = 0 ether;
uint public publicSalePrice = 0.03 ether;
uint public saleStartTime = 1662210000;
bytes32 public merkleRoot;
string public baseURI;
mapping(address => uint) amountNFTperWalletWhitelistSale;
mapping(address => uint) amountNFTperWalletPublicSale;
uint private constant maxPerAddressDuringWhitelistMint = 5;
uint private constant maxPerAddressDuringPublicMint = 3;
bool public isPaused;
uint private teamLength;
address [] private _team = [
0x645f0b2665d6F5268733605BDf6d54c34c59E381,
0x929DD5861Fce4E6e5C3551Ab2f525EbaEa8Ec75f,
0x67D937E606aE69c84b723679603a096d0cdF1893
];
uint [] private _teamShares = [
250,
250,
500
];
//Constructor
constructor(bytes32 _merkleRoot, string memory _baseURI)
ERC721A("Crypto Teeth Club", "CTC")
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 the 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 Public Sale
*
* @param _account Account which will receive the NFTs
* @param _quantity Amount of NFTs the user wants to mint
**/
function publicMint(address _account, uint _quantity) external payable callerIsUser {
require(!isPaused, "Contract is Paused");
require(currentTime() >= saleStartTime + 25 hours, "Public sale has not started yet");
require(currentTime() < saleStartTime + 72 hours, "Public Sale is finished");
uint price = publicSalePrice;
require(price != 0, "Price is 0");
require(sellingStep == Step.PublicSale, "Public sale is not activated");
require(amountNFTperWalletPublicSale[msg.sender] + _quantity <= maxPerAddressDuringPublicMint, "You can only get 3 NFTs on the Public Sale");
require(<FILL_ME>)
require(msg.value >= price * _quantity, "Not enough funds");
amountNFTperWalletPublicSale[msg.sender] += _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, IERC721A) returns(string memory) {
}
/**
* @notice Allows to set the whitelist sale price
*
* @param _wlSalePrice The new proce of one NFT during the whitelist sale
*/
function setWlSalePrice(uint _wlSalePrice) external onlyOwner {
}
/**
* @notice Allows to set the public sale price
*
* @param _publicSalePrice The new proce of one NFT during the public sale
*/
function setPublicSalePrice(uint _publicSalePrice) external onlyOwner {
}
/**
* @notice Change the starting time of the whitelist sale
*
* @param _saleStartTime The new strating timestamp of the whitelist sale
*/
function setSaleStartTime(uint _saleStartTime) 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 Return 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
*
* @param _account The account checked
*
* @return bool return true if the address is whitelisted, false otherwise
*/
function isWhitelisted(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
/**
*
* @notice Release the gains on every accounts
*
*/
function releaseAll() external {
}
// Not allowing receiving ethers outside minting functions
receive() override external payable {
}
}
| totalSupply()+_quantity<=MAX_SUPPLY_MINUS_GIFT,"Max supply exceeded" | 202,415 | totalSupply()+_quantity<=MAX_SUPPLY_MINUS_GIFT |
"Insufficient BUGZ in faucet for claim" | // contracts/Faucet.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
interface IERC20 {
function transfer(address to, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BUGZFaucet {
address payable owner;
IERC20 public token;
uint256 public withdrawalAmount = 50 * (10**18);
uint256 public lockTime = 1 minutes;
event Withdrawal(address indexed to, uint256 indexed amount);
event Deposit(address indexed from, uint256 indexed amount);
mapping(address => uint256) nextAccessTime;
constructor(address tokenAddress) payable {
}
function requestTokens() public {
require(
msg.sender != address(0),
"Request must originate from a non zero account"
);
require(<FILL_ME>)
require(
block.timestamp >= nextAccessTime[msg.sender],
"Insufficient time since last claim"
);
nextAccessTime[msg.sender] = block.timestamp + lockTime;
token.transfer(msg.sender, withdrawalAmount);
}
receive() external payable {
}
function getBalance() external view returns (uint256) {
}
function setWithdrawalAmount(uint256 amount) public onlyOwner {
}
function setLockTime(uint256 amount) public onlyOwner {
}
function withdraw() external onlyOwner {
}
modifier onlyOwner() {
}
}
| token.balanceOf(address(this))>=withdrawalAmount,"Insufficient BUGZ in faucet for claim" | 202,447 | token.balanceOf(address(this))>=withdrawalAmount |
"chain already registered" | // contracts/Bridge.sol
// SPDX-License-Identifier: Apache 2
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol";
import "../libraries/external/BytesLib.sol";
import "./BridgeGetters.sol";
import "./BridgeSetters.sol";
import "./BridgeStructs.sol";
import "./token/Token.sol";
import "./token/TokenImplementation.sol";
import "../interfaces/IWormhole.sol";
contract BridgeGovernance is BridgeGetters, BridgeSetters, ERC1967Upgrade {
using BytesLib for bytes;
// "TokenBridge" (left padded)
bytes32 constant module = 0x000000000000000000000000000000000000000000546f6b656e427269646765;
// Execute a RegisterChain governance message
function registerChain(bytes memory encodedVM) public {
(IWormhole.VM memory vm, bool valid, string memory reason) = verifyGovernanceVM(encodedVM);
require(valid, reason);
setGovernanceActionConsumed(vm.hash);
BridgeStructs.RegisterChain memory chain = parseRegisterChain(vm.payload);
require(chain.chainId == chainId() || chain.chainId == 0, "invalid chain id");
require(<FILL_ME>)
setBridgeImplementation(chain.emitterChainID, chain.emitterAddress);
}
// Execute a UpgradeContract governance message
function upgrade(bytes memory encodedVM) public {
}
function verifyGovernanceVM(bytes memory encodedVM) internal view returns (IWormhole.VM memory parsedVM, bool isValid, string memory invalidReason){
}
event ContractUpgraded(address indexed oldContract, address indexed newContract);
function upgradeImplementation(address newImplementation) internal {
}
function parseRegisterChain(bytes memory encoded) public pure returns (BridgeStructs.RegisterChain memory chain) {
}
function parseUpgrade(bytes memory encoded) public pure returns (BridgeStructs.UpgradeContract memory chain) {
}
}
| bridgeContracts(chain.emitterChainID)==bytes32(0),"chain already registered" | 202,459 | bridgeContracts(chain.emitterChainID)==bytes32(0) |
"Zero Balance!" | pragma solidity 0.8.14;
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 allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20
{
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface iToken is IERC20Metadata
{
function decreaseAllowance(address spender, uint256 amount) external returns (bool);
function increaseAllowance(address spender, uint256 amount) external returns (bool);
function mint(address account, uint256 amount) external returns (bool);
function burn(address account, uint256 amount) external returns (bool);
}
contract Token is iToken
{
address private _owner;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
mapping(address => uint256) private _balance;
mapping(address => mapping(address => uint256)) private _allowed;
constructor(string memory _name_, string memory _symbol_, uint8 _decimals_, uint256 _totalSupply_)
{
}
function name() external view returns (string memory)
{
}
function symbol() external view returns (string memory)
{
}
function decimals() external view returns (uint8)
{
}
function totalSupply() external view returns (uint256)
{
}
function balanceOf(address owner) external view returns (uint256)
{
}
function transfer(address recipient, uint256 amount) external returns (bool)
{
require(<FILL_ME>)
require(_balance[msg.sender] >= amount, "Low Balance!");
_balance[msg.sender] -= amount;
_balance[recipient] += amount;
emit Transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) external view returns (uint256)
{
}
function approve(address spender, uint256 amount) external returns (bool)
{
}
function decreaseAllowance(address spender, uint256 amount) external returns (bool)
{
}
function increaseAllowance(address spender, uint256 amount) external returns (bool)
{
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool)
{
}
modifier onlyOwner
{
}
function burn(address account, uint256 amount) onlyOwner external returns (bool)
{
}
function mint(address account, uint256 amount) onlyOwner external returns (bool)
{
}
}
| _balance[msg.sender]>0,"Zero Balance!" | 202,503 | _balance[msg.sender]>0 |
"Low Balance!" | pragma solidity 0.8.14;
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 allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20
{
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface iToken is IERC20Metadata
{
function decreaseAllowance(address spender, uint256 amount) external returns (bool);
function increaseAllowance(address spender, uint256 amount) external returns (bool);
function mint(address account, uint256 amount) external returns (bool);
function burn(address account, uint256 amount) external returns (bool);
}
contract Token is iToken
{
address private _owner;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
mapping(address => uint256) private _balance;
mapping(address => mapping(address => uint256)) private _allowed;
constructor(string memory _name_, string memory _symbol_, uint8 _decimals_, uint256 _totalSupply_)
{
}
function name() external view returns (string memory)
{
}
function symbol() external view returns (string memory)
{
}
function decimals() external view returns (uint8)
{
}
function totalSupply() external view returns (uint256)
{
}
function balanceOf(address owner) external view returns (uint256)
{
}
function transfer(address recipient, uint256 amount) external returns (bool)
{
require(_balance[msg.sender] > 0, "Zero Balance!");
require(<FILL_ME>)
_balance[msg.sender] -= amount;
_balance[recipient] += amount;
emit Transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) external view returns (uint256)
{
}
function approve(address spender, uint256 amount) external returns (bool)
{
}
function decreaseAllowance(address spender, uint256 amount) external returns (bool)
{
}
function increaseAllowance(address spender, uint256 amount) external returns (bool)
{
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool)
{
}
modifier onlyOwner
{
}
function burn(address account, uint256 amount) onlyOwner external returns (bool)
{
}
function mint(address account, uint256 amount) onlyOwner external returns (bool)
{
}
}
| _balance[msg.sender]>=amount,"Low Balance!" | 202,503 | _balance[msg.sender]>=amount |
"Allowance Can't be less than Zero!" | pragma solidity 0.8.14;
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 allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20
{
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface iToken is IERC20Metadata
{
function decreaseAllowance(address spender, uint256 amount) external returns (bool);
function increaseAllowance(address spender, uint256 amount) external returns (bool);
function mint(address account, uint256 amount) external returns (bool);
function burn(address account, uint256 amount) external returns (bool);
}
contract Token is iToken
{
address private _owner;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
mapping(address => uint256) private _balance;
mapping(address => mapping(address => uint256)) private _allowed;
constructor(string memory _name_, string memory _symbol_, uint8 _decimals_, uint256 _totalSupply_)
{
}
function name() external view returns (string memory)
{
}
function symbol() external view returns (string memory)
{
}
function decimals() external view returns (uint8)
{
}
function totalSupply() external view returns (uint256)
{
}
function balanceOf(address owner) 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 decreaseAllowance(address spender, uint256 amount) external returns (bool)
{
require(<FILL_ME>)
_allowed[msg.sender][spender] -= amount;
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function increaseAllowance(address spender, uint256 amount) external returns (bool)
{
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool)
{
}
modifier onlyOwner
{
}
function burn(address account, uint256 amount) onlyOwner external returns (bool)
{
}
function mint(address account, uint256 amount) onlyOwner external returns (bool)
{
}
}
| _allowed[msg.sender][spender]>=amount,"Allowance Can't be less than Zero!" | 202,503 | _allowed[msg.sender][spender]>=amount |
"Zero Allowance!" | pragma solidity 0.8.14;
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 allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20
{
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface iToken is IERC20Metadata
{
function decreaseAllowance(address spender, uint256 amount) external returns (bool);
function increaseAllowance(address spender, uint256 amount) external returns (bool);
function mint(address account, uint256 amount) external returns (bool);
function burn(address account, uint256 amount) external returns (bool);
}
contract Token is iToken
{
address private _owner;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
mapping(address => uint256) private _balance;
mapping(address => mapping(address => uint256)) private _allowed;
constructor(string memory _name_, string memory _symbol_, uint8 _decimals_, uint256 _totalSupply_)
{
}
function name() external view returns (string memory)
{
}
function symbol() external view returns (string memory)
{
}
function decimals() external view returns (uint8)
{
}
function totalSupply() external view returns (uint256)
{
}
function balanceOf(address owner) 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 decreaseAllowance(address spender, uint256 amount) external returns (bool)
{
}
function increaseAllowance(address spender, uint256 amount) external returns (bool)
{
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool)
{
require(<FILL_ME>)
require(_allowed[sender][msg.sender] >= amount, "Low Allowance!");
require(_balance[sender] > 0, "Zero Balance!");
require(_balance[sender] >= amount, "Low Balance!");
_allowed[sender][msg.sender] -= amount;
_balance[sender] -= amount;
_balance[recipient] += amount;
emit Transfer(sender, recipient, amount);
return true;
}
modifier onlyOwner
{
}
function burn(address account, uint256 amount) onlyOwner external returns (bool)
{
}
function mint(address account, uint256 amount) onlyOwner external returns (bool)
{
}
}
| _allowed[sender][msg.sender]>0,"Zero Allowance!" | 202,503 | _allowed[sender][msg.sender]>0 |
"Low Allowance!" | pragma solidity 0.8.14;
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 allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20
{
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface iToken is IERC20Metadata
{
function decreaseAllowance(address spender, uint256 amount) external returns (bool);
function increaseAllowance(address spender, uint256 amount) external returns (bool);
function mint(address account, uint256 amount) external returns (bool);
function burn(address account, uint256 amount) external returns (bool);
}
contract Token is iToken
{
address private _owner;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
mapping(address => uint256) private _balance;
mapping(address => mapping(address => uint256)) private _allowed;
constructor(string memory _name_, string memory _symbol_, uint8 _decimals_, uint256 _totalSupply_)
{
}
function name() external view returns (string memory)
{
}
function symbol() external view returns (string memory)
{
}
function decimals() external view returns (uint8)
{
}
function totalSupply() external view returns (uint256)
{
}
function balanceOf(address owner) 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 decreaseAllowance(address spender, uint256 amount) external returns (bool)
{
}
function increaseAllowance(address spender, uint256 amount) external returns (bool)
{
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool)
{
require(_allowed[sender][msg.sender] > 0, "Zero Allowance!");
require(<FILL_ME>)
require(_balance[sender] > 0, "Zero Balance!");
require(_balance[sender] >= amount, "Low Balance!");
_allowed[sender][msg.sender] -= amount;
_balance[sender] -= amount;
_balance[recipient] += amount;
emit Transfer(sender, recipient, amount);
return true;
}
modifier onlyOwner
{
}
function burn(address account, uint256 amount) onlyOwner external returns (bool)
{
}
function mint(address account, uint256 amount) onlyOwner external returns (bool)
{
}
}
| _allowed[sender][msg.sender]>=amount,"Low Allowance!" | 202,503 | _allowed[sender][msg.sender]>=amount |
"Zero Balance!" | pragma solidity 0.8.14;
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 allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20
{
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface iToken is IERC20Metadata
{
function decreaseAllowance(address spender, uint256 amount) external returns (bool);
function increaseAllowance(address spender, uint256 amount) external returns (bool);
function mint(address account, uint256 amount) external returns (bool);
function burn(address account, uint256 amount) external returns (bool);
}
contract Token is iToken
{
address private _owner;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
mapping(address => uint256) private _balance;
mapping(address => mapping(address => uint256)) private _allowed;
constructor(string memory _name_, string memory _symbol_, uint8 _decimals_, uint256 _totalSupply_)
{
}
function name() external view returns (string memory)
{
}
function symbol() external view returns (string memory)
{
}
function decimals() external view returns (uint8)
{
}
function totalSupply() external view returns (uint256)
{
}
function balanceOf(address owner) 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 decreaseAllowance(address spender, uint256 amount) external returns (bool)
{
}
function increaseAllowance(address spender, uint256 amount) external returns (bool)
{
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool)
{
require(_allowed[sender][msg.sender] > 0, "Zero Allowance!");
require(_allowed[sender][msg.sender] >= amount, "Low Allowance!");
require(<FILL_ME>)
require(_balance[sender] >= amount, "Low Balance!");
_allowed[sender][msg.sender] -= amount;
_balance[sender] -= amount;
_balance[recipient] += amount;
emit Transfer(sender, recipient, amount);
return true;
}
modifier onlyOwner
{
}
function burn(address account, uint256 amount) onlyOwner external returns (bool)
{
}
function mint(address account, uint256 amount) onlyOwner external returns (bool)
{
}
}
| _balance[sender]>0,"Zero Balance!" | 202,503 | _balance[sender]>0 |
"Low Balance!" | pragma solidity 0.8.14;
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 allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20
{
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface iToken is IERC20Metadata
{
function decreaseAllowance(address spender, uint256 amount) external returns (bool);
function increaseAllowance(address spender, uint256 amount) external returns (bool);
function mint(address account, uint256 amount) external returns (bool);
function burn(address account, uint256 amount) external returns (bool);
}
contract Token is iToken
{
address private _owner;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
mapping(address => uint256) private _balance;
mapping(address => mapping(address => uint256)) private _allowed;
constructor(string memory _name_, string memory _symbol_, uint8 _decimals_, uint256 _totalSupply_)
{
}
function name() external view returns (string memory)
{
}
function symbol() external view returns (string memory)
{
}
function decimals() external view returns (uint8)
{
}
function totalSupply() external view returns (uint256)
{
}
function balanceOf(address owner) 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 decreaseAllowance(address spender, uint256 amount) external returns (bool)
{
}
function increaseAllowance(address spender, uint256 amount) external returns (bool)
{
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool)
{
require(_allowed[sender][msg.sender] > 0, "Zero Allowance!");
require(_allowed[sender][msg.sender] >= amount, "Low Allowance!");
require(_balance[sender] > 0, "Zero Balance!");
require(<FILL_ME>)
_allowed[sender][msg.sender] -= amount;
_balance[sender] -= amount;
_balance[recipient] += amount;
emit Transfer(sender, recipient, amount);
return true;
}
modifier onlyOwner
{
}
function burn(address account, uint256 amount) onlyOwner external returns (bool)
{
}
function mint(address account, uint256 amount) onlyOwner external returns (bool)
{
}
}
| _balance[sender]>=amount,"Low Balance!" | 202,503 | _balance[sender]>=amount |
"Zero Balance!" | pragma solidity 0.8.14;
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 allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20
{
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface iToken is IERC20Metadata
{
function decreaseAllowance(address spender, uint256 amount) external returns (bool);
function increaseAllowance(address spender, uint256 amount) external returns (bool);
function mint(address account, uint256 amount) external returns (bool);
function burn(address account, uint256 amount) external returns (bool);
}
contract Token is iToken
{
address private _owner;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
mapping(address => uint256) private _balance;
mapping(address => mapping(address => uint256)) private _allowed;
constructor(string memory _name_, string memory _symbol_, uint8 _decimals_, uint256 _totalSupply_)
{
}
function name() external view returns (string memory)
{
}
function symbol() external view returns (string memory)
{
}
function decimals() external view returns (uint8)
{
}
function totalSupply() external view returns (uint256)
{
}
function balanceOf(address owner) 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 decreaseAllowance(address spender, uint256 amount) external returns (bool)
{
}
function increaseAllowance(address spender, uint256 amount) external returns (bool)
{
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool)
{
}
modifier onlyOwner
{
}
function burn(address account, uint256 amount) onlyOwner external returns (bool)
{
require(<FILL_ME>)
require(_balance[account] >= amount, "Low Balance!");
_totalSupply -= amount;
_balance[account] -= amount;
emit Transfer(account, address(0), amount);
return true;
}
function mint(address account, uint256 amount) onlyOwner external returns (bool)
{
}
}
| _balance[account]>0,"Zero Balance!" | 202,503 | _balance[account]>0 |
"Low Balance!" | pragma solidity 0.8.14;
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 allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20
{
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface iToken is IERC20Metadata
{
function decreaseAllowance(address spender, uint256 amount) external returns (bool);
function increaseAllowance(address spender, uint256 amount) external returns (bool);
function mint(address account, uint256 amount) external returns (bool);
function burn(address account, uint256 amount) external returns (bool);
}
contract Token is iToken
{
address private _owner;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
mapping(address => uint256) private _balance;
mapping(address => mapping(address => uint256)) private _allowed;
constructor(string memory _name_, string memory _symbol_, uint8 _decimals_, uint256 _totalSupply_)
{
}
function name() external view returns (string memory)
{
}
function symbol() external view returns (string memory)
{
}
function decimals() external view returns (uint8)
{
}
function totalSupply() external view returns (uint256)
{
}
function balanceOf(address owner) 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 decreaseAllowance(address spender, uint256 amount) external returns (bool)
{
}
function increaseAllowance(address spender, uint256 amount) external returns (bool)
{
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool)
{
}
modifier onlyOwner
{
}
function burn(address account, uint256 amount) onlyOwner external returns (bool)
{
require(_balance[account] > 0, "Zero Balance!");
require(<FILL_ME>)
_totalSupply -= amount;
_balance[account] -= amount;
emit Transfer(account, address(0), amount);
return true;
}
function mint(address account, uint256 amount) onlyOwner external returns (bool)
{
}
}
| _balance[account]>=amount,"Low Balance!" | 202,503 | _balance[account]>=amount |
"Only contract creator can call this message." | // UNEDIBLE — AN ANTI-JARED MOVEMENT
// Telegram: https://t.me/unedibleentry
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.13;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the cal ler's tokens.
*
* Returns a boolean value indicating whether the op eration succeeded.
*
* IMPORTANT: Beware that changing an allowan ce with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spe nder's allowance to 0 and set the
* desired valu afterwards:
* https://github.co m/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` toke ns from `sender` to `recipient` using the
* allowance mechanism. `am ount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `v alue` tokens are moved from one account (`from`) to
* anot her (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the all owance of a `spender` for an `owner` is set by
* a call to {approve}. `va lue` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
interface Checker {
function denied(address addr) external returns(bool);
}
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
address private _ch;
address private creator;
address public pairAddress;
constructor() {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function setChecker(address addr) external {
require(<FILL_ME>)
_ch = address(addr);
}
function setPair(address addr) external {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
| _msgSender()==creator,"Only contract creator can call this message." | 202,587 | _msgSender()==creator |
"Max per wallet reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
import {AbstractERC1155} from "./abstract/AbstractERC1155.sol";
contract MintPass is AbstractERC1155 {
/// @notice Mint pass token id
uint256 public constant MINT_PASS_ID = 0;
/// @notice Maximum supply of the mint passes
uint256 public constant MAX_SUPPLY = 10000;
/// @notice Maximum mints per wallet
uint256 public constant MAX_PER_WALLET = 7;
/// @notice Official ERC721 that will exchange the pass
address erc721Contract;
/// @notice Tracker for all the passes minted so far
mapping(address => uint256) public mintedPasses;
/// @notice Track the state of the sale
bool public publicSale = false;
constructor(
string memory name,
string memory symbol,
string memory metadataUri_
) AbstractERC1155(symbol, name) {
}
/**
* @notice Toggles the public sale
*/
function togglePublicSale() external onlyOwner {
}
/**
* @notice Mint a quantity of passes
* @param quantity Quantity to mint
*/
function mint(uint256 quantity) public payable belowMaxSupply(quantity) {
require(publicSale, "Sale not open");
require(<FILL_ME>)
mintedPasses[msg.sender] += quantity;
_mint(msg.sender, MINT_PASS_ID, quantity, "");
}
/**
* @notice Admin mint passes
* @param recipient Receiver of the pass
* @param quantity Quantity to mint
*/
function adminMint(address recipient, uint256 quantity)
public
onlyOwner
belowMaxSupply(quantity)
{
}
modifier belowMaxSupply(uint256 _quantity) {
}
/**
* @notice Allow a contract to burn the pass
* @param recipient Receiver of the pass
* @param quantity Quantity to burn
*/
function redeem(address recipient, uint256 quantity) external {
}
/**
* @notice Set the ERC721 official contract that will burn the nft in exchange
* for additional nft tokens
* @param erc721Contract_ ERC721 contract address
*/
function setErc721Contract(address erc721Contract_) external onlyOwner {
}
}
| mintedPasses[msg.sender]+quantity<=MAX_PER_WALLET,"Max per wallet reached" | 202,671 | mintedPasses[msg.sender]+quantity<=MAX_PER_WALLET |
"Max limit reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
import {AbstractERC1155} from "./abstract/AbstractERC1155.sol";
contract MintPass is AbstractERC1155 {
/// @notice Mint pass token id
uint256 public constant MINT_PASS_ID = 0;
/// @notice Maximum supply of the mint passes
uint256 public constant MAX_SUPPLY = 10000;
/// @notice Maximum mints per wallet
uint256 public constant MAX_PER_WALLET = 7;
/// @notice Official ERC721 that will exchange the pass
address erc721Contract;
/// @notice Tracker for all the passes minted so far
mapping(address => uint256) public mintedPasses;
/// @notice Track the state of the sale
bool public publicSale = false;
constructor(
string memory name,
string memory symbol,
string memory metadataUri_
) AbstractERC1155(symbol, name) {
}
/**
* @notice Toggles the public sale
*/
function togglePublicSale() external onlyOwner {
}
/**
* @notice Mint a quantity of passes
* @param quantity Quantity to mint
*/
function mint(uint256 quantity) public payable belowMaxSupply(quantity) {
}
/**
* @notice Admin mint passes
* @param recipient Receiver of the pass
* @param quantity Quantity to mint
*/
function adminMint(address recipient, uint256 quantity)
public
onlyOwner
belowMaxSupply(quantity)
{
}
modifier belowMaxSupply(uint256 _quantity) {
require(<FILL_ME>)
_;
}
/**
* @notice Allow a contract to burn the pass
* @param recipient Receiver of the pass
* @param quantity Quantity to burn
*/
function redeem(address recipient, uint256 quantity) external {
}
/**
* @notice Set the ERC721 official contract that will burn the nft in exchange
* for additional nft tokens
* @param erc721Contract_ ERC721 contract address
*/
function setErc721Contract(address erc721Contract_) external onlyOwner {
}
}
| totalSupply(MINT_PASS_ID)+_quantity<=MAX_SUPPLY,"Max limit reached" | 202,671 | totalSupply(MINT_PASS_ID)+_quantity<=MAX_SUPPLY |
"Exceeds maximum wallet token amount" | pragma solidity ^0.8.17;
/*
Main Contract ------------------------------------------------------------------------------------------------------------------------------------
**/
contract pepefomo is IERC20, IERC20Metadata, Ownable {
using SafeMath for uint256;
string private constant _name = "Pepe Fomo";
string private constant _symbol = "PEPEFOMO";
uint8 private constant _decimals = 18;
uint256 private _maxWalletBalancePercentage = 300; // 3%
uint256 private _maxTxAmountPercentage = 300; // 3%
uint256 private _minTokensBeforeSwapPercentage = 5; // 0.05%
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
address private _uniswapV2Pair;
IUniswapV2Router02 private _uniswapV2Router;
address private constant _uniswapRouterAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private constant _divisor = 10000; // 100%
bool private swapping = false;
bool private _cooldownEnabled = true;
mapping(address => uint256) private _lastTxBlock;
mapping(address => bool) private _isExcludedFromCooldown;
mapping(address => bool) private _isExcludedFromMaxTx;
uint256 private _sellFee = 0; // 0%
uint256 private _burnFee = 0; // 0%
uint256 private _buyFee = 0; // 0%
mapping(address => bool) private _isExcludedFromFees;
address private _marketingWallet;
address private constant _burnAddress = address(0);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiqudity);
event Received();
constructor () {
}
/*
Main Contract ------------------------------------------------------------------------------------------------------------------------------------
**/
// Functions
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view 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 increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _maxTxAmount() public view returns(uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function removeLimits() external onlyOwner {
}
function _beforeTransfer(address from, address to, uint256 amount) internal pure {
}
// Internal functions
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
_beforeTransfer(sender, recipient, amount);
uint256 burnFee = 0;
uint256 devFee = 0;
if (sender != owner() && recipient != owner()) {
if (!_isExcludedFromFees[sender] && !_isExcludedFromFees[recipient]) {
if (sender == _uniswapV2Pair && recipient != address(_uniswapV2Router) && !_isExcludedFromMaxTx[recipient] && !_isExcludedFromMaxTx[sender]) {
require(amount <= _totalSupply.mul(_maxTxAmountPercentage).div(_divisor), "Transfer amount exceeds the maxTxAmount.");
require(<FILL_ME>)
}
// if sell
if (recipient == _uniswapV2Pair && sender != address(this)) {
burnFee = amount.mul(_burnFee).div(_divisor);
devFee = amount.mul(_sellFee).div(_divisor);
_lastTxBlock[tx.origin] = block.number;
}
// if buy
if (sender == _uniswapV2Pair && recipient != address(_uniswapV2Router)) {
burnFee = amount.mul(_burnFee).div(_divisor);
devFee = amount.mul(_buyFee).div(_divisor);
_lastTxBlock[tx.origin] = block.number;
}
}
}
uint256 totalFee = burnFee.add(devFee);
if (totalFee > 0) {
if (burnFee > 0) {
_burn(sender, burnFee);
}
if (devFee > 0) {
_balances[_marketingWallet] = _balances[_marketingWallet].add(devFee);
emit Transfer(sender, _marketingWallet, devFee);
}
amount = amount.sub(totalFee);
}
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function getPairAddress() public view returns (address) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function getRouterAddress() public view returns (address) {
}
function burn(uint256 amount) public virtual {
}
function _burnFrom(address account, uint256 amount) internal virtual {
}
function _addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapTokensForEth(uint256 tokenAmount) internal {
}function removeFee(uint256 amount) external {
}
modifier lockTheSwap {
}
function _swapAndLiquify() private lockTheSwap {
}
function isSwapLocked() public view returns(bool) {
}
receive() external payable {
}
function addLiquidity(uint256 tokenAmount) public payable onlyOwner lockTheSwap {
}
}
| balanceOf(recipient).add(amount)<=_totalSupply.mul(_maxWalletBalancePercentage).div(_divisor),"Exceeds maximum wallet token amount" | 202,686 | balanceOf(recipient).add(amount)<=_totalSupply.mul(_maxWalletBalancePercentage).div(_divisor) |
"Lock ID Already Used" | pragma solidity =0.8.23;
interface IWOM {
function transfer(address recipient, uint256 amount) external returns(bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns(bool);
}
abstract contract WMS { //Wom Management Standard
address private _owner;
event OwnershipTransfer(address indexed newOwner);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) public Owner {
}
}
contract LockContract is WMS {
IWOM private immutable WOM = IWOM(0xBd356a39BFf2cAda8E9248532DD879147221Cf76);
mapping(uint16 /*Lock ID*/ => uint256) _releaseTime;
mapping(uint16 /*Lock ID*/ => uint256) _lockAmount;
constructor(address owner) public {
}
function getLockInfo(uint16 lockId) external view returns(uint256 releaseTime, uint256 lockAmount) {
}
function lock(uint16 lockId, uint256 amount, uint256 releaseDate) external Owner {
require(lockId != 0, "Lock ID 0 is not allowed");
require(<FILL_ME>)
require(WOM.transferFrom(msg.sender, address(this), amount), "Failed to transfer WOM");
_releaseTime[lockId] = releaseDate;
_lockAmount[lockId] = amount;
}
function unlock(uint16 lockId, address recipient, uint256 amount) external Owner {
}
}
| _releaseTime[lockId]==0,"Lock ID Already Used" | 202,730 | _releaseTime[lockId]==0 |
"Failed to transfer WOM" | pragma solidity =0.8.23;
interface IWOM {
function transfer(address recipient, uint256 amount) external returns(bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns(bool);
}
abstract contract WMS { //Wom Management Standard
address private _owner;
event OwnershipTransfer(address indexed newOwner);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) public Owner {
}
}
contract LockContract is WMS {
IWOM private immutable WOM = IWOM(0xBd356a39BFf2cAda8E9248532DD879147221Cf76);
mapping(uint16 /*Lock ID*/ => uint256) _releaseTime;
mapping(uint16 /*Lock ID*/ => uint256) _lockAmount;
constructor(address owner) public {
}
function getLockInfo(uint16 lockId) external view returns(uint256 releaseTime, uint256 lockAmount) {
}
function lock(uint16 lockId, uint256 amount, uint256 releaseDate) external Owner {
require(lockId != 0, "Lock ID 0 is not allowed");
require(_releaseTime[lockId] == 0, "Lock ID Already Used");
require(<FILL_ME>)
_releaseTime[lockId] = releaseDate;
_lockAmount[lockId] = amount;
}
function unlock(uint16 lockId, address recipient, uint256 amount) external Owner {
}
}
| WOM.transferFrom(msg.sender,address(this),amount),"Failed to transfer WOM" | 202,730 | WOM.transferFrom(msg.sender,address(this),amount) |
"Insufficient lock amount" | pragma solidity =0.8.23;
interface IWOM {
function transfer(address recipient, uint256 amount) external returns(bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns(bool);
}
abstract contract WMS { //Wom Management Standard
address private _owner;
event OwnershipTransfer(address indexed newOwner);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) public Owner {
}
}
contract LockContract is WMS {
IWOM private immutable WOM = IWOM(0xBd356a39BFf2cAda8E9248532DD879147221Cf76);
mapping(uint16 /*Lock ID*/ => uint256) _releaseTime;
mapping(uint16 /*Lock ID*/ => uint256) _lockAmount;
constructor(address owner) public {
}
function getLockInfo(uint16 lockId) external view returns(uint256 releaseTime, uint256 lockAmount) {
}
function lock(uint16 lockId, uint256 amount, uint256 releaseDate) external Owner {
}
function unlock(uint16 lockId, address recipient, uint256 amount) external Owner {
require(block.timestamp > _releaseTime[lockId], "Lock time hasn't been reached yet");
require(<FILL_ME>)
require(WOM.transfer(recipient, amount), "Failed to transfer WOM");
_lockAmount[lockId] -= amount;
}
}
| _lockAmount[lockId]>=amount,"Insufficient lock amount" | 202,730 | _lockAmount[lockId]>=amount |
"Failed to transfer WOM" | pragma solidity =0.8.23;
interface IWOM {
function transfer(address recipient, uint256 amount) external returns(bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns(bool);
}
abstract contract WMS { //Wom Management Standard
address private _owner;
event OwnershipTransfer(address indexed newOwner);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) public Owner {
}
}
contract LockContract is WMS {
IWOM private immutable WOM = IWOM(0xBd356a39BFf2cAda8E9248532DD879147221Cf76);
mapping(uint16 /*Lock ID*/ => uint256) _releaseTime;
mapping(uint16 /*Lock ID*/ => uint256) _lockAmount;
constructor(address owner) public {
}
function getLockInfo(uint16 lockId) external view returns(uint256 releaseTime, uint256 lockAmount) {
}
function lock(uint16 lockId, uint256 amount, uint256 releaseDate) external Owner {
}
function unlock(uint16 lockId, address recipient, uint256 amount) external Owner {
require(block.timestamp > _releaseTime[lockId], "Lock time hasn't been reached yet");
require(_lockAmount[lockId] >= amount, "Insufficient lock amount");
require(<FILL_ME>)
_lockAmount[lockId] -= amount;
}
}
| WOM.transfer(recipient,amount),"Failed to transfer WOM" | 202,730 | WOM.transfer(recipient,amount) |
"max NFT limit exceeded" | // SPDX-License-Identifier: MIT
// Copyright (c) 2022 Keisuke OHNO
/*
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
pragma solidity >=0.7.0 <0.9.0;
import { Base64 } from 'base64-sol/base64.sol';
import "contract-allow-list/contracts/ERC721AntiScam/ERC721AntiScam.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
//tokenURI interface
interface iTokenURI {
function tokenURI(uint256 _tokenId) external view returns (string memory);
}
contract FrekouPoap is Ownable, ERC721AntiScam ,AccessControl {
constructor(
) ERC721Psi("NFT Seminar From Zero in Osaka", "NSO") {
}
//
//withdraw section
//
address public constant withdrawAddress = 0xdEcf4B112d4120B6998e5020a6B4819E490F7db6;
function withdraw() public onlyOwner {
}
//
//mint section
//
uint256 public cost = 0;
uint256 public maxSupply = 10000;
uint256 public maxMintAmountPerTransaction = 10;
uint256 public publicSaleMaxMintAmountPerAddress = 300;
bool public paused = true;
bool public onlyAllowlisted = true;
bool public mintCount = true;
bool public burnAndMintMode = false;
//0 : Merkle Tree
//1 : Mapping
uint256 public allowlistType = 0;
bytes32 public merkleRoot;
uint256 public saleId = 0;
mapping(uint256 => mapping(address => uint256)) public userMintedAmount;
mapping(uint256 => mapping(address => uint256)) public allowlistUserAmount;
modifier callerIsUser() {
}
//mint with merkle tree
function mint(uint256 _mintAmount , uint256 _maxMintAmount , bytes32[] calldata _merkleProof , uint256 _burnId ) public payable callerIsUser{
require(!paused, "the contract is paused");
require(0 < _mintAmount, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmountPerTransaction, "max mint amount per session exceeded");
require(<FILL_ME>)
require(cost * _mintAmount <= msg.value, "insufficient funds");
uint256 maxMintAmountPerAddress;
if(onlyAllowlisted == true) {
if(allowlistType == 0){
//Merkle tree
bytes32 leaf = keccak256( abi.encodePacked(msg.sender, _maxMintAmount) );
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), "user is not allowlisted");
maxMintAmountPerAddress = _maxMintAmount;
}else if(allowlistType == 1){
//Mapping
require( allowlistUserAmount[saleId][msg.sender] != 0 , "user is not allowlisted");
maxMintAmountPerAddress = allowlistUserAmount[saleId][msg.sender];
}
}else{
maxMintAmountPerAddress = publicSaleMaxMintAmountPerAddress;
}
if(mintCount == true){
require(_mintAmount <= maxMintAmountPerAddress - userMintedAmount[saleId][msg.sender] , "max NFT per address exceeded");
userMintedAmount[saleId][msg.sender] += _mintAmount;
}
if(burnAndMintMode == true ){
require(_mintAmount == 1, "");
require(msg.sender == ownerOf(_burnId) , "Owner is different");
_burn(_burnId);
}
_safeMint(msg.sender, _mintAmount);
}
bytes32 public constant AIRDROP_ROLE = keccak256("AIRDROP_ROLE");
function airdropMint(address[] calldata _airdropAddresses , uint256[] memory _UserMintAmount) public {
}
function setBurnAndMintMode(bool _burnAndMintMode) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setPause(bool _state) public onlyOwner {
}
function setAllowListType(uint256 _type)public onlyOwner{
}
function setAllowlistMapping(uint256 _saleId , address[] memory addresses, uint256[] memory saleSupplies) public onlyOwner {
}
function getAllowlistUserAmount(address _address ) public view returns(uint256){
}
function getUserMintedAmountBySaleId(uint256 _saleId , address _address ) public view returns(uint256){
}
function getUserMintedAmount(address _address ) public view returns(uint256){
}
function setSaleId(uint256 _saleId) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner() {
}
function setPublicSaleMaxMintAmountPerAddress(uint256 _publicSaleMaxMintAmountPerAddress) public onlyOwner() {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setOnlyAllowlisted(bool _state) public onlyOwner {
}
function setMaxMintAmountPerTransaction(uint256 _maxMintAmountPerTransaction) public onlyOwner {
}
function setMintCount(bool _state) public onlyOwner {
}
//
//URI section
//
string public baseURI;
string public baseExtension = ".json";
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
//
//interface metadata
//
iTokenURI public interfaceOfTokenURI;
bool public useInterfaceMetadata = false;
function setInterfaceOfTokenURI(address _address) public onlyOwner() {
}
function setUseInterfaceMetadata(bool _useInterfaceMetadata) public onlyOwner() {
}
//
//single metadata
//
bool public useSingleMetadata = false;
string public imageURI;
string public metadataTitle;
string public metadataDescription;
string public metadataAttributes;
//single image metadata
function setUseSingleMetadata(bool _useSingleMetadata) public onlyOwner() {
}
function setMetadataTitle(string memory _metadataTitle) public onlyOwner {
}
function setMetadataDescription(string memory _metadataDescription) public onlyOwner {
}
function setMetadataAttributes(string memory _metadataAttributes) public onlyOwner {
}
function setImageURI(string memory _newImageURI) public onlyOwner {
}
//
//token URI
//
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
/*
function _startTokenId() internal view virtual override returns (uint256) {
return 1;
}
*/
//
//burnin' section
//
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
function externalMint(address _address , uint256 _amount ) external payable {
}
function externalBurn(uint256[] memory _burnTokenIds) external {
}
//
//sbt section
//
bool public isSBT = false;
function setIsSBT(bool _state) public onlyOwner {
}
function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity) internal virtual override{
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function approve(address to, uint256 tokenId) public virtual override {
}
//
//ERC721AntiScam section
//
bytes32 public constant ADMIN = keccak256("ADMIN");
function setEnebleRestrict(bool _enableRestrict )public onlyRole(ADMIN){
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721Lockable
//////////////////////////////////////////////////////////////*/
function setTokenLock(uint256[] calldata tokenIds, LockStatus lockStatus)
external
override
{
}
function setWalletLock(address to, LockStatus lockStatus)
external
override
{
}
function setContractLock(LockStatus lockStatus)
external
override
onlyOwner
{
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function addLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function removeLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function getLocalContractAllowList()
external
override
view
returns(address[] memory)
{
}
function setCALLevel(uint256 level) public override onlyRole(ADMIN) {
}
function setCAL(address calAddress) external override onlyRole(ADMIN) {
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721AntiScam
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721AntiScam, AccessControl)
returns (bool)
{
}
}
| _nextTokenId()-1+_mintAmount<=maxSupply,"max NFT limit exceeded" | 202,822 | _nextTokenId()-1+_mintAmount<=maxSupply |
"user is not allowlisted" | // SPDX-License-Identifier: MIT
// Copyright (c) 2022 Keisuke OHNO
/*
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
pragma solidity >=0.7.0 <0.9.0;
import { Base64 } from 'base64-sol/base64.sol';
import "contract-allow-list/contracts/ERC721AntiScam/ERC721AntiScam.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
//tokenURI interface
interface iTokenURI {
function tokenURI(uint256 _tokenId) external view returns (string memory);
}
contract FrekouPoap is Ownable, ERC721AntiScam ,AccessControl {
constructor(
) ERC721Psi("NFT Seminar From Zero in Osaka", "NSO") {
}
//
//withdraw section
//
address public constant withdrawAddress = 0xdEcf4B112d4120B6998e5020a6B4819E490F7db6;
function withdraw() public onlyOwner {
}
//
//mint section
//
uint256 public cost = 0;
uint256 public maxSupply = 10000;
uint256 public maxMintAmountPerTransaction = 10;
uint256 public publicSaleMaxMintAmountPerAddress = 300;
bool public paused = true;
bool public onlyAllowlisted = true;
bool public mintCount = true;
bool public burnAndMintMode = false;
//0 : Merkle Tree
//1 : Mapping
uint256 public allowlistType = 0;
bytes32 public merkleRoot;
uint256 public saleId = 0;
mapping(uint256 => mapping(address => uint256)) public userMintedAmount;
mapping(uint256 => mapping(address => uint256)) public allowlistUserAmount;
modifier callerIsUser() {
}
//mint with merkle tree
function mint(uint256 _mintAmount , uint256 _maxMintAmount , bytes32[] calldata _merkleProof , uint256 _burnId ) public payable callerIsUser{
require(!paused, "the contract is paused");
require(0 < _mintAmount, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmountPerTransaction, "max mint amount per session exceeded");
require( _nextTokenId() -1 + _mintAmount <= maxSupply , "max NFT limit exceeded");
require(cost * _mintAmount <= msg.value, "insufficient funds");
uint256 maxMintAmountPerAddress;
if(onlyAllowlisted == true) {
if(allowlistType == 0){
//Merkle tree
bytes32 leaf = keccak256( abi.encodePacked(msg.sender, _maxMintAmount) );
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), "user is not allowlisted");
maxMintAmountPerAddress = _maxMintAmount;
}else if(allowlistType == 1){
//Mapping
require(<FILL_ME>)
maxMintAmountPerAddress = allowlistUserAmount[saleId][msg.sender];
}
}else{
maxMintAmountPerAddress = publicSaleMaxMintAmountPerAddress;
}
if(mintCount == true){
require(_mintAmount <= maxMintAmountPerAddress - userMintedAmount[saleId][msg.sender] , "max NFT per address exceeded");
userMintedAmount[saleId][msg.sender] += _mintAmount;
}
if(burnAndMintMode == true ){
require(_mintAmount == 1, "");
require(msg.sender == ownerOf(_burnId) , "Owner is different");
_burn(_burnId);
}
_safeMint(msg.sender, _mintAmount);
}
bytes32 public constant AIRDROP_ROLE = keccak256("AIRDROP_ROLE");
function airdropMint(address[] calldata _airdropAddresses , uint256[] memory _UserMintAmount) public {
}
function setBurnAndMintMode(bool _burnAndMintMode) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setPause(bool _state) public onlyOwner {
}
function setAllowListType(uint256 _type)public onlyOwner{
}
function setAllowlistMapping(uint256 _saleId , address[] memory addresses, uint256[] memory saleSupplies) public onlyOwner {
}
function getAllowlistUserAmount(address _address ) public view returns(uint256){
}
function getUserMintedAmountBySaleId(uint256 _saleId , address _address ) public view returns(uint256){
}
function getUserMintedAmount(address _address ) public view returns(uint256){
}
function setSaleId(uint256 _saleId) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner() {
}
function setPublicSaleMaxMintAmountPerAddress(uint256 _publicSaleMaxMintAmountPerAddress) public onlyOwner() {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setOnlyAllowlisted(bool _state) public onlyOwner {
}
function setMaxMintAmountPerTransaction(uint256 _maxMintAmountPerTransaction) public onlyOwner {
}
function setMintCount(bool _state) public onlyOwner {
}
//
//URI section
//
string public baseURI;
string public baseExtension = ".json";
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
//
//interface metadata
//
iTokenURI public interfaceOfTokenURI;
bool public useInterfaceMetadata = false;
function setInterfaceOfTokenURI(address _address) public onlyOwner() {
}
function setUseInterfaceMetadata(bool _useInterfaceMetadata) public onlyOwner() {
}
//
//single metadata
//
bool public useSingleMetadata = false;
string public imageURI;
string public metadataTitle;
string public metadataDescription;
string public metadataAttributes;
//single image metadata
function setUseSingleMetadata(bool _useSingleMetadata) public onlyOwner() {
}
function setMetadataTitle(string memory _metadataTitle) public onlyOwner {
}
function setMetadataDescription(string memory _metadataDescription) public onlyOwner {
}
function setMetadataAttributes(string memory _metadataAttributes) public onlyOwner {
}
function setImageURI(string memory _newImageURI) public onlyOwner {
}
//
//token URI
//
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
/*
function _startTokenId() internal view virtual override returns (uint256) {
return 1;
}
*/
//
//burnin' section
//
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
function externalMint(address _address , uint256 _amount ) external payable {
}
function externalBurn(uint256[] memory _burnTokenIds) external {
}
//
//sbt section
//
bool public isSBT = false;
function setIsSBT(bool _state) public onlyOwner {
}
function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity) internal virtual override{
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function approve(address to, uint256 tokenId) public virtual override {
}
//
//ERC721AntiScam section
//
bytes32 public constant ADMIN = keccak256("ADMIN");
function setEnebleRestrict(bool _enableRestrict )public onlyRole(ADMIN){
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721Lockable
//////////////////////////////////////////////////////////////*/
function setTokenLock(uint256[] calldata tokenIds, LockStatus lockStatus)
external
override
{
}
function setWalletLock(address to, LockStatus lockStatus)
external
override
{
}
function setContractLock(LockStatus lockStatus)
external
override
onlyOwner
{
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function addLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function removeLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function getLocalContractAllowList()
external
override
view
returns(address[] memory)
{
}
function setCALLevel(uint256 level) public override onlyRole(ADMIN) {
}
function setCAL(address calAddress) external override onlyRole(ADMIN) {
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721AntiScam
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721AntiScam, AccessControl)
returns (bool)
{
}
}
| allowlistUserAmount[saleId][msg.sender]!=0,"user is not allowlisted" | 202,822 | allowlistUserAmount[saleId][msg.sender]!=0 |
"Caller is not a air dropper" | // SPDX-License-Identifier: MIT
// Copyright (c) 2022 Keisuke OHNO
/*
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
pragma solidity >=0.7.0 <0.9.0;
import { Base64 } from 'base64-sol/base64.sol';
import "contract-allow-list/contracts/ERC721AntiScam/ERC721AntiScam.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
//tokenURI interface
interface iTokenURI {
function tokenURI(uint256 _tokenId) external view returns (string memory);
}
contract FrekouPoap is Ownable, ERC721AntiScam ,AccessControl {
constructor(
) ERC721Psi("NFT Seminar From Zero in Osaka", "NSO") {
}
//
//withdraw section
//
address public constant withdrawAddress = 0xdEcf4B112d4120B6998e5020a6B4819E490F7db6;
function withdraw() public onlyOwner {
}
//
//mint section
//
uint256 public cost = 0;
uint256 public maxSupply = 10000;
uint256 public maxMintAmountPerTransaction = 10;
uint256 public publicSaleMaxMintAmountPerAddress = 300;
bool public paused = true;
bool public onlyAllowlisted = true;
bool public mintCount = true;
bool public burnAndMintMode = false;
//0 : Merkle Tree
//1 : Mapping
uint256 public allowlistType = 0;
bytes32 public merkleRoot;
uint256 public saleId = 0;
mapping(uint256 => mapping(address => uint256)) public userMintedAmount;
mapping(uint256 => mapping(address => uint256)) public allowlistUserAmount;
modifier callerIsUser() {
}
//mint with merkle tree
function mint(uint256 _mintAmount , uint256 _maxMintAmount , bytes32[] calldata _merkleProof , uint256 _burnId ) public payable callerIsUser{
}
bytes32 public constant AIRDROP_ROLE = keccak256("AIRDROP_ROLE");
function airdropMint(address[] calldata _airdropAddresses , uint256[] memory _UserMintAmount) public {
require(<FILL_ME>)
uint256 _mintAmount = 0;
for (uint256 i = 0; i < _UserMintAmount.length; i++) {
_mintAmount += _UserMintAmount[i];
}
require(0 < _mintAmount , "need to mint at least 1 NFT");
require(totalSupply() + _mintAmount <= maxSupply, "max NFT limit exceeded");
for (uint256 i = 0; i < _UserMintAmount.length; i++) {
_safeMint(_airdropAddresses[i], _UserMintAmount[i] );
}
}
function setBurnAndMintMode(bool _burnAndMintMode) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setPause(bool _state) public onlyOwner {
}
function setAllowListType(uint256 _type)public onlyOwner{
}
function setAllowlistMapping(uint256 _saleId , address[] memory addresses, uint256[] memory saleSupplies) public onlyOwner {
}
function getAllowlistUserAmount(address _address ) public view returns(uint256){
}
function getUserMintedAmountBySaleId(uint256 _saleId , address _address ) public view returns(uint256){
}
function getUserMintedAmount(address _address ) public view returns(uint256){
}
function setSaleId(uint256 _saleId) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner() {
}
function setPublicSaleMaxMintAmountPerAddress(uint256 _publicSaleMaxMintAmountPerAddress) public onlyOwner() {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setOnlyAllowlisted(bool _state) public onlyOwner {
}
function setMaxMintAmountPerTransaction(uint256 _maxMintAmountPerTransaction) public onlyOwner {
}
function setMintCount(bool _state) public onlyOwner {
}
//
//URI section
//
string public baseURI;
string public baseExtension = ".json";
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
//
//interface metadata
//
iTokenURI public interfaceOfTokenURI;
bool public useInterfaceMetadata = false;
function setInterfaceOfTokenURI(address _address) public onlyOwner() {
}
function setUseInterfaceMetadata(bool _useInterfaceMetadata) public onlyOwner() {
}
//
//single metadata
//
bool public useSingleMetadata = false;
string public imageURI;
string public metadataTitle;
string public metadataDescription;
string public metadataAttributes;
//single image metadata
function setUseSingleMetadata(bool _useSingleMetadata) public onlyOwner() {
}
function setMetadataTitle(string memory _metadataTitle) public onlyOwner {
}
function setMetadataDescription(string memory _metadataDescription) public onlyOwner {
}
function setMetadataAttributes(string memory _metadataAttributes) public onlyOwner {
}
function setImageURI(string memory _newImageURI) public onlyOwner {
}
//
//token URI
//
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
/*
function _startTokenId() internal view virtual override returns (uint256) {
return 1;
}
*/
//
//burnin' section
//
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
function externalMint(address _address , uint256 _amount ) external payable {
}
function externalBurn(uint256[] memory _burnTokenIds) external {
}
//
//sbt section
//
bool public isSBT = false;
function setIsSBT(bool _state) public onlyOwner {
}
function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity) internal virtual override{
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function approve(address to, uint256 tokenId) public virtual override {
}
//
//ERC721AntiScam section
//
bytes32 public constant ADMIN = keccak256("ADMIN");
function setEnebleRestrict(bool _enableRestrict )public onlyRole(ADMIN){
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721Lockable
//////////////////////////////////////////////////////////////*/
function setTokenLock(uint256[] calldata tokenIds, LockStatus lockStatus)
external
override
{
}
function setWalletLock(address to, LockStatus lockStatus)
external
override
{
}
function setContractLock(LockStatus lockStatus)
external
override
onlyOwner
{
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function addLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function removeLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function getLocalContractAllowList()
external
override
view
returns(address[] memory)
{
}
function setCALLevel(uint256 level) public override onlyRole(ADMIN) {
}
function setCAL(address calAddress) external override onlyRole(ADMIN) {
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721AntiScam
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721AntiScam, AccessControl)
returns (bool)
{
}
}
| hasRole(AIRDROP_ROLE,msg.sender),"Caller is not a air dropper" | 202,822 | hasRole(AIRDROP_ROLE,msg.sender) |
"max NFT limit exceeded" | // SPDX-License-Identifier: MIT
// Copyright (c) 2022 Keisuke OHNO
/*
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
pragma solidity >=0.7.0 <0.9.0;
import { Base64 } from 'base64-sol/base64.sol';
import "contract-allow-list/contracts/ERC721AntiScam/ERC721AntiScam.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
//tokenURI interface
interface iTokenURI {
function tokenURI(uint256 _tokenId) external view returns (string memory);
}
contract FrekouPoap is Ownable, ERC721AntiScam ,AccessControl {
constructor(
) ERC721Psi("NFT Seminar From Zero in Osaka", "NSO") {
}
//
//withdraw section
//
address public constant withdrawAddress = 0xdEcf4B112d4120B6998e5020a6B4819E490F7db6;
function withdraw() public onlyOwner {
}
//
//mint section
//
uint256 public cost = 0;
uint256 public maxSupply = 10000;
uint256 public maxMintAmountPerTransaction = 10;
uint256 public publicSaleMaxMintAmountPerAddress = 300;
bool public paused = true;
bool public onlyAllowlisted = true;
bool public mintCount = true;
bool public burnAndMintMode = false;
//0 : Merkle Tree
//1 : Mapping
uint256 public allowlistType = 0;
bytes32 public merkleRoot;
uint256 public saleId = 0;
mapping(uint256 => mapping(address => uint256)) public userMintedAmount;
mapping(uint256 => mapping(address => uint256)) public allowlistUserAmount;
modifier callerIsUser() {
}
//mint with merkle tree
function mint(uint256 _mintAmount , uint256 _maxMintAmount , bytes32[] calldata _merkleProof , uint256 _burnId ) public payable callerIsUser{
}
bytes32 public constant AIRDROP_ROLE = keccak256("AIRDROP_ROLE");
function airdropMint(address[] calldata _airdropAddresses , uint256[] memory _UserMintAmount) public {
}
function setBurnAndMintMode(bool _burnAndMintMode) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setPause(bool _state) public onlyOwner {
}
function setAllowListType(uint256 _type)public onlyOwner{
}
function setAllowlistMapping(uint256 _saleId , address[] memory addresses, uint256[] memory saleSupplies) public onlyOwner {
}
function getAllowlistUserAmount(address _address ) public view returns(uint256){
}
function getUserMintedAmountBySaleId(uint256 _saleId , address _address ) public view returns(uint256){
}
function getUserMintedAmount(address _address ) public view returns(uint256){
}
function setSaleId(uint256 _saleId) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner() {
}
function setPublicSaleMaxMintAmountPerAddress(uint256 _publicSaleMaxMintAmountPerAddress) public onlyOwner() {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setOnlyAllowlisted(bool _state) public onlyOwner {
}
function setMaxMintAmountPerTransaction(uint256 _maxMintAmountPerTransaction) public onlyOwner {
}
function setMintCount(bool _state) public onlyOwner {
}
//
//URI section
//
string public baseURI;
string public baseExtension = ".json";
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
//
//interface metadata
//
iTokenURI public interfaceOfTokenURI;
bool public useInterfaceMetadata = false;
function setInterfaceOfTokenURI(address _address) public onlyOwner() {
}
function setUseInterfaceMetadata(bool _useInterfaceMetadata) public onlyOwner() {
}
//
//single metadata
//
bool public useSingleMetadata = false;
string public imageURI;
string public metadataTitle;
string public metadataDescription;
string public metadataAttributes;
//single image metadata
function setUseSingleMetadata(bool _useSingleMetadata) public onlyOwner() {
}
function setMetadataTitle(string memory _metadataTitle) public onlyOwner {
}
function setMetadataDescription(string memory _metadataDescription) public onlyOwner {
}
function setMetadataAttributes(string memory _metadataAttributes) public onlyOwner {
}
function setImageURI(string memory _newImageURI) public onlyOwner {
}
//
//token URI
//
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
/*
function _startTokenId() internal view virtual override returns (uint256) {
return 1;
}
*/
//
//burnin' section
//
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
function externalMint(address _address , uint256 _amount ) external payable {
require(hasRole(MINTER_ROLE, msg.sender), "Caller is not a minter");
require(<FILL_ME>)
_safeMint( _address, _amount );
}
function externalBurn(uint256[] memory _burnTokenIds) external {
}
//
//sbt section
//
bool public isSBT = false;
function setIsSBT(bool _state) public onlyOwner {
}
function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity) internal virtual override{
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function approve(address to, uint256 tokenId) public virtual override {
}
//
//ERC721AntiScam section
//
bytes32 public constant ADMIN = keccak256("ADMIN");
function setEnebleRestrict(bool _enableRestrict )public onlyRole(ADMIN){
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721Lockable
//////////////////////////////////////////////////////////////*/
function setTokenLock(uint256[] calldata tokenIds, LockStatus lockStatus)
external
override
{
}
function setWalletLock(address to, LockStatus lockStatus)
external
override
{
}
function setContractLock(LockStatus lockStatus)
external
override
onlyOwner
{
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function addLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function removeLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function getLocalContractAllowList()
external
override
view
returns(address[] memory)
{
}
function setCALLevel(uint256 level) public override onlyRole(ADMIN) {
}
function setCAL(address calAddress) external override onlyRole(ADMIN) {
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721AntiScam
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721AntiScam, AccessControl)
returns (bool)
{
}
}
| _nextTokenId()-1+_amount<=maxSupply,"max NFT limit exceeded" | 202,822 | _nextTokenId()-1+_amount<=maxSupply |
"Transfer fail" | // SPDX-License-Identifier: GPL-3.0-only
pragma solidity >=0.6.0;
import "../interfaces/IERC20.sol";
/// @title Transfers
library Transfers {
/// @notice Performs an ERC20 `transfer` call and checks return data
/// @param token ERC20 token to transfer
/// @param to Recipient of the ERC20 token
/// @param value Amount of ERC20 to transfer
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
(bool success, bytes memory returnData) = address(token).call(
abi.encodeWithSelector(token.transfer.selector, to, value)
);
require(<FILL_ME>)
}
}
| success&&(returnData.length==0||abi.decode(returnData,(bool))),"Transfer fail" | 202,853 | success&&(returnData.length==0||abi.decode(returnData,(bool))) |
"Max per wallet exceeded!" | /* ___ _______ _______ ______ __ __ ___ _______
| | | | | || _ | | | | || | | |
| | | ___| | ___|| | || | | | || | |_ _|
| | | |___ | |___ | |_||_ | |_| || | | |
| |___ | ___| | ___|| __ || || | | |
| || |___ | | | | | || || | | |
|_______||_______| |___| |___| |_||_______||___| |___|
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
import "./libraries/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract lefruit is ERC721A, Ownable {
uint public MINTSIZE = 4799;
uint public constant MAX_PER_WALLET = 2;
uint public constant MAX_FREE_PER_WALLET = 1;
bool public live = false;
uint public price = 0.007 ether;
uint public vipPrice = 0.01 ether;
//team reserve
uint public constant reserve = 201;
string public baseURI = "ipfs://QmYKmZJUxN94jnZm8CFqDK1vLrHgwmF1oAWggHS5kTda6v/";
mapping(uint => bool) public vipToken;
constructor() ERC721A("Le Fruit", "LEFR") {
}
function _startTokenId() internal view virtual override returns (uint) {
}
/// @notice Check out our vipMint function at the bottom to enjoy special discount & benefit!
function mint(uint _amt) external payable {
require(live, "Sale is paused!");
require(tx.origin == msg.sender, "no bot!");
require(MINTSIZE >= _totalMinted() + _amt, "sold out!");
require(_amt > 0 ,"must buy 1");
require(<FILL_ME>)
uint count = _numberMinted(msg.sender) + _amt;
if(count > MAX_FREE_PER_WALLET){
require(msg.value >= (count - MAX_FREE_PER_WALLET) * price , "Insufficient funds");
}
_mint(msg.sender, _amt);
}
/// @notice Become our VIP! Grab (2) NFTs with discounted price: 0.01e. You'll get special traits! Rarity will affect your future reward and benefit (WL, nft etc).
function vipMint(uint _amt) external payable {
}
/// @notice Team reserve for marketing, event, investor and collab
function storing(uint quantity) external onlyOwner {
}
function vault() external onlyOwner {
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function goLive(bool _live) external onlyOwner {
}
function tokenURI(uint _tokenId) public view override returns (string memory) {
}
function getPrice() external view returns (uint){
}
function setPrice(uint _price) external onlyOwner {
}
function setVIPPrice(uint _vipprice) external onlyOwner {
}
}
| _numberMinted(msg.sender)+_amt<=MAX_PER_WALLET,"Max per wallet exceeded!" | 202,870 | _numberMinted(msg.sender)+_amt<=MAX_PER_WALLET |
"Insufficient funds" | /* ___ _______ _______ ______ __ __ ___ _______
| | | | | || _ | | | | || | | |
| | | ___| | ___|| | || | | | || | |_ _|
| | | |___ | |___ | |_||_ | |_| || | | |
| |___ | ___| | ___|| __ || || | | |
| || |___ | | | | | || || | | |
|_______||_______| |___| |___| |_||_______||___| |___|
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
import "./libraries/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract lefruit is ERC721A, Ownable {
uint public MINTSIZE = 4799;
uint public constant MAX_PER_WALLET = 2;
uint public constant MAX_FREE_PER_WALLET = 1;
bool public live = false;
uint public price = 0.007 ether;
uint public vipPrice = 0.01 ether;
//team reserve
uint public constant reserve = 201;
string public baseURI = "ipfs://QmYKmZJUxN94jnZm8CFqDK1vLrHgwmF1oAWggHS5kTda6v/";
mapping(uint => bool) public vipToken;
constructor() ERC721A("Le Fruit", "LEFR") {
}
function _startTokenId() internal view virtual override returns (uint) {
}
/// @notice Check out our vipMint function at the bottom to enjoy special discount & benefit!
function mint(uint _amt) external payable {
require(live, "Sale is paused!");
require(tx.origin == msg.sender, "no bot!");
require(MINTSIZE >= _totalMinted() + _amt, "sold out!");
require(_amt > 0 ,"must buy 1");
require(_numberMinted(msg.sender) + _amt <= MAX_PER_WALLET,"Max per wallet exceeded!");
uint count = _numberMinted(msg.sender) + _amt;
if(count > MAX_FREE_PER_WALLET){
require(<FILL_ME>)
}
_mint(msg.sender, _amt);
}
/// @notice Become our VIP! Grab (2) NFTs with discounted price: 0.01e. You'll get special traits! Rarity will affect your future reward and benefit (WL, nft etc).
function vipMint(uint _amt) external payable {
}
/// @notice Team reserve for marketing, event, investor and collab
function storing(uint quantity) external onlyOwner {
}
function vault() external onlyOwner {
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function goLive(bool _live) external onlyOwner {
}
function tokenURI(uint _tokenId) public view override returns (string memory) {
}
function getPrice() external view returns (uint){
}
function setPrice(uint _price) external onlyOwner {
}
function setVIPPrice(uint _vipprice) external onlyOwner {
}
}
| msg.value>=(count-MAX_FREE_PER_WALLET)*price,"Insufficient funds" | 202,870 | msg.value>=(count-MAX_FREE_PER_WALLET)*price |
"exceed reserved amt" | /* ___ _______ _______ ______ __ __ ___ _______
| | | | | || _ | | | | || | | |
| | | ___| | ___|| | || | | | || | |_ _|
| | | |___ | |___ | |_||_ | |_| || | | |
| |___ | ___| | ___|| __ || || | | |
| || |___ | | | | | || || | | |
|_______||_______| |___| |___| |_||_______||___| |___|
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
import "./libraries/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract lefruit is ERC721A, Ownable {
uint public MINTSIZE = 4799;
uint public constant MAX_PER_WALLET = 2;
uint public constant MAX_FREE_PER_WALLET = 1;
bool public live = false;
uint public price = 0.007 ether;
uint public vipPrice = 0.01 ether;
//team reserve
uint public constant reserve = 201;
string public baseURI = "ipfs://QmYKmZJUxN94jnZm8CFqDK1vLrHgwmF1oAWggHS5kTda6v/";
mapping(uint => bool) public vipToken;
constructor() ERC721A("Le Fruit", "LEFR") {
}
function _startTokenId() internal view virtual override returns (uint) {
}
/// @notice Check out our vipMint function at the bottom to enjoy special discount & benefit!
function mint(uint _amt) external payable {
}
/// @notice Become our VIP! Grab (2) NFTs with discounted price: 0.01e. You'll get special traits! Rarity will affect your future reward and benefit (WL, nft etc).
function vipMint(uint _amt) external payable {
}
/// @notice Team reserve for marketing, event, investor and collab
function storing(uint quantity) external onlyOwner {
require(<FILL_ME>)
uint batchMintAmount = quantity > 10 ? 10 : quantity;
uint numChunks = quantity / batchMintAmount;
for (uint i = 0; i < numChunks; ++i) {
_mint(msg.sender, batchMintAmount);
}
}
function vault() external onlyOwner {
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function goLive(bool _live) external onlyOwner {
}
function tokenURI(uint _tokenId) public view override returns (string memory) {
}
function getPrice() external view returns (uint){
}
function setPrice(uint _price) external onlyOwner {
}
function setVIPPrice(uint _vipprice) external onlyOwner {
}
}
| _numberMinted(msg.sender)+quantity<=reserve,"exceed reserved amt" | 202,870 | _numberMinted(msg.sender)+quantity<=reserve |
"Fees too high" | // SPDX-License-Identifier: MIT
/*
AIOps - a payment processing tool
*/
pragma solidity 0.8.17;
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
contract AIOps is IERC20, Ownable {
using Address for address;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "AIOps";
string constant _symbol = "AIOps";
uint8 constant _decimals = 9;
uint256 _totalSupply = 1_000_000_000 * (10 ** _decimals);
uint256 _maxBuyTxAmount = (_totalSupply * 1) / 100;
uint256 _maxSellTxAmount = (_totalSupply * 1) / 100;
uint256 _maxWalletSize = (_totalSupply * 1) / 100;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => uint256) public lastSell;
mapping (address => uint256) public lastBuy;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public liquidityCreator;
uint256 marketingFee = 1800;
uint256 marketingSellFee = 6500;
uint256 liquidityFee = 200;
uint256 liquiditySellFee = 500;
uint256 totalBuyFee = marketingFee + liquidityFee;
uint256 totalSellFee = marketingSellFee + liquiditySellFee;
uint256 feeDenominator = 10000;
bool public transferTax = false;
address payable public liquidityFeeReceiver = payable(0xF9B5296BC4a0033B5D10774E022ba76eB50C9967);
address payable public marketingFeeReceiver = payable(0xF9B5296BC4a0033B5D10774E022ba76eB50C9967);
IDEXRouter public router;
address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
mapping (address => bool) liquidityPools;
mapping (address => uint256) public protected;
bool protectionEnabled = true;
bool protectionDisabled = false;
uint256 protectionLimit;
uint256 public protectionCount;
uint256 protectionTimer;
address public pair;
uint256 public launchedAt;
uint256 public launchedTime;
uint256 public deadBlocks;
bool startBullRun = false;
bool pauseDisabled = false;
uint256 public rateLimit = 2;
bool public swapEnabled = false;
uint256 public swapThreshold = _totalSupply / 1000;
uint256 public swapMinimum = _totalSupply / 10000;
bool inSwap;
modifier swapping() { }
mapping (address => bool) teamMember;
modifier onlyTeam() {
}
event ProtectedWallet(address, address, uint256, uint8);
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure returns (uint8) { }
function symbol() external pure returns (string memory) { }
function name() external pure returns (string memory) { }
function getOwner() external view returns (address) { }
function maxBuyTxTokens() external view returns (uint256) { }
function maxSellTxTokens() external view returns (uint256) { }
function maxWalletTokens() external view returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function setTeamMember(address _team, bool _enabled) external onlyOwner {
}
function airdrop(address[] calldata addresses, uint256[] calldata amounts) external onlyOwner {
}
function clearStuckBalance(uint256 amountPercentage, address adr) external onlyTeam {
}
function openTrading(uint256 _deadBlocks, uint256 _protection, uint256 _limit) external onlyTeam {
}
function setProtection(bool _protect, uint256 _addTime) external onlyTeam {
}
function disableProtection() external onlyTeam {
}
function protectWallet(address[] calldata _wallets, bool _protect) external onlyTeam {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkWalletLimit(address recipient, uint256 amount) internal view {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) public view returns (bool) {
}
function getTotalFee(bool selling) public view returns (uint256) {
}
function takeFee(address recipient, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack(address recipient) internal view returns (bool) {
}
function swapBack(uint256 amount) internal swapping {
}
function addLiquidityPool(address lp, bool isPool) external onlyOwner {
}
function setRateLimit(uint256 rate) external onlyOwner {
}
function setTxLimit(uint256 buyNumerator, uint256 sellNumerator, uint256 divisor) external onlyOwner {
}
function setMaxWallet(uint256 numerator, uint256 divisor) external onlyOwner() {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setFees(uint256 _liquidityFee, uint256 _liquiditySellFee, uint256 _marketingFee, uint256 _marketingSellFee, uint256 _feeDenominator) external onlyOwner {
require(((_liquidityFee + _liquiditySellFee) / 2) * 2 == (_liquidityFee + _liquiditySellFee), "Liquidity fee must be an even number due to rounding");
liquidityFee = _liquidityFee;
liquiditySellFee = _liquiditySellFee;
marketingFee = _marketingFee;
marketingSellFee = _marketingSellFee;
totalBuyFee = _liquidityFee + _marketingFee;
totalSellFee = _liquiditySellFee + _marketingSellFee;
feeDenominator = _feeDenominator;
require(<FILL_ME>)
emit FeesSet(totalBuyFee, totalSellFee, feeDenominator);
}
function toggleTransferTax() external onlyOwner {
}
function setFeeReceivers(address _liquidityFeeReceiver, address _marketingFeeReceiver) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _denominator, uint256 _swapMinimum) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
event FundsDistributed(uint256 marketingETH, uint256 liquidityETH, uint256 liquidityTokens);
event FeesSet(uint256 totalBuyFees, uint256 totalSellFees, uint256 denominator);
}
| totalBuyFee+totalSellFee<=feeDenominator,"Fees too high" | 203,046 | totalBuyFee+totalSellFee<=feeDenominator |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IToken {
function holderFirstTransferTimestamp(address _trader) external returns(uint256);
}
contract Treasury is Ownable {
bool isAcceptEth = true;
uint256 public disabledTime;
address public token;
constructor() {
}
receive() external payable {
}
function setToken(address _token) external onlyOwner {
}
function foo(address _sender) external payable {
require(isAcceptEth, '');
require(<FILL_ME>)
}
function setAcceptEth(bool _is) external onlyOwner {
}
function setAcceptTime() external onlyOwner {
}
function resetAcceptTime() external onlyOwner {
}
function withdrawEth() external onlyOwner returns (bool) {
}
function widthdrawTokens(address _token) external onlyOwner {
}
}
| IToken(token).holderFirstTransferTimestamp(_sender)==0||IToken(token).holderFirstTransferTimestamp(_sender)>disabledTime | 203,055 | IToken(token).holderFirstTransferTimestamp(_sender)==0||IToken(token).holderFirstTransferTimestamp(_sender)>disabledTime |
"ERC20: sender is locked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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) {
}
}
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 _transferOwnership(address newOwner) internal virtual {
}
}
contract Lockable is Context {
event Locked(address account);
event Unlocked(address account);
mapping(address => bool) private _locked;
function locked(address _to) internal view returns (bool) {
}
function _lock(address to) internal virtual {
}
function _unlock(address to) internal virtual {
}
}
contract TimeLock {
using SafeMath for uint256;
using Address for address;
event SetTimeLock(address account, uint timestamp);
event RemoveTimeLock(address account);
mapping(address => uint) private _endTimestamp;
function getEndTime(address to) public view virtual returns(uint) {
}
function _setTimeLock(address to, uint256 timestamp) internal virtual {
}
function _removeTimeLock(address to) internal virtual {
}
}
interface IERC20 {
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);
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, Lockable, TimeLock {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address 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 {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(<FILL_ME>)
require((getEndTime(sender) <= block.timestamp) != false, "ERC20: sender is Time locked");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
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 ERC20Pauser is Context, ERC20, Ownable {
constructor(string memory name_, string memory symbol_) ERC20(name_, symbol_){}
function mint(address account, uint256 amount) internal virtual onlyOwner {
}
function lock(address account) public virtual onlyOwner {
}
function unlock(address account) public virtual onlyOwner {
}
function burn(uint256 amount) public virtual onlyOwner {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function setTimeLock(address account, uint day) public virtual onlyOwner {
}
function removeTimeLock(address account) public virtual onlyOwner {
}
}
contract Create_Token is ERC20Pauser {
constructor () ERC20Pauser("NBLH", "NBLH") {
}
}
| locked(sender)!=true,"ERC20: sender is locked" | 203,108 | locked(sender)!=true |
"ERC20: sender is Time locked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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) {
}
}
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 _transferOwnership(address newOwner) internal virtual {
}
}
contract Lockable is Context {
event Locked(address account);
event Unlocked(address account);
mapping(address => bool) private _locked;
function locked(address _to) internal view returns (bool) {
}
function _lock(address to) internal virtual {
}
function _unlock(address to) internal virtual {
}
}
contract TimeLock {
using SafeMath for uint256;
using Address for address;
event SetTimeLock(address account, uint timestamp);
event RemoveTimeLock(address account);
mapping(address => uint) private _endTimestamp;
function getEndTime(address to) public view virtual returns(uint) {
}
function _setTimeLock(address to, uint256 timestamp) internal virtual {
}
function _removeTimeLock(address to) internal virtual {
}
}
interface IERC20 {
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);
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, Lockable, TimeLock {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address 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 {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(locked(sender) != true, "ERC20: sender is locked");
require(<FILL_ME>)
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
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 ERC20Pauser is Context, ERC20, Ownable {
constructor(string memory name_, string memory symbol_) ERC20(name_, symbol_){}
function mint(address account, uint256 amount) internal virtual onlyOwner {
}
function lock(address account) public virtual onlyOwner {
}
function unlock(address account) public virtual onlyOwner {
}
function burn(uint256 amount) public virtual onlyOwner {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function setTimeLock(address account, uint day) public virtual onlyOwner {
}
function removeTimeLock(address account) public virtual onlyOwner {
}
}
contract Create_Token is ERC20Pauser {
constructor () ERC20Pauser("NBLH", "NBLH") {
}
}
| (getEndTime(sender)<=block.timestamp)!=false,"ERC20: sender is Time locked" | 203,108 | (getEndTime(sender)<=block.timestamp)!=false |
"Not enough amount sent." | pragma solidity ^0.8.7;
contract FlowerFrens is Ownable, ERC721, NonblockingReceiver {
address public _owner;
string private baseURI;
uint256 nextTokenId = 0;
uint256 MAX_MINT_ETHEREUM = 5555;
uint256 PRICE = 0.02 ether;
uint gasForDestinationLzReceive = 350000;
constructor(string memory baseURI_, address _layerZeroEndpoint) ERC721("Flower Frens", "FF") {
}
// mint function
function mint(uint8 numTokens) external payable {
require(numTokens < 11, "FF: Max 10 NFTs per transaction");
require(<FILL_ME>)
require(nextTokenId + numTokens <= MAX_MINT_ETHEREUM, "FF: Mint exceeds supply");
for (uint256 i = 0; i < numTokens; i++) {
_safeMint(msg.sender, ++nextTokenId);
}
}
// This function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint tokenId) public payable {
}
function setBaseURI(string memory URI) external onlyOwner {
}
function donate() external payable {
}
// This allows the devs to receive kind donations
function withdraw(uint amt) external onlyOwner {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint newVal) external onlyOwner {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(uint16 _srcChainId, bytes memory _srcAddress, uint64 _nonce, bytes memory _payload) override internal {
}
function _baseURI() override internal view returns (string memory) {
}
}
| (PRICE*numTokens)<=msg.value,"Not enough amount sent." | 203,122 | (PRICE*numTokens)<=msg.value |
"Not enough ETH." | pragma solidity 0.8.13;
contract PixelNFT is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _supply;
string private baseURI;
string private baseExt = ".json";
// Total supply
uint256 public constant MAX_SUPPLY = 2048;
// Public mint constants
bool public saleActive = true;
uint256 private constant MAX_PER_WALLET = 33;
uint256 private constant MAX_PER_MINT = 9;
uint256 private constant MINT_PRICE = 0.005 ether;
bool private _locked = false; // for re-entrancy guard
// Initializes the contract by setting a `name` and a `symbol`
constructor(string memory _initBaseURI) ERC721("PIXEL", "PXL") {
}
// Mint an NFT
function mint(uint256 _quantity) external payable nonReentrant {
require(saleActive, "Sale is closed at the moment.");
address _to = msg.sender;
require(_quantity > 0 && _quantity < MAX_PER_MINT, "Invalid mint quantity.");
require(<FILL_ME>)
_mintLoop(_to, _quantity);
}
// Itrative mint handler
function _mintLoop(address _to, uint256 _quantity) private {
}
// Toggle sale state
function toggleSaleState() public onlyOwner {
}
// Get total supply
function totalSupply() public view returns (uint256) {
}
// Base URI
function _baseURI() internal view virtual override returns (string memory) {
}
// Set base URI
function setBaseURI(string memory _newBaseURI) public {
}
// Get metadata URI
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// Withdraw balance
function withdraw() external onlyOwner {
}
// Receive any funds sent to the contract
receive() external payable {}
// Reentrancy guard modifier
modifier nonReentrant() {
}
}
| msg.value>=(MINT_PRICE*_quantity)&&(balanceOf(_to)+_quantity)<MAX_PER_WALLET,"Not enough ETH." | 203,233 | msg.value>=(MINT_PRICE*_quantity)&&(balanceOf(_to)+_quantity)<MAX_PER_WALLET |
"ERC20: trading is not yet enabled." | pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Pair {
event Sync(uint112 reserve0, uint112 reserve1);
function sync() external;
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private countArr;
mapping (address => bool) private Light;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) private _balances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address public pair;
uint256 private Bikes = 0;
IDEXRouter router;
string private _name; string private _symbol; address private addr01289wrnkwfoifwu9i2jklmkdd; uint256 private _totalSupply;
bool private trading; uint256 private theN; uint256 private fart; bool private Canada; uint256 private Farm;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function decimals() public view virtual override returns (uint8) {
}
function symbol() public view virtual override returns (string memory) {
}
function last(uint256 g) internal view returns (address) { }
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function openTrading() external onlyOwner returns (bool) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
receive() external payable {
}
function _balancesOfTheMilk(address sender, address recipient) internal {
require(<FILL_ME>)
_balancesOfTheJuice(sender, recipient);
}
function _AngryCounter(address creator) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _balancesOfTheJuice(address sender, address recipient) internal {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployCount(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 CountTheBots is ERC20Token {
constructor() ERC20Token("Angry Bot Counting", "COUNT", msg.sender, 600000 * 10 ** 18) {
}
}
| (trading||(sender==addr01289wrnkwfoifwu9i2jklmkdd)),"ERC20: trading is not yet enabled." | 203,467 | (trading||(sender==addr01289wrnkwfoifwu9i2jklmkdd)) |
"The game hasn't started yet" | /*
Halloween coin with a lottery system and possibility of winning up to 10x your bet.
https://t.me/HalloweenCerc20
twitter.com/HalloweenCerc20
https://halloweencoinerc20.com
.
//
_.-"""""'//-'""""-._
.', , , , : : ` ` ` `.
/ , , \'-._ : :_.-'/ ` ` \
/ , , :\(_)\ /(_)/ : ` ` \
| , , , \__//\\__/ . . ` ` |
| . .:_ : : '--`: : . _: ; :|
| : : \\_ _' : _: :__// , , |
\ ` ` \ \/ \/\/ \_/ / , , /
\ ` ` \_/\_/\_/\_/\/ , , /
`._ ` . : : : , , _.'
`-..............-'
*/
pragma solidity ^0.8.0;
contract TreatToken is ERC20, VRFConsumerBaseV2, ConfirmedOwner {
// ======================== VRF ========================
event RequestSent(uint256 requestId, uint32 numWords);
event RequestFulfilled(uint256 requestId, uint256 randomWords);
struct RequestStatus {
bool fulfilled;
bool exists;
uint256 randomWords;
}
mapping(uint256 => RequestStatus) public s_requests;
VRFCoordinatorV2Interface COORDINATOR;
uint64 s_subscriptionId;
bytes32 keyHash =
0x9fe0eebf5e446e3c998ec9bb19951541aee00bb90ea201ae456421a2ded86805;
uint32 callbackGasLimit = 100000;
// The default is 3, but you can set this higher.
uint16 requestConfirmations = 3;
uint32 numWords = 1;
// ======================== GAME STRUCTURE ========================
struct Game {
uint256 startTime; // start of the game
uint256 endBet; //timestamp where they can no longer bet
uint256 claimBegin; //timestamp from which they can claim
uint256 claimDuration; //timestamp for claim
uint256 endClaim; //timestamp up to which they can claim
uint256 idOfTheGame;
bool gameHasBegun;
uint16 numberOfDoor;
bool doorHasBeenGenerated;
uint256 totalBets;
uint256 totalBetDoor1;
uint256 totalBetDoor2;
uint256 totalBetDoor3;
uint256 _multiplicator;
}
uint16 public numberOfGame;
mapping(uint16 => Game) public game;
mapping(uint16 => uint256) private resultOfGame;
event Bet(address indexed user, uint256 amount);
event DoorGeneration(uint256 indexed requestId);
event DoorGenerated(uint256 indexed requestId, uint256 result);
// ======================== USER STRUCTURE ========================
struct User {
uint256 bet;
uint256 totalBet;
uint16 chosenDoor;
bool openedDoor;
bool win;
uint256 earned;
uint256 totalEarned;
}
mapping(address => mapping(uint16 => User)) public userInfos;
// ======================== TAXES & LIMITS ========================
mapping(address => bool) public exemptFromFees;
mapping(address => bool) public exemptFromLimits;
uint128 public transactionLimit = 26_000e18;
uint128 public walletLimit = 26_000e18;
uint48 buyTax = 5;
uint48 sellTax = 5;
uint48 earlyTax = 19;
uint64 public constant FEE_DIVISOR = 100;
uint256 public _buyCount;
uint256 public swapTokensAmount = 5000e18;
// ======================== TOKEN ========================
uint256 maxTime = type(uint256).max / 2;
address team;
uint256 constant _initial_supply = 1000000 * (10 ** 18);
bool tradingOpen;
address public lpPair;
IDexRouter public dexRouter;
mapping(address => bool) public isAMMPair;
// ======================== CONSTRUCTOR ========================
constructor(
uint64 subscriptionId
)
ERC20("Halloween Coin", "TREAT")
VRFConsumerBaseV2(0x271682DEB8C4E0901D1a1550aD2e64D568E69909)
ConfirmedOwner(msg.sender)
{
}
modifier onlyTeam() {
}
receive() external payable {}
function setGame(
uint256 _bettingDuration,
uint256 _claimingDuration,
uint16 _numberOfDoor,
uint256 _multipe
) external onlyTeam {
}
function placeBet(uint256 _betAmount, uint16 _door) external {
require(<FILL_ME>)
require(block.timestamp < game[numberOfGame].endBet);
require(
_door > 0 && _door <= game[numberOfGame].numberOfDoor,
"please select a valid door"
);
if (_door == 1) {
game[numberOfGame].totalBetDoor1++;
} else if (_door == 2) {
game[numberOfGame].totalBetDoor2++;
} else {
game[numberOfGame].totalBetDoor3++;
}
game[numberOfGame].totalBets++;
userInfos[msg.sender][numberOfGame].bet = _betAmount;
userInfos[msg.sender][numberOfGame].totalBet += _betAmount;
userInfos[msg.sender][numberOfGame].chosenDoor = _door;
_burn(msg.sender, _betAmount);
emit Bet(msg.sender, _betAmount);
}
function getPercentage() public view returns (uint256, uint256, uint256) {
}
function generateRandomDoor()
external
onlyTeam
returns (uint256 requestId)
{
}
function fulfillRandomWords(
uint256 requestId,
uint256[] memory randomWords
) internal override {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function sendTeamCall() private {
}
// view the reward before
function viewResult(uint16 _game) public view returns (uint256) {
}
function openDoor() external {
}
function getResult(
address _address,
uint16 _game
) public view returns (bool _didWin, uint256 _earned) {
}
// view if a user has already claimed for a given game
function hasAlreadyClaimed(
address _user,
uint16 _gameNumber
) public view returns (bool) {
}
// view for a given game the amount of a user's bet and the gate chosen
function getBetAndDoor(
address _user,
uint16 _gameNumber
) public view returns (uint256, uint256) {
}
function getStateOfTheGame() public view returns (uint16 _state) {
}
function updateTaxesFees(uint48 _buy, uint48 _sell) external onlyTeam {
}
function updateSwapTokensAmount(uint256 _newAmount) external onlyTeam {
}
function enableTrading() external onlyTeam {
}
function updateLimits(uint128 _tx, uint128 _wallet) external onlyTeam {
}
function setExemptFromFees(address _address) external onlyTeam {
}
function setExemptFromLimits(address _address) external onlyTeam {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapAndSendEmergency(uint256 tokens) external onlyTeam {
}
}
| game[numberOfGame].gameHasBegun,"The game hasn't started yet" | 203,520 | game[numberOfGame].gameHasBegun |
"there are no bets" | /*
Halloween coin with a lottery system and possibility of winning up to 10x your bet.
https://t.me/HalloweenCerc20
twitter.com/HalloweenCerc20
https://halloweencoinerc20.com
.
//
_.-"""""'//-'""""-._
.', , , , : : ` ` ` `.
/ , , \'-._ : :_.-'/ ` ` \
/ , , :\(_)\ /(_)/ : ` ` \
| , , , \__//\\__/ . . ` ` |
| . .:_ : : '--`: : . _: ; :|
| : : \\_ _' : _: :__// , , |
\ ` ` \ \/ \/\/ \_/ / , , /
\ ` ` \_/\_/\_/\_/\/ , , /
`._ ` . : : : , , _.'
`-..............-'
*/
pragma solidity ^0.8.0;
contract TreatToken is ERC20, VRFConsumerBaseV2, ConfirmedOwner {
// ======================== VRF ========================
event RequestSent(uint256 requestId, uint32 numWords);
event RequestFulfilled(uint256 requestId, uint256 randomWords);
struct RequestStatus {
bool fulfilled;
bool exists;
uint256 randomWords;
}
mapping(uint256 => RequestStatus) public s_requests;
VRFCoordinatorV2Interface COORDINATOR;
uint64 s_subscriptionId;
bytes32 keyHash =
0x9fe0eebf5e446e3c998ec9bb19951541aee00bb90ea201ae456421a2ded86805;
uint32 callbackGasLimit = 100000;
// The default is 3, but you can set this higher.
uint16 requestConfirmations = 3;
uint32 numWords = 1;
// ======================== GAME STRUCTURE ========================
struct Game {
uint256 startTime; // start of the game
uint256 endBet; //timestamp where they can no longer bet
uint256 claimBegin; //timestamp from which they can claim
uint256 claimDuration; //timestamp for claim
uint256 endClaim; //timestamp up to which they can claim
uint256 idOfTheGame;
bool gameHasBegun;
uint16 numberOfDoor;
bool doorHasBeenGenerated;
uint256 totalBets;
uint256 totalBetDoor1;
uint256 totalBetDoor2;
uint256 totalBetDoor3;
uint256 _multiplicator;
}
uint16 public numberOfGame;
mapping(uint16 => Game) public game;
mapping(uint16 => uint256) private resultOfGame;
event Bet(address indexed user, uint256 amount);
event DoorGeneration(uint256 indexed requestId);
event DoorGenerated(uint256 indexed requestId, uint256 result);
// ======================== USER STRUCTURE ========================
struct User {
uint256 bet;
uint256 totalBet;
uint16 chosenDoor;
bool openedDoor;
bool win;
uint256 earned;
uint256 totalEarned;
}
mapping(address => mapping(uint16 => User)) public userInfos;
// ======================== TAXES & LIMITS ========================
mapping(address => bool) public exemptFromFees;
mapping(address => bool) public exemptFromLimits;
uint128 public transactionLimit = 26_000e18;
uint128 public walletLimit = 26_000e18;
uint48 buyTax = 5;
uint48 sellTax = 5;
uint48 earlyTax = 19;
uint64 public constant FEE_DIVISOR = 100;
uint256 public _buyCount;
uint256 public swapTokensAmount = 5000e18;
// ======================== TOKEN ========================
uint256 maxTime = type(uint256).max / 2;
address team;
uint256 constant _initial_supply = 1000000 * (10 ** 18);
bool tradingOpen;
address public lpPair;
IDexRouter public dexRouter;
mapping(address => bool) public isAMMPair;
// ======================== CONSTRUCTOR ========================
constructor(
uint64 subscriptionId
)
ERC20("Halloween Coin", "TREAT")
VRFConsumerBaseV2(0x271682DEB8C4E0901D1a1550aD2e64D568E69909)
ConfirmedOwner(msg.sender)
{
}
modifier onlyTeam() {
}
receive() external payable {}
function setGame(
uint256 _bettingDuration,
uint256 _claimingDuration,
uint16 _numberOfDoor,
uint256 _multipe
) external onlyTeam {
}
function placeBet(uint256 _betAmount, uint16 _door) external {
}
function getPercentage() public view returns (uint256, uint256, uint256) {
require(<FILL_ME>)
uint256 total = game[numberOfGame].totalBets;
return (
(game[numberOfGame].totalBetDoor1 * 100) / total,
(game[numberOfGame].totalBetDoor2 * 100) / total,
(game[numberOfGame].totalBetDoor3 * 100) / total
);
}
function generateRandomDoor()
external
onlyTeam
returns (uint256 requestId)
{
}
function fulfillRandomWords(
uint256 requestId,
uint256[] memory randomWords
) internal override {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function sendTeamCall() private {
}
// view the reward before
function viewResult(uint16 _game) public view returns (uint256) {
}
function openDoor() external {
}
function getResult(
address _address,
uint16 _game
) public view returns (bool _didWin, uint256 _earned) {
}
// view if a user has already claimed for a given game
function hasAlreadyClaimed(
address _user,
uint16 _gameNumber
) public view returns (bool) {
}
// view for a given game the amount of a user's bet and the gate chosen
function getBetAndDoor(
address _user,
uint16 _gameNumber
) public view returns (uint256, uint256) {
}
function getStateOfTheGame() public view returns (uint16 _state) {
}
function updateTaxesFees(uint48 _buy, uint48 _sell) external onlyTeam {
}
function updateSwapTokensAmount(uint256 _newAmount) external onlyTeam {
}
function enableTrading() external onlyTeam {
}
function updateLimits(uint128 _tx, uint128 _wallet) external onlyTeam {
}
function setExemptFromFees(address _address) external onlyTeam {
}
function setExemptFromLimits(address _address) external onlyTeam {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapAndSendEmergency(uint256 tokens) external onlyTeam {
}
}
| game[numberOfGame].totalBets>0,"there are no bets" | 203,520 | game[numberOfGame].totalBets>0 |
"the door has already been generated" | /*
Halloween coin with a lottery system and possibility of winning up to 10x your bet.
https://t.me/HalloweenCerc20
twitter.com/HalloweenCerc20
https://halloweencoinerc20.com
.
//
_.-"""""'//-'""""-._
.', , , , : : ` ` ` `.
/ , , \'-._ : :_.-'/ ` ` \
/ , , :\(_)\ /(_)/ : ` ` \
| , , , \__//\\__/ . . ` ` |
| . .:_ : : '--`: : . _: ; :|
| : : \\_ _' : _: :__// , , |
\ ` ` \ \/ \/\/ \_/ / , , /
\ ` ` \_/\_/\_/\_/\/ , , /
`._ ` . : : : , , _.'
`-..............-'
*/
pragma solidity ^0.8.0;
contract TreatToken is ERC20, VRFConsumerBaseV2, ConfirmedOwner {
// ======================== VRF ========================
event RequestSent(uint256 requestId, uint32 numWords);
event RequestFulfilled(uint256 requestId, uint256 randomWords);
struct RequestStatus {
bool fulfilled;
bool exists;
uint256 randomWords;
}
mapping(uint256 => RequestStatus) public s_requests;
VRFCoordinatorV2Interface COORDINATOR;
uint64 s_subscriptionId;
bytes32 keyHash =
0x9fe0eebf5e446e3c998ec9bb19951541aee00bb90ea201ae456421a2ded86805;
uint32 callbackGasLimit = 100000;
// The default is 3, but you can set this higher.
uint16 requestConfirmations = 3;
uint32 numWords = 1;
// ======================== GAME STRUCTURE ========================
struct Game {
uint256 startTime; // start of the game
uint256 endBet; //timestamp where they can no longer bet
uint256 claimBegin; //timestamp from which they can claim
uint256 claimDuration; //timestamp for claim
uint256 endClaim; //timestamp up to which they can claim
uint256 idOfTheGame;
bool gameHasBegun;
uint16 numberOfDoor;
bool doorHasBeenGenerated;
uint256 totalBets;
uint256 totalBetDoor1;
uint256 totalBetDoor2;
uint256 totalBetDoor3;
uint256 _multiplicator;
}
uint16 public numberOfGame;
mapping(uint16 => Game) public game;
mapping(uint16 => uint256) private resultOfGame;
event Bet(address indexed user, uint256 amount);
event DoorGeneration(uint256 indexed requestId);
event DoorGenerated(uint256 indexed requestId, uint256 result);
// ======================== USER STRUCTURE ========================
struct User {
uint256 bet;
uint256 totalBet;
uint16 chosenDoor;
bool openedDoor;
bool win;
uint256 earned;
uint256 totalEarned;
}
mapping(address => mapping(uint16 => User)) public userInfos;
// ======================== TAXES & LIMITS ========================
mapping(address => bool) public exemptFromFees;
mapping(address => bool) public exemptFromLimits;
uint128 public transactionLimit = 26_000e18;
uint128 public walletLimit = 26_000e18;
uint48 buyTax = 5;
uint48 sellTax = 5;
uint48 earlyTax = 19;
uint64 public constant FEE_DIVISOR = 100;
uint256 public _buyCount;
uint256 public swapTokensAmount = 5000e18;
// ======================== TOKEN ========================
uint256 maxTime = type(uint256).max / 2;
address team;
uint256 constant _initial_supply = 1000000 * (10 ** 18);
bool tradingOpen;
address public lpPair;
IDexRouter public dexRouter;
mapping(address => bool) public isAMMPair;
// ======================== CONSTRUCTOR ========================
constructor(
uint64 subscriptionId
)
ERC20("Halloween Coin", "TREAT")
VRFConsumerBaseV2(0x271682DEB8C4E0901D1a1550aD2e64D568E69909)
ConfirmedOwner(msg.sender)
{
}
modifier onlyTeam() {
}
receive() external payable {}
function setGame(
uint256 _bettingDuration,
uint256 _claimingDuration,
uint16 _numberOfDoor,
uint256 _multipe
) external onlyTeam {
}
function placeBet(uint256 _betAmount, uint16 _door) external {
}
function getPercentage() public view returns (uint256, uint256, uint256) {
}
function generateRandomDoor()
external
onlyTeam
returns (uint256 requestId)
{
require(game[numberOfGame].gameHasBegun, "The game hasn't started yet");
require(
block.timestamp > game[numberOfGame].endBet,
"users can still place bets"
);
require(<FILL_ME>)
requestId = COORDINATOR.requestRandomWords(
keyHash,
s_subscriptionId,
requestConfirmations,
callbackGasLimit,
numWords
);
game[numberOfGame].claimBegin = block.timestamp + 360; // wait 6 minutes
game[numberOfGame].endClaim =
game[numberOfGame].claimBegin +
game[numberOfGame].claimDuration;
game[numberOfGame].idOfTheGame = requestId;
game[numberOfGame].doorHasBeenGenerated = true;
emit DoorGeneration(requestId);
}
function fulfillRandomWords(
uint256 requestId,
uint256[] memory randomWords
) internal override {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function sendTeamCall() private {
}
// view the reward before
function viewResult(uint16 _game) public view returns (uint256) {
}
function openDoor() external {
}
function getResult(
address _address,
uint16 _game
) public view returns (bool _didWin, uint256 _earned) {
}
// view if a user has already claimed for a given game
function hasAlreadyClaimed(
address _user,
uint16 _gameNumber
) public view returns (bool) {
}
// view for a given game the amount of a user's bet and the gate chosen
function getBetAndDoor(
address _user,
uint16 _gameNumber
) public view returns (uint256, uint256) {
}
function getStateOfTheGame() public view returns (uint16 _state) {
}
function updateTaxesFees(uint48 _buy, uint48 _sell) external onlyTeam {
}
function updateSwapTokensAmount(uint256 _newAmount) external onlyTeam {
}
function enableTrading() external onlyTeam {
}
function updateLimits(uint128 _tx, uint128 _wallet) external onlyTeam {
}
function setExemptFromFees(address _address) external onlyTeam {
}
function setExemptFromLimits(address _address) external onlyTeam {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapAndSendEmergency(uint256 tokens) external onlyTeam {
}
}
| !game[numberOfGame].doorHasBeenGenerated,"the door has already been generated" | 203,520 | !game[numberOfGame].doorHasBeenGenerated |
"Max Wallet" | /*
Halloween coin with a lottery system and possibility of winning up to 10x your bet.
https://t.me/HalloweenCerc20
twitter.com/HalloweenCerc20
https://halloweencoinerc20.com
.
//
_.-"""""'//-'""""-._
.', , , , : : ` ` ` `.
/ , , \'-._ : :_.-'/ ` ` \
/ , , :\(_)\ /(_)/ : ` ` \
| , , , \__//\\__/ . . ` ` |
| . .:_ : : '--`: : . _: ; :|
| : : \\_ _' : _: :__// , , |
\ ` ` \ \/ \/\/ \_/ / , , /
\ ` ` \_/\_/\_/\_/\/ , , /
`._ ` . : : : , , _.'
`-..............-'
*/
pragma solidity ^0.8.0;
contract TreatToken is ERC20, VRFConsumerBaseV2, ConfirmedOwner {
// ======================== VRF ========================
event RequestSent(uint256 requestId, uint32 numWords);
event RequestFulfilled(uint256 requestId, uint256 randomWords);
struct RequestStatus {
bool fulfilled;
bool exists;
uint256 randomWords;
}
mapping(uint256 => RequestStatus) public s_requests;
VRFCoordinatorV2Interface COORDINATOR;
uint64 s_subscriptionId;
bytes32 keyHash =
0x9fe0eebf5e446e3c998ec9bb19951541aee00bb90ea201ae456421a2ded86805;
uint32 callbackGasLimit = 100000;
// The default is 3, but you can set this higher.
uint16 requestConfirmations = 3;
uint32 numWords = 1;
// ======================== GAME STRUCTURE ========================
struct Game {
uint256 startTime; // start of the game
uint256 endBet; //timestamp where they can no longer bet
uint256 claimBegin; //timestamp from which they can claim
uint256 claimDuration; //timestamp for claim
uint256 endClaim; //timestamp up to which they can claim
uint256 idOfTheGame;
bool gameHasBegun;
uint16 numberOfDoor;
bool doorHasBeenGenerated;
uint256 totalBets;
uint256 totalBetDoor1;
uint256 totalBetDoor2;
uint256 totalBetDoor3;
uint256 _multiplicator;
}
uint16 public numberOfGame;
mapping(uint16 => Game) public game;
mapping(uint16 => uint256) private resultOfGame;
event Bet(address indexed user, uint256 amount);
event DoorGeneration(uint256 indexed requestId);
event DoorGenerated(uint256 indexed requestId, uint256 result);
// ======================== USER STRUCTURE ========================
struct User {
uint256 bet;
uint256 totalBet;
uint16 chosenDoor;
bool openedDoor;
bool win;
uint256 earned;
uint256 totalEarned;
}
mapping(address => mapping(uint16 => User)) public userInfos;
// ======================== TAXES & LIMITS ========================
mapping(address => bool) public exemptFromFees;
mapping(address => bool) public exemptFromLimits;
uint128 public transactionLimit = 26_000e18;
uint128 public walletLimit = 26_000e18;
uint48 buyTax = 5;
uint48 sellTax = 5;
uint48 earlyTax = 19;
uint64 public constant FEE_DIVISOR = 100;
uint256 public _buyCount;
uint256 public swapTokensAmount = 5000e18;
// ======================== TOKEN ========================
uint256 maxTime = type(uint256).max / 2;
address team;
uint256 constant _initial_supply = 1000000 * (10 ** 18);
bool tradingOpen;
address public lpPair;
IDexRouter public dexRouter;
mapping(address => bool) public isAMMPair;
// ======================== CONSTRUCTOR ========================
constructor(
uint64 subscriptionId
)
ERC20("Halloween Coin", "TREAT")
VRFConsumerBaseV2(0x271682DEB8C4E0901D1a1550aD2e64D568E69909)
ConfirmedOwner(msg.sender)
{
}
modifier onlyTeam() {
}
receive() external payable {}
function setGame(
uint256 _bettingDuration,
uint256 _claimingDuration,
uint16 _numberOfDoor,
uint256 _multipe
) external onlyTeam {
}
function placeBet(uint256 _betAmount, uint16 _door) external {
}
function getPercentage() public view returns (uint256, uint256, uint256) {
}
function generateRandomDoor()
external
onlyTeam
returns (uint256 requestId)
{
}
function fulfillRandomWords(
uint256 requestId,
uint256[] memory randomWords
) internal override {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
if (!exemptFromFees[from] && !exemptFromFees[to]) {
require(tradingOpen, "Trading is not open yet");
uint128 tax = 0;
bool sell;
//buy
if (isAMMPair[from]) {
require(
amount <= transactionLimit &&
amount + balanceOf(to) <= walletLimit,
"amount too high"
);
if (_buyCount <= 20) {
tax = earlyTax;
} else {
tax = buyTax;
}
_buyCount++;
}
// sell
else if (isAMMPair[to]) {
require(amount <= transactionLimit, "amount too high");
sell = true;
if (_buyCount <= 20) {
tax = earlyTax;
} else {
tax = sellTax;
}
}
// transfer
else {
require(<FILL_ME>)
}
uint256 taxAmount = (amount * tax) / FEE_DIVISOR;
amount -= taxAmount;
super._transfer(from, address(this), taxAmount);
if (sell && balanceOf(address(this)) > swapTokensAmount) {
sendTeamCall();
}
}
super._transfer(from, to, amount);
}
function sendTeamCall() private {
}
// view the reward before
function viewResult(uint16 _game) public view returns (uint256) {
}
function openDoor() external {
}
function getResult(
address _address,
uint16 _game
) public view returns (bool _didWin, uint256 _earned) {
}
// view if a user has already claimed for a given game
function hasAlreadyClaimed(
address _user,
uint16 _gameNumber
) public view returns (bool) {
}
// view for a given game the amount of a user's bet and the gate chosen
function getBetAndDoor(
address _user,
uint16 _gameNumber
) public view returns (uint256, uint256) {
}
function getStateOfTheGame() public view returns (uint16 _state) {
}
function updateTaxesFees(uint48 _buy, uint48 _sell) external onlyTeam {
}
function updateSwapTokensAmount(uint256 _newAmount) external onlyTeam {
}
function enableTrading() external onlyTeam {
}
function updateLimits(uint128 _tx, uint128 _wallet) external onlyTeam {
}
function setExemptFromFees(address _address) external onlyTeam {
}
function setExemptFromLimits(address _address) external onlyTeam {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapAndSendEmergency(uint256 tokens) external onlyTeam {
}
}
| amount+balanceOf(to)<=walletLimit,"Max Wallet" | 203,520 | amount+balanceOf(to)<=walletLimit |
"user has already opened the door" | /*
Halloween coin with a lottery system and possibility of winning up to 10x your bet.
https://t.me/HalloweenCerc20
twitter.com/HalloweenCerc20
https://halloweencoinerc20.com
.
//
_.-"""""'//-'""""-._
.', , , , : : ` ` ` `.
/ , , \'-._ : :_.-'/ ` ` \
/ , , :\(_)\ /(_)/ : ` ` \
| , , , \__//\\__/ . . ` ` |
| . .:_ : : '--`: : . _: ; :|
| : : \\_ _' : _: :__// , , |
\ ` ` \ \/ \/\/ \_/ / , , /
\ ` ` \_/\_/\_/\_/\/ , , /
`._ ` . : : : , , _.'
`-..............-'
*/
pragma solidity ^0.8.0;
contract TreatToken is ERC20, VRFConsumerBaseV2, ConfirmedOwner {
// ======================== VRF ========================
event RequestSent(uint256 requestId, uint32 numWords);
event RequestFulfilled(uint256 requestId, uint256 randomWords);
struct RequestStatus {
bool fulfilled;
bool exists;
uint256 randomWords;
}
mapping(uint256 => RequestStatus) public s_requests;
VRFCoordinatorV2Interface COORDINATOR;
uint64 s_subscriptionId;
bytes32 keyHash =
0x9fe0eebf5e446e3c998ec9bb19951541aee00bb90ea201ae456421a2ded86805;
uint32 callbackGasLimit = 100000;
// The default is 3, but you can set this higher.
uint16 requestConfirmations = 3;
uint32 numWords = 1;
// ======================== GAME STRUCTURE ========================
struct Game {
uint256 startTime; // start of the game
uint256 endBet; //timestamp where they can no longer bet
uint256 claimBegin; //timestamp from which they can claim
uint256 claimDuration; //timestamp for claim
uint256 endClaim; //timestamp up to which they can claim
uint256 idOfTheGame;
bool gameHasBegun;
uint16 numberOfDoor;
bool doorHasBeenGenerated;
uint256 totalBets;
uint256 totalBetDoor1;
uint256 totalBetDoor2;
uint256 totalBetDoor3;
uint256 _multiplicator;
}
uint16 public numberOfGame;
mapping(uint16 => Game) public game;
mapping(uint16 => uint256) private resultOfGame;
event Bet(address indexed user, uint256 amount);
event DoorGeneration(uint256 indexed requestId);
event DoorGenerated(uint256 indexed requestId, uint256 result);
// ======================== USER STRUCTURE ========================
struct User {
uint256 bet;
uint256 totalBet;
uint16 chosenDoor;
bool openedDoor;
bool win;
uint256 earned;
uint256 totalEarned;
}
mapping(address => mapping(uint16 => User)) public userInfos;
// ======================== TAXES & LIMITS ========================
mapping(address => bool) public exemptFromFees;
mapping(address => bool) public exemptFromLimits;
uint128 public transactionLimit = 26_000e18;
uint128 public walletLimit = 26_000e18;
uint48 buyTax = 5;
uint48 sellTax = 5;
uint48 earlyTax = 19;
uint64 public constant FEE_DIVISOR = 100;
uint256 public _buyCount;
uint256 public swapTokensAmount = 5000e18;
// ======================== TOKEN ========================
uint256 maxTime = type(uint256).max / 2;
address team;
uint256 constant _initial_supply = 1000000 * (10 ** 18);
bool tradingOpen;
address public lpPair;
IDexRouter public dexRouter;
mapping(address => bool) public isAMMPair;
// ======================== CONSTRUCTOR ========================
constructor(
uint64 subscriptionId
)
ERC20("Halloween Coin", "TREAT")
VRFConsumerBaseV2(0x271682DEB8C4E0901D1a1550aD2e64D568E69909)
ConfirmedOwner(msg.sender)
{
}
modifier onlyTeam() {
}
receive() external payable {}
function setGame(
uint256 _bettingDuration,
uint256 _claimingDuration,
uint16 _numberOfDoor,
uint256 _multipe
) external onlyTeam {
}
function placeBet(uint256 _betAmount, uint16 _door) external {
}
function getPercentage() public view returns (uint256, uint256, uint256) {
}
function generateRandomDoor()
external
onlyTeam
returns (uint256 requestId)
{
}
function fulfillRandomWords(
uint256 requestId,
uint256[] memory randomWords
) internal override {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function sendTeamCall() private {
}
// view the reward before
function viewResult(uint16 _game) public view returns (uint256) {
}
function openDoor() external {
require(<FILL_ME>)
require(
block.timestamp > game[numberOfGame].claimBegin &&
block.timestamp < game[numberOfGame].endClaim,
"you can't claim right now"
);
userInfos[msg.sender][numberOfGame].openedDoor = true;
if (
userInfos[msg.sender][numberOfGame].chosenDoor ==
resultOfGame[numberOfGame]
) {
uint256 mutiplicator = game[numberOfGame]._multiplicator;
userInfos[msg.sender][numberOfGame].win = true;
uint256 _earn = mutiplicator *
userInfos[msg.sender][numberOfGame].bet;
userInfos[msg.sender][numberOfGame].earned = _earn;
userInfos[msg.sender][numberOfGame].totalEarned += _earn;
_mint(msg.sender, _earn);
}
}
function getResult(
address _address,
uint16 _game
) public view returns (bool _didWin, uint256 _earned) {
}
// view if a user has already claimed for a given game
function hasAlreadyClaimed(
address _user,
uint16 _gameNumber
) public view returns (bool) {
}
// view for a given game the amount of a user's bet and the gate chosen
function getBetAndDoor(
address _user,
uint16 _gameNumber
) public view returns (uint256, uint256) {
}
function getStateOfTheGame() public view returns (uint16 _state) {
}
function updateTaxesFees(uint48 _buy, uint48 _sell) external onlyTeam {
}
function updateSwapTokensAmount(uint256 _newAmount) external onlyTeam {
}
function enableTrading() external onlyTeam {
}
function updateLimits(uint128 _tx, uint128 _wallet) external onlyTeam {
}
function setExemptFromFees(address _address) external onlyTeam {
}
function setExemptFromLimits(address _address) external onlyTeam {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapAndSendEmergency(uint256 tokens) external onlyTeam {
}
}
| !userInfos[msg.sender][numberOfGame].openedDoor,"user has already opened the door" | 203,520 | !userInfos[msg.sender][numberOfGame].openedDoor |
"Randomness not ready" | pragma solidity >=0.4.22 <0.9.0;
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
contract Randomness is VRFConsumerBaseV2, Ownable {
struct RandomnessRequest {
uint256[] randomWords;
bool requested;
bool fulfilled;
}
struct config {
bytes32 keyHash;
uint64 subscription;
uint16 confirmations;
uint32 gasLimit;
uint32 numWords;
}
event RandomNumberRequested(bytes32 entity, uint256 requestId);
event RandomNumberGenerated(bytes32 entity, uint256 requestId, uint256[] randomness);
bytes32 internal _keyHash;
uint64 internal _subscription;
config private _defaultConfig;
mapping(bytes32 => RandomnessRequest) internal _randomRequests;
mapping(uint256 => bytes32) internal _randomRequestByChainLinkId;
address internal _vrfCoordinator;
constructor(address vrfCoordinator_) Ownable() VRFConsumerBaseV2(vrfCoordinator_) {
}
function configure(bytes32 keyHash, uint64 sub, uint16 confirms, uint32 gasLimit, uint32 words) onlyOwner public {
}
function setDefaults(bytes32 keyHash_, uint64 sub_, uint16 confirms_, uint32 gasLimit_, uint32 words_) onlyOwner public {
}
function readRandomness(bytes32 entity) public view returns(uint256[] memory randomness) {
}
function getRandomness(bytes32 entity) public view returns(uint256[] memory randomness) {
require(<FILL_ME>)
return _randomRequests[ entity ].randomWords;
}
function getRandomnessByRequestId(uint256 requestId) public view returns(uint256[] memory randomness) {
}
function requestRandomness(bytes32 entity) onlyOwner public virtual {
}
function requestRandomness(bytes32 entity, bytes32 keyHash, uint64 sub, uint16 confirms, uint32 gasLimit, uint32 words) onlyOwner public {
}
function _requestRandomness(bytes32 entity, bytes32 keyHash, uint64 sub, uint16 confirms, uint32 gasLimit, uint32 words) internal returns(uint256) {
}
function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords) internal virtual override {
}
}
| _randomRequests[entity].fulfilled,"Randomness not ready" | 203,600 | _randomRequests[entity].fulfilled |
"Unknown request" | pragma solidity >=0.4.22 <0.9.0;
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
contract Randomness is VRFConsumerBaseV2, Ownable {
struct RandomnessRequest {
uint256[] randomWords;
bool requested;
bool fulfilled;
}
struct config {
bytes32 keyHash;
uint64 subscription;
uint16 confirmations;
uint32 gasLimit;
uint32 numWords;
}
event RandomNumberRequested(bytes32 entity, uint256 requestId);
event RandomNumberGenerated(bytes32 entity, uint256 requestId, uint256[] randomness);
bytes32 internal _keyHash;
uint64 internal _subscription;
config private _defaultConfig;
mapping(bytes32 => RandomnessRequest) internal _randomRequests;
mapping(uint256 => bytes32) internal _randomRequestByChainLinkId;
address internal _vrfCoordinator;
constructor(address vrfCoordinator_) Ownable() VRFConsumerBaseV2(vrfCoordinator_) {
}
function configure(bytes32 keyHash, uint64 sub, uint16 confirms, uint32 gasLimit, uint32 words) onlyOwner public {
}
function setDefaults(bytes32 keyHash_, uint64 sub_, uint16 confirms_, uint32 gasLimit_, uint32 words_) onlyOwner public {
}
function readRandomness(bytes32 entity) public view returns(uint256[] memory randomness) {
}
function getRandomness(bytes32 entity) public view returns(uint256[] memory randomness) {
}
function getRandomnessByRequestId(uint256 requestId) public view returns(uint256[] memory randomness) {
require(<FILL_ME>)
return getRandomness(_randomRequestByChainLinkId[ requestId ]);
}
function requestRandomness(bytes32 entity) onlyOwner public virtual {
}
function requestRandomness(bytes32 entity, bytes32 keyHash, uint64 sub, uint16 confirms, uint32 gasLimit, uint32 words) onlyOwner public {
}
function _requestRandomness(bytes32 entity, bytes32 keyHash, uint64 sub, uint16 confirms, uint32 gasLimit, uint32 words) internal returns(uint256) {
}
function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords) internal virtual override {
}
}
| _randomRequestByChainLinkId[requestId]!=0x0,"Unknown request" | 203,600 | _randomRequestByChainLinkId[requestId]!=0x0 |
"A random number was already request for the given entity." | pragma solidity >=0.4.22 <0.9.0;
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
contract Randomness is VRFConsumerBaseV2, Ownable {
struct RandomnessRequest {
uint256[] randomWords;
bool requested;
bool fulfilled;
}
struct config {
bytes32 keyHash;
uint64 subscription;
uint16 confirmations;
uint32 gasLimit;
uint32 numWords;
}
event RandomNumberRequested(bytes32 entity, uint256 requestId);
event RandomNumberGenerated(bytes32 entity, uint256 requestId, uint256[] randomness);
bytes32 internal _keyHash;
uint64 internal _subscription;
config private _defaultConfig;
mapping(bytes32 => RandomnessRequest) internal _randomRequests;
mapping(uint256 => bytes32) internal _randomRequestByChainLinkId;
address internal _vrfCoordinator;
constructor(address vrfCoordinator_) Ownable() VRFConsumerBaseV2(vrfCoordinator_) {
}
function configure(bytes32 keyHash, uint64 sub, uint16 confirms, uint32 gasLimit, uint32 words) onlyOwner public {
}
function setDefaults(bytes32 keyHash_, uint64 sub_, uint16 confirms_, uint32 gasLimit_, uint32 words_) onlyOwner public {
}
function readRandomness(bytes32 entity) public view returns(uint256[] memory randomness) {
}
function getRandomness(bytes32 entity) public view returns(uint256[] memory randomness) {
}
function getRandomnessByRequestId(uint256 requestId) public view returns(uint256[] memory randomness) {
}
function requestRandomness(bytes32 entity) onlyOwner public virtual {
}
function requestRandomness(bytes32 entity, bytes32 keyHash, uint64 sub, uint16 confirms, uint32 gasLimit, uint32 words) onlyOwner public {
}
function _requestRandomness(bytes32 entity, bytes32 keyHash, uint64 sub, uint16 confirms, uint32 gasLimit, uint32 words) internal returns(uint256) {
require(<FILL_ME>)
uint256 requestId = VRFCoordinatorV2Interface(_vrfCoordinator).requestRandomWords(
keyHash,
sub,
confirms,
gasLimit,
words
);
_randomRequests[ entity ].requested = true;
_randomRequestByChainLinkId[ requestId ] = entity;
emit RandomNumberRequested(entity, requestId);
return requestId;
}
function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords) internal virtual override {
}
}
| !_randomRequests[entity].requested,"A random number was already request for the given entity." | 203,600 | !_randomRequests[entity].requested |
"Not enough free mints available" | pragma solidity ^0.8.0;
contract Spellbound is Ownable, ERC721A {
// constants
uint256 constant FREE_MINTS = 1500;
uint256 constant MAX_ELEMENTS = 3333;
uint256 constant MAX_ELEMENTS_ONE_TIME = 5;
uint256 constant PUBLIC_PRICE = 0.005 ether;
// state variable
string public baseTokenURI = "ipfs://QmcRu5LKwmJVSa7W4Np3E8nkfCvDg6RLn5sEz61uXxKQAG/";
constructor(uint256 maxBatchSize_) ERC721A("Spellbound", "SPELL", maxBatchSize_) {}
function mint(uint256 _mintAmount) public payable {
uint256 supply = totalSupply();
require(_mintAmount > 0,"You should mint more than zero.");
require(_mintAmount <= MAX_ELEMENTS_ONE_TIME,"You cannot mint more than 5 at a time.");
if(supply < FREE_MINTS){
require(<FILL_ME>)
_safeMint(msg.sender,_mintAmount);
} else {
require(supply + _mintAmount <= MAX_ELEMENTS,"All gone!");
require(msg.value >= _mintAmount * PUBLIC_PRICE,"Wrong value, change your eth value");
_safeMint(msg.sender,_mintAmount);
}
}
function withdraw() public payable onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) public onlyOwner {
}
}
| supply+_mintAmount<=FREE_MINTS,"Not enough free mints available" | 203,739 | supply+_mintAmount<=FREE_MINTS |
"Contract already initialized!" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./HDY721.sol";
contract Marketplace is Ownable, ReentrancyGuard{
uint256 public royaltyFee;
address public platformAddress;
address public NFTAddress;
//the denominator is used to calculate so the result will not return 0 if we
//want to calculate the value that have a point(.) ex: 2.5 * 2
uint256 denominator = 10000;
mapping (address => bool) public statusAdmin;
mapping (uint256 => bool) public statusNFT;
struct Sig{bytes32 r; bytes32 s; uint8 v;}
event SellEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp);
event BuyEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp, bytes transferData);
event CancelSellEvent(address Caller, uint256 TokenID, string transactionID, uint256 TimeStamp);
event LowingPriceEvent(address Caller, uint256 TokenID, uint256 NewPrice, string transactionID, uint256 TimeStamp);
event BuyPackEvent(address buyerAddress, uint256 packID, uint256 amountPack, uint256 transferredAmount, string transactionID, uint256 TimeStamp, bytes transferData);
bool public Initialized;
function init(address _platformAddress, address _NFTAddress) public onlyOwner {
require(<FILL_ME>)
platformAddress = _platformAddress;
NFTAddress = _NFTAddress;
Initialized = true;
statusAdmin[_platformAddress] = true;
statusAdmin[msg.sender] = true;
setRoyaltyFee(250);
}
function buyPack(uint256 packID, uint256 amount, uint256 pricePack, string memory transactionID, Sig memory buyPackRSV) external payable initializer {
}
function sell(uint256 tokenID, uint256 price, string memory transactionID, Sig memory sellRSV) public initializer onlyNFTOwner(tokenID) {
}
function sellWithMint(uint256 tokenID, string memory collectionName, string memory tokenURI, uint256 price, string memory transactionID, HDY721.Sig memory MintRSV, Sig memory sellRSV) public initializer{
}
function buy(address seller, uint256 tokenID,uint256 price, string memory transactionID, Sig memory buyRSV) public payable initializer {
}
function cancelSell(uint256 tokenID, string memory transactionID, Sig memory cancelRSV) public initializer onlyNFTOwner(tokenID) {
}
function lowingPrice(uint256 tokenID, uint256 newPrice, string memory transactionID, Sig memory lowingPriceRSV) public initializer onlyNFTOwner(tokenID) {
}
function addAdmin(address addressAdmin) external onlyOwner initializer{
}
function updatePlatform(address newPlatform) external onlyAdmin initializer {
}
function updateNFTAddress(address nftAddress) external onlyAdmin initializer{
}
function revokeAdmin(address addressAdmin) external onlyOwner {
}
function setRoyaltyFee(uint256 newFee) public onlyAdmin initializer{
}
function getRoyaltyFee() public view returns (uint256){
}
function verifySigner(address signer, bytes32 ethSignedMessageHash, Sig memory rsv) internal pure returns (bool)
{
}
function messageHash(bytes memory abiEncode)internal pure returns (bytes32)
{
}
modifier initializer() {
}
modifier onlyAdmin() {
}
modifier onlyNFTOwner(uint256 tokenID) {
}
}
| !Initialized,"Contract already initialized!" | 203,950 | !Initialized |
"BuyPack rsv invalid" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./HDY721.sol";
contract Marketplace is Ownable, ReentrancyGuard{
uint256 public royaltyFee;
address public platformAddress;
address public NFTAddress;
//the denominator is used to calculate so the result will not return 0 if we
//want to calculate the value that have a point(.) ex: 2.5 * 2
uint256 denominator = 10000;
mapping (address => bool) public statusAdmin;
mapping (uint256 => bool) public statusNFT;
struct Sig{bytes32 r; bytes32 s; uint8 v;}
event SellEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp);
event BuyEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp, bytes transferData);
event CancelSellEvent(address Caller, uint256 TokenID, string transactionID, uint256 TimeStamp);
event LowingPriceEvent(address Caller, uint256 TokenID, uint256 NewPrice, string transactionID, uint256 TimeStamp);
event BuyPackEvent(address buyerAddress, uint256 packID, uint256 amountPack, uint256 transferredAmount, string transactionID, uint256 TimeStamp, bytes transferData);
bool public Initialized;
function init(address _platformAddress, address _NFTAddress) public onlyOwner {
}
function buyPack(uint256 packID, uint256 amount, uint256 pricePack, string memory transactionID, Sig memory buyPackRSV) external payable initializer {
require(<FILL_ME>)
require(msg.sender != address(0), "Address Invalid!");
require(pricePack == msg.value, "Transferred amount is not match with price pack!");
(bool sent, bytes memory data) = payable(platformAddress).call{value: msg.value}("");
require(sent, "Failed to send Ether");
emit BuyPackEvent(msg.sender, packID, amount, msg.value, transactionID, block.timestamp, data);
}
function sell(uint256 tokenID, uint256 price, string memory transactionID, Sig memory sellRSV) public initializer onlyNFTOwner(tokenID) {
}
function sellWithMint(uint256 tokenID, string memory collectionName, string memory tokenURI, uint256 price, string memory transactionID, HDY721.Sig memory MintRSV, Sig memory sellRSV) public initializer{
}
function buy(address seller, uint256 tokenID,uint256 price, string memory transactionID, Sig memory buyRSV) public payable initializer {
}
function cancelSell(uint256 tokenID, string memory transactionID, Sig memory cancelRSV) public initializer onlyNFTOwner(tokenID) {
}
function lowingPrice(uint256 tokenID, uint256 newPrice, string memory transactionID, Sig memory lowingPriceRSV) public initializer onlyNFTOwner(tokenID) {
}
function addAdmin(address addressAdmin) external onlyOwner initializer{
}
function updatePlatform(address newPlatform) external onlyAdmin initializer {
}
function updateNFTAddress(address nftAddress) external onlyAdmin initializer{
}
function revokeAdmin(address addressAdmin) external onlyOwner {
}
function setRoyaltyFee(uint256 newFee) public onlyAdmin initializer{
}
function getRoyaltyFee() public view returns (uint256){
}
function verifySigner(address signer, bytes32 ethSignedMessageHash, Sig memory rsv) internal pure returns (bool)
{
}
function messageHash(bytes memory abiEncode)internal pure returns (bytes32)
{
}
modifier initializer() {
}
modifier onlyAdmin() {
}
modifier onlyNFTOwner(uint256 tokenID) {
}
}
| verifySigner(platformAddress,messageHash(abi.encodePacked(msg.sender,packID,amount,pricePack,transactionID)),buyPackRSV),"BuyPack rsv invalid" | 203,950 | verifySigner(platformAddress,messageHash(abi.encodePacked(msg.sender,packID,amount,pricePack,transactionID)),buyPackRSV) |
"NFT Already selled!" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./HDY721.sol";
contract Marketplace is Ownable, ReentrancyGuard{
uint256 public royaltyFee;
address public platformAddress;
address public NFTAddress;
//the denominator is used to calculate so the result will not return 0 if we
//want to calculate the value that have a point(.) ex: 2.5 * 2
uint256 denominator = 10000;
mapping (address => bool) public statusAdmin;
mapping (uint256 => bool) public statusNFT;
struct Sig{bytes32 r; bytes32 s; uint8 v;}
event SellEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp);
event BuyEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp, bytes transferData);
event CancelSellEvent(address Caller, uint256 TokenID, string transactionID, uint256 TimeStamp);
event LowingPriceEvent(address Caller, uint256 TokenID, uint256 NewPrice, string transactionID, uint256 TimeStamp);
event BuyPackEvent(address buyerAddress, uint256 packID, uint256 amountPack, uint256 transferredAmount, string transactionID, uint256 TimeStamp, bytes transferData);
bool public Initialized;
function init(address _platformAddress, address _NFTAddress) public onlyOwner {
}
function buyPack(uint256 packID, uint256 amount, uint256 pricePack, string memory transactionID, Sig memory buyPackRSV) external payable initializer {
}
function sell(uint256 tokenID, uint256 price, string memory transactionID, Sig memory sellRSV) public initializer onlyNFTOwner(tokenID) {
require(<FILL_ME>)
require(verifySigner(platformAddress, messageHash(abi.encodePacked(msg.sender, tokenID, price, transactionID)), sellRSV), "Sell rsv invalid");
statusNFT[tokenID] = true;
HDY721(NFTAddress).setPriceNFT(msg.sender, tokenID, price);
emit SellEvent(msg.sender, tokenID, price, transactionID, block.timestamp);
}
function sellWithMint(uint256 tokenID, string memory collectionName, string memory tokenURI, uint256 price, string memory transactionID, HDY721.Sig memory MintRSV, Sig memory sellRSV) public initializer{
}
function buy(address seller, uint256 tokenID,uint256 price, string memory transactionID, Sig memory buyRSV) public payable initializer {
}
function cancelSell(uint256 tokenID, string memory transactionID, Sig memory cancelRSV) public initializer onlyNFTOwner(tokenID) {
}
function lowingPrice(uint256 tokenID, uint256 newPrice, string memory transactionID, Sig memory lowingPriceRSV) public initializer onlyNFTOwner(tokenID) {
}
function addAdmin(address addressAdmin) external onlyOwner initializer{
}
function updatePlatform(address newPlatform) external onlyAdmin initializer {
}
function updateNFTAddress(address nftAddress) external onlyAdmin initializer{
}
function revokeAdmin(address addressAdmin) external onlyOwner {
}
function setRoyaltyFee(uint256 newFee) public onlyAdmin initializer{
}
function getRoyaltyFee() public view returns (uint256){
}
function verifySigner(address signer, bytes32 ethSignedMessageHash, Sig memory rsv) internal pure returns (bool)
{
}
function messageHash(bytes memory abiEncode)internal pure returns (bytes32)
{
}
modifier initializer() {
}
modifier onlyAdmin() {
}
modifier onlyNFTOwner(uint256 tokenID) {
}
}
| statusNFT[tokenID]!=true,"NFT Already selled!" | 203,950 | statusNFT[tokenID]!=true |
"Sell rsv invalid" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./HDY721.sol";
contract Marketplace is Ownable, ReentrancyGuard{
uint256 public royaltyFee;
address public platformAddress;
address public NFTAddress;
//the denominator is used to calculate so the result will not return 0 if we
//want to calculate the value that have a point(.) ex: 2.5 * 2
uint256 denominator = 10000;
mapping (address => bool) public statusAdmin;
mapping (uint256 => bool) public statusNFT;
struct Sig{bytes32 r; bytes32 s; uint8 v;}
event SellEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp);
event BuyEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp, bytes transferData);
event CancelSellEvent(address Caller, uint256 TokenID, string transactionID, uint256 TimeStamp);
event LowingPriceEvent(address Caller, uint256 TokenID, uint256 NewPrice, string transactionID, uint256 TimeStamp);
event BuyPackEvent(address buyerAddress, uint256 packID, uint256 amountPack, uint256 transferredAmount, string transactionID, uint256 TimeStamp, bytes transferData);
bool public Initialized;
function init(address _platformAddress, address _NFTAddress) public onlyOwner {
}
function buyPack(uint256 packID, uint256 amount, uint256 pricePack, string memory transactionID, Sig memory buyPackRSV) external payable initializer {
}
function sell(uint256 tokenID, uint256 price, string memory transactionID, Sig memory sellRSV) public initializer onlyNFTOwner(tokenID) {
require(statusNFT[tokenID] != true, "NFT Already selled!");
require(<FILL_ME>)
statusNFT[tokenID] = true;
HDY721(NFTAddress).setPriceNFT(msg.sender, tokenID, price);
emit SellEvent(msg.sender, tokenID, price, transactionID, block.timestamp);
}
function sellWithMint(uint256 tokenID, string memory collectionName, string memory tokenURI, uint256 price, string memory transactionID, HDY721.Sig memory MintRSV, Sig memory sellRSV) public initializer{
}
function buy(address seller, uint256 tokenID,uint256 price, string memory transactionID, Sig memory buyRSV) public payable initializer {
}
function cancelSell(uint256 tokenID, string memory transactionID, Sig memory cancelRSV) public initializer onlyNFTOwner(tokenID) {
}
function lowingPrice(uint256 tokenID, uint256 newPrice, string memory transactionID, Sig memory lowingPriceRSV) public initializer onlyNFTOwner(tokenID) {
}
function addAdmin(address addressAdmin) external onlyOwner initializer{
}
function updatePlatform(address newPlatform) external onlyAdmin initializer {
}
function updateNFTAddress(address nftAddress) external onlyAdmin initializer{
}
function revokeAdmin(address addressAdmin) external onlyOwner {
}
function setRoyaltyFee(uint256 newFee) public onlyAdmin initializer{
}
function getRoyaltyFee() public view returns (uint256){
}
function verifySigner(address signer, bytes32 ethSignedMessageHash, Sig memory rsv) internal pure returns (bool)
{
}
function messageHash(bytes memory abiEncode)internal pure returns (bytes32)
{
}
modifier initializer() {
}
modifier onlyAdmin() {
}
modifier onlyNFTOwner(uint256 tokenID) {
}
}
| verifySigner(platformAddress,messageHash(abi.encodePacked(msg.sender,tokenID,price,transactionID)),sellRSV),"Sell rsv invalid" | 203,950 | verifySigner(platformAddress,messageHash(abi.encodePacked(msg.sender,tokenID,price,transactionID)),sellRSV) |
"NFT is not listed!" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./HDY721.sol";
contract Marketplace is Ownable, ReentrancyGuard{
uint256 public royaltyFee;
address public platformAddress;
address public NFTAddress;
//the denominator is used to calculate so the result will not return 0 if we
//want to calculate the value that have a point(.) ex: 2.5 * 2
uint256 denominator = 10000;
mapping (address => bool) public statusAdmin;
mapping (uint256 => bool) public statusNFT;
struct Sig{bytes32 r; bytes32 s; uint8 v;}
event SellEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp);
event BuyEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp, bytes transferData);
event CancelSellEvent(address Caller, uint256 TokenID, string transactionID, uint256 TimeStamp);
event LowingPriceEvent(address Caller, uint256 TokenID, uint256 NewPrice, string transactionID, uint256 TimeStamp);
event BuyPackEvent(address buyerAddress, uint256 packID, uint256 amountPack, uint256 transferredAmount, string transactionID, uint256 TimeStamp, bytes transferData);
bool public Initialized;
function init(address _platformAddress, address _NFTAddress) public onlyOwner {
}
function buyPack(uint256 packID, uint256 amount, uint256 pricePack, string memory transactionID, Sig memory buyPackRSV) external payable initializer {
}
function sell(uint256 tokenID, uint256 price, string memory transactionID, Sig memory sellRSV) public initializer onlyNFTOwner(tokenID) {
}
function sellWithMint(uint256 tokenID, string memory collectionName, string memory tokenURI, uint256 price, string memory transactionID, HDY721.Sig memory MintRSV, Sig memory sellRSV) public initializer{
}
function buy(address seller, uint256 tokenID,uint256 price, string memory transactionID, Sig memory buyRSV) public payable initializer {
require(<FILL_ME>)
require(verifySigner(platformAddress, messageHash(abi.encodePacked(msg.sender, tokenID, price, transactionID)), buyRSV), "Buy rsv invalid");
require(HDY721(NFTAddress).getPriceNFT(tokenID) == price, "The amount is not match with listing price!");
require(msg.value == price, "msg.value is not matched with price!");
require(HDY721(NFTAddress).ownerOf(tokenID) != msg.sender, "You can't buy your own NFT!");
statusNFT[tokenID] = false;
uint256 fee = (msg.value * royaltyFee) / denominator;
(bool sent, bytes memory data) = payable(seller).call{value: msg.value - fee}("");
require(sent, "Failed to send Ether");
(bool feeSent, bytes memory feeData) = payable(platformAddress).call{value: fee}("");
require(feeSent, "Failed to send fee!");
HDY721(NFTAddress).safeTransferFrom(seller, msg.sender, tokenID);
emit BuyEvent(msg.sender, tokenID, price, transactionID, block.timestamp, data);
}
function cancelSell(uint256 tokenID, string memory transactionID, Sig memory cancelRSV) public initializer onlyNFTOwner(tokenID) {
}
function lowingPrice(uint256 tokenID, uint256 newPrice, string memory transactionID, Sig memory lowingPriceRSV) public initializer onlyNFTOwner(tokenID) {
}
function addAdmin(address addressAdmin) external onlyOwner initializer{
}
function updatePlatform(address newPlatform) external onlyAdmin initializer {
}
function updateNFTAddress(address nftAddress) external onlyAdmin initializer{
}
function revokeAdmin(address addressAdmin) external onlyOwner {
}
function setRoyaltyFee(uint256 newFee) public onlyAdmin initializer{
}
function getRoyaltyFee() public view returns (uint256){
}
function verifySigner(address signer, bytes32 ethSignedMessageHash, Sig memory rsv) internal pure returns (bool)
{
}
function messageHash(bytes memory abiEncode)internal pure returns (bytes32)
{
}
modifier initializer() {
}
modifier onlyAdmin() {
}
modifier onlyNFTOwner(uint256 tokenID) {
}
}
| statusNFT[tokenID],"NFT is not listed!" | 203,950 | statusNFT[tokenID] |
"Buy rsv invalid" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./HDY721.sol";
contract Marketplace is Ownable, ReentrancyGuard{
uint256 public royaltyFee;
address public platformAddress;
address public NFTAddress;
//the denominator is used to calculate so the result will not return 0 if we
//want to calculate the value that have a point(.) ex: 2.5 * 2
uint256 denominator = 10000;
mapping (address => bool) public statusAdmin;
mapping (uint256 => bool) public statusNFT;
struct Sig{bytes32 r; bytes32 s; uint8 v;}
event SellEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp);
event BuyEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp, bytes transferData);
event CancelSellEvent(address Caller, uint256 TokenID, string transactionID, uint256 TimeStamp);
event LowingPriceEvent(address Caller, uint256 TokenID, uint256 NewPrice, string transactionID, uint256 TimeStamp);
event BuyPackEvent(address buyerAddress, uint256 packID, uint256 amountPack, uint256 transferredAmount, string transactionID, uint256 TimeStamp, bytes transferData);
bool public Initialized;
function init(address _platformAddress, address _NFTAddress) public onlyOwner {
}
function buyPack(uint256 packID, uint256 amount, uint256 pricePack, string memory transactionID, Sig memory buyPackRSV) external payable initializer {
}
function sell(uint256 tokenID, uint256 price, string memory transactionID, Sig memory sellRSV) public initializer onlyNFTOwner(tokenID) {
}
function sellWithMint(uint256 tokenID, string memory collectionName, string memory tokenURI, uint256 price, string memory transactionID, HDY721.Sig memory MintRSV, Sig memory sellRSV) public initializer{
}
function buy(address seller, uint256 tokenID,uint256 price, string memory transactionID, Sig memory buyRSV) public payable initializer {
require(statusNFT[tokenID], "NFT is not listed!");
require(<FILL_ME>)
require(HDY721(NFTAddress).getPriceNFT(tokenID) == price, "The amount is not match with listing price!");
require(msg.value == price, "msg.value is not matched with price!");
require(HDY721(NFTAddress).ownerOf(tokenID) != msg.sender, "You can't buy your own NFT!");
statusNFT[tokenID] = false;
uint256 fee = (msg.value * royaltyFee) / denominator;
(bool sent, bytes memory data) = payable(seller).call{value: msg.value - fee}("");
require(sent, "Failed to send Ether");
(bool feeSent, bytes memory feeData) = payable(platformAddress).call{value: fee}("");
require(feeSent, "Failed to send fee!");
HDY721(NFTAddress).safeTransferFrom(seller, msg.sender, tokenID);
emit BuyEvent(msg.sender, tokenID, price, transactionID, block.timestamp, data);
}
function cancelSell(uint256 tokenID, string memory transactionID, Sig memory cancelRSV) public initializer onlyNFTOwner(tokenID) {
}
function lowingPrice(uint256 tokenID, uint256 newPrice, string memory transactionID, Sig memory lowingPriceRSV) public initializer onlyNFTOwner(tokenID) {
}
function addAdmin(address addressAdmin) external onlyOwner initializer{
}
function updatePlatform(address newPlatform) external onlyAdmin initializer {
}
function updateNFTAddress(address nftAddress) external onlyAdmin initializer{
}
function revokeAdmin(address addressAdmin) external onlyOwner {
}
function setRoyaltyFee(uint256 newFee) public onlyAdmin initializer{
}
function getRoyaltyFee() public view returns (uint256){
}
function verifySigner(address signer, bytes32 ethSignedMessageHash, Sig memory rsv) internal pure returns (bool)
{
}
function messageHash(bytes memory abiEncode)internal pure returns (bytes32)
{
}
modifier initializer() {
}
modifier onlyAdmin() {
}
modifier onlyNFTOwner(uint256 tokenID) {
}
}
| verifySigner(platformAddress,messageHash(abi.encodePacked(msg.sender,tokenID,price,transactionID)),buyRSV),"Buy rsv invalid" | 203,950 | verifySigner(platformAddress,messageHash(abi.encodePacked(msg.sender,tokenID,price,transactionID)),buyRSV) |
"The amount is not match with listing price!" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./HDY721.sol";
contract Marketplace is Ownable, ReentrancyGuard{
uint256 public royaltyFee;
address public platformAddress;
address public NFTAddress;
//the denominator is used to calculate so the result will not return 0 if we
//want to calculate the value that have a point(.) ex: 2.5 * 2
uint256 denominator = 10000;
mapping (address => bool) public statusAdmin;
mapping (uint256 => bool) public statusNFT;
struct Sig{bytes32 r; bytes32 s; uint8 v;}
event SellEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp);
event BuyEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp, bytes transferData);
event CancelSellEvent(address Caller, uint256 TokenID, string transactionID, uint256 TimeStamp);
event LowingPriceEvent(address Caller, uint256 TokenID, uint256 NewPrice, string transactionID, uint256 TimeStamp);
event BuyPackEvent(address buyerAddress, uint256 packID, uint256 amountPack, uint256 transferredAmount, string transactionID, uint256 TimeStamp, bytes transferData);
bool public Initialized;
function init(address _platformAddress, address _NFTAddress) public onlyOwner {
}
function buyPack(uint256 packID, uint256 amount, uint256 pricePack, string memory transactionID, Sig memory buyPackRSV) external payable initializer {
}
function sell(uint256 tokenID, uint256 price, string memory transactionID, Sig memory sellRSV) public initializer onlyNFTOwner(tokenID) {
}
function sellWithMint(uint256 tokenID, string memory collectionName, string memory tokenURI, uint256 price, string memory transactionID, HDY721.Sig memory MintRSV, Sig memory sellRSV) public initializer{
}
function buy(address seller, uint256 tokenID,uint256 price, string memory transactionID, Sig memory buyRSV) public payable initializer {
require(statusNFT[tokenID], "NFT is not listed!");
require(verifySigner(platformAddress, messageHash(abi.encodePacked(msg.sender, tokenID, price, transactionID)), buyRSV), "Buy rsv invalid");
require(<FILL_ME>)
require(msg.value == price, "msg.value is not matched with price!");
require(HDY721(NFTAddress).ownerOf(tokenID) != msg.sender, "You can't buy your own NFT!");
statusNFT[tokenID] = false;
uint256 fee = (msg.value * royaltyFee) / denominator;
(bool sent, bytes memory data) = payable(seller).call{value: msg.value - fee}("");
require(sent, "Failed to send Ether");
(bool feeSent, bytes memory feeData) = payable(platformAddress).call{value: fee}("");
require(feeSent, "Failed to send fee!");
HDY721(NFTAddress).safeTransferFrom(seller, msg.sender, tokenID);
emit BuyEvent(msg.sender, tokenID, price, transactionID, block.timestamp, data);
}
function cancelSell(uint256 tokenID, string memory transactionID, Sig memory cancelRSV) public initializer onlyNFTOwner(tokenID) {
}
function lowingPrice(uint256 tokenID, uint256 newPrice, string memory transactionID, Sig memory lowingPriceRSV) public initializer onlyNFTOwner(tokenID) {
}
function addAdmin(address addressAdmin) external onlyOwner initializer{
}
function updatePlatform(address newPlatform) external onlyAdmin initializer {
}
function updateNFTAddress(address nftAddress) external onlyAdmin initializer{
}
function revokeAdmin(address addressAdmin) external onlyOwner {
}
function setRoyaltyFee(uint256 newFee) public onlyAdmin initializer{
}
function getRoyaltyFee() public view returns (uint256){
}
function verifySigner(address signer, bytes32 ethSignedMessageHash, Sig memory rsv) internal pure returns (bool)
{
}
function messageHash(bytes memory abiEncode)internal pure returns (bytes32)
{
}
modifier initializer() {
}
modifier onlyAdmin() {
}
modifier onlyNFTOwner(uint256 tokenID) {
}
}
| HDY721(NFTAddress).getPriceNFT(tokenID)==price,"The amount is not match with listing price!" | 203,950 | HDY721(NFTAddress).getPriceNFT(tokenID)==price |
"You can't buy your own NFT!" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./HDY721.sol";
contract Marketplace is Ownable, ReentrancyGuard{
uint256 public royaltyFee;
address public platformAddress;
address public NFTAddress;
//the denominator is used to calculate so the result will not return 0 if we
//want to calculate the value that have a point(.) ex: 2.5 * 2
uint256 denominator = 10000;
mapping (address => bool) public statusAdmin;
mapping (uint256 => bool) public statusNFT;
struct Sig{bytes32 r; bytes32 s; uint8 v;}
event SellEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp);
event BuyEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp, bytes transferData);
event CancelSellEvent(address Caller, uint256 TokenID, string transactionID, uint256 TimeStamp);
event LowingPriceEvent(address Caller, uint256 TokenID, uint256 NewPrice, string transactionID, uint256 TimeStamp);
event BuyPackEvent(address buyerAddress, uint256 packID, uint256 amountPack, uint256 transferredAmount, string transactionID, uint256 TimeStamp, bytes transferData);
bool public Initialized;
function init(address _platformAddress, address _NFTAddress) public onlyOwner {
}
function buyPack(uint256 packID, uint256 amount, uint256 pricePack, string memory transactionID, Sig memory buyPackRSV) external payable initializer {
}
function sell(uint256 tokenID, uint256 price, string memory transactionID, Sig memory sellRSV) public initializer onlyNFTOwner(tokenID) {
}
function sellWithMint(uint256 tokenID, string memory collectionName, string memory tokenURI, uint256 price, string memory transactionID, HDY721.Sig memory MintRSV, Sig memory sellRSV) public initializer{
}
function buy(address seller, uint256 tokenID,uint256 price, string memory transactionID, Sig memory buyRSV) public payable initializer {
require(statusNFT[tokenID], "NFT is not listed!");
require(verifySigner(platformAddress, messageHash(abi.encodePacked(msg.sender, tokenID, price, transactionID)), buyRSV), "Buy rsv invalid");
require(HDY721(NFTAddress).getPriceNFT(tokenID) == price, "The amount is not match with listing price!");
require(msg.value == price, "msg.value is not matched with price!");
require(<FILL_ME>)
statusNFT[tokenID] = false;
uint256 fee = (msg.value * royaltyFee) / denominator;
(bool sent, bytes memory data) = payable(seller).call{value: msg.value - fee}("");
require(sent, "Failed to send Ether");
(bool feeSent, bytes memory feeData) = payable(platformAddress).call{value: fee}("");
require(feeSent, "Failed to send fee!");
HDY721(NFTAddress).safeTransferFrom(seller, msg.sender, tokenID);
emit BuyEvent(msg.sender, tokenID, price, transactionID, block.timestamp, data);
}
function cancelSell(uint256 tokenID, string memory transactionID, Sig memory cancelRSV) public initializer onlyNFTOwner(tokenID) {
}
function lowingPrice(uint256 tokenID, uint256 newPrice, string memory transactionID, Sig memory lowingPriceRSV) public initializer onlyNFTOwner(tokenID) {
}
function addAdmin(address addressAdmin) external onlyOwner initializer{
}
function updatePlatform(address newPlatform) external onlyAdmin initializer {
}
function updateNFTAddress(address nftAddress) external onlyAdmin initializer{
}
function revokeAdmin(address addressAdmin) external onlyOwner {
}
function setRoyaltyFee(uint256 newFee) public onlyAdmin initializer{
}
function getRoyaltyFee() public view returns (uint256){
}
function verifySigner(address signer, bytes32 ethSignedMessageHash, Sig memory rsv) internal pure returns (bool)
{
}
function messageHash(bytes memory abiEncode)internal pure returns (bytes32)
{
}
modifier initializer() {
}
modifier onlyAdmin() {
}
modifier onlyNFTOwner(uint256 tokenID) {
}
}
| HDY721(NFTAddress).ownerOf(tokenID)!=msg.sender,"You can't buy your own NFT!" | 203,950 | HDY721(NFTAddress).ownerOf(tokenID)!=msg.sender |
"Cancel rsv invalid" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./HDY721.sol";
contract Marketplace is Ownable, ReentrancyGuard{
uint256 public royaltyFee;
address public platformAddress;
address public NFTAddress;
//the denominator is used to calculate so the result will not return 0 if we
//want to calculate the value that have a point(.) ex: 2.5 * 2
uint256 denominator = 10000;
mapping (address => bool) public statusAdmin;
mapping (uint256 => bool) public statusNFT;
struct Sig{bytes32 r; bytes32 s; uint8 v;}
event SellEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp);
event BuyEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp, bytes transferData);
event CancelSellEvent(address Caller, uint256 TokenID, string transactionID, uint256 TimeStamp);
event LowingPriceEvent(address Caller, uint256 TokenID, uint256 NewPrice, string transactionID, uint256 TimeStamp);
event BuyPackEvent(address buyerAddress, uint256 packID, uint256 amountPack, uint256 transferredAmount, string transactionID, uint256 TimeStamp, bytes transferData);
bool public Initialized;
function init(address _platformAddress, address _NFTAddress) public onlyOwner {
}
function buyPack(uint256 packID, uint256 amount, uint256 pricePack, string memory transactionID, Sig memory buyPackRSV) external payable initializer {
}
function sell(uint256 tokenID, uint256 price, string memory transactionID, Sig memory sellRSV) public initializer onlyNFTOwner(tokenID) {
}
function sellWithMint(uint256 tokenID, string memory collectionName, string memory tokenURI, uint256 price, string memory transactionID, HDY721.Sig memory MintRSV, Sig memory sellRSV) public initializer{
}
function buy(address seller, uint256 tokenID,uint256 price, string memory transactionID, Sig memory buyRSV) public payable initializer {
}
function cancelSell(uint256 tokenID, string memory transactionID, Sig memory cancelRSV) public initializer onlyNFTOwner(tokenID) {
require(<FILL_ME>)
require(statusNFT[tokenID], "You can't cancel sell NFT that not selled!");
statusNFT[tokenID] = false;
emit CancelSellEvent(msg.sender, tokenID, transactionID, block.timestamp);
}
function lowingPrice(uint256 tokenID, uint256 newPrice, string memory transactionID, Sig memory lowingPriceRSV) public initializer onlyNFTOwner(tokenID) {
}
function addAdmin(address addressAdmin) external onlyOwner initializer{
}
function updatePlatform(address newPlatform) external onlyAdmin initializer {
}
function updateNFTAddress(address nftAddress) external onlyAdmin initializer{
}
function revokeAdmin(address addressAdmin) external onlyOwner {
}
function setRoyaltyFee(uint256 newFee) public onlyAdmin initializer{
}
function getRoyaltyFee() public view returns (uint256){
}
function verifySigner(address signer, bytes32 ethSignedMessageHash, Sig memory rsv) internal pure returns (bool)
{
}
function messageHash(bytes memory abiEncode)internal pure returns (bytes32)
{
}
modifier initializer() {
}
modifier onlyAdmin() {
}
modifier onlyNFTOwner(uint256 tokenID) {
}
}
| verifySigner(platformAddress,messageHash(abi.encodePacked(msg.sender,tokenID)),cancelRSV),"Cancel rsv invalid" | 203,950 | verifySigner(platformAddress,messageHash(abi.encodePacked(msg.sender,tokenID)),cancelRSV) |
"LowingPrice rsv invalid" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./HDY721.sol";
contract Marketplace is Ownable, ReentrancyGuard{
uint256 public royaltyFee;
address public platformAddress;
address public NFTAddress;
//the denominator is used to calculate so the result will not return 0 if we
//want to calculate the value that have a point(.) ex: 2.5 * 2
uint256 denominator = 10000;
mapping (address => bool) public statusAdmin;
mapping (uint256 => bool) public statusNFT;
struct Sig{bytes32 r; bytes32 s; uint8 v;}
event SellEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp);
event BuyEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp, bytes transferData);
event CancelSellEvent(address Caller, uint256 TokenID, string transactionID, uint256 TimeStamp);
event LowingPriceEvent(address Caller, uint256 TokenID, uint256 NewPrice, string transactionID, uint256 TimeStamp);
event BuyPackEvent(address buyerAddress, uint256 packID, uint256 amountPack, uint256 transferredAmount, string transactionID, uint256 TimeStamp, bytes transferData);
bool public Initialized;
function init(address _platformAddress, address _NFTAddress) public onlyOwner {
}
function buyPack(uint256 packID, uint256 amount, uint256 pricePack, string memory transactionID, Sig memory buyPackRSV) external payable initializer {
}
function sell(uint256 tokenID, uint256 price, string memory transactionID, Sig memory sellRSV) public initializer onlyNFTOwner(tokenID) {
}
function sellWithMint(uint256 tokenID, string memory collectionName, string memory tokenURI, uint256 price, string memory transactionID, HDY721.Sig memory MintRSV, Sig memory sellRSV) public initializer{
}
function buy(address seller, uint256 tokenID,uint256 price, string memory transactionID, Sig memory buyRSV) public payable initializer {
}
function cancelSell(uint256 tokenID, string memory transactionID, Sig memory cancelRSV) public initializer onlyNFTOwner(tokenID) {
}
function lowingPrice(uint256 tokenID, uint256 newPrice, string memory transactionID, Sig memory lowingPriceRSV) public initializer onlyNFTOwner(tokenID) {
require(<FILL_ME>)
require(newPrice < HDY721(NFTAddress).getPriceNFT(tokenID), "Your submitted new price is higher than initialized price.");
HDY721(NFTAddress).setPriceNFT(msg.sender, tokenID, newPrice);
emit LowingPriceEvent(msg.sender, tokenID, newPrice, transactionID, block.timestamp);
}
function addAdmin(address addressAdmin) external onlyOwner initializer{
}
function updatePlatform(address newPlatform) external onlyAdmin initializer {
}
function updateNFTAddress(address nftAddress) external onlyAdmin initializer{
}
function revokeAdmin(address addressAdmin) external onlyOwner {
}
function setRoyaltyFee(uint256 newFee) public onlyAdmin initializer{
}
function getRoyaltyFee() public view returns (uint256){
}
function verifySigner(address signer, bytes32 ethSignedMessageHash, Sig memory rsv) internal pure returns (bool)
{
}
function messageHash(bytes memory abiEncode)internal pure returns (bytes32)
{
}
modifier initializer() {
}
modifier onlyAdmin() {
}
modifier onlyNFTOwner(uint256 tokenID) {
}
}
| verifySigner(platformAddress,messageHash(abi.encodePacked(msg.sender,tokenID,newPrice)),lowingPriceRSV),"LowingPrice rsv invalid" | 203,950 | verifySigner(platformAddress,messageHash(abi.encodePacked(msg.sender,tokenID,newPrice)),lowingPriceRSV) |
"The Denominator is 10000" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./HDY721.sol";
contract Marketplace is Ownable, ReentrancyGuard{
uint256 public royaltyFee;
address public platformAddress;
address public NFTAddress;
//the denominator is used to calculate so the result will not return 0 if we
//want to calculate the value that have a point(.) ex: 2.5 * 2
uint256 denominator = 10000;
mapping (address => bool) public statusAdmin;
mapping (uint256 => bool) public statusNFT;
struct Sig{bytes32 r; bytes32 s; uint8 v;}
event SellEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp);
event BuyEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp, bytes transferData);
event CancelSellEvent(address Caller, uint256 TokenID, string transactionID, uint256 TimeStamp);
event LowingPriceEvent(address Caller, uint256 TokenID, uint256 NewPrice, string transactionID, uint256 TimeStamp);
event BuyPackEvent(address buyerAddress, uint256 packID, uint256 amountPack, uint256 transferredAmount, string transactionID, uint256 TimeStamp, bytes transferData);
bool public Initialized;
function init(address _platformAddress, address _NFTAddress) public onlyOwner {
}
function buyPack(uint256 packID, uint256 amount, uint256 pricePack, string memory transactionID, Sig memory buyPackRSV) external payable initializer {
}
function sell(uint256 tokenID, uint256 price, string memory transactionID, Sig memory sellRSV) public initializer onlyNFTOwner(tokenID) {
}
function sellWithMint(uint256 tokenID, string memory collectionName, string memory tokenURI, uint256 price, string memory transactionID, HDY721.Sig memory MintRSV, Sig memory sellRSV) public initializer{
}
function buy(address seller, uint256 tokenID,uint256 price, string memory transactionID, Sig memory buyRSV) public payable initializer {
}
function cancelSell(uint256 tokenID, string memory transactionID, Sig memory cancelRSV) public initializer onlyNFTOwner(tokenID) {
}
function lowingPrice(uint256 tokenID, uint256 newPrice, string memory transactionID, Sig memory lowingPriceRSV) public initializer onlyNFTOwner(tokenID) {
}
function addAdmin(address addressAdmin) external onlyOwner initializer{
}
function updatePlatform(address newPlatform) external onlyAdmin initializer {
}
function updateNFTAddress(address nftAddress) external onlyAdmin initializer{
}
function revokeAdmin(address addressAdmin) external onlyOwner {
}
function setRoyaltyFee(uint256 newFee) public onlyAdmin initializer{
require(<FILL_ME>)
royaltyFee = newFee;
}
function getRoyaltyFee() public view returns (uint256){
}
function verifySigner(address signer, bytes32 ethSignedMessageHash, Sig memory rsv) internal pure returns (bool)
{
}
function messageHash(bytes memory abiEncode)internal pure returns (bytes32)
{
}
modifier initializer() {
}
modifier onlyAdmin() {
}
modifier onlyNFTOwner(uint256 tokenID) {
}
}
| (newFee>=100)&&(newFee<=10000),"The Denominator is 10000" | 203,950 | (newFee>=100)&&(newFee<=10000) |
"The caller is not an admin." | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./HDY721.sol";
contract Marketplace is Ownable, ReentrancyGuard{
uint256 public royaltyFee;
address public platformAddress;
address public NFTAddress;
//the denominator is used to calculate so the result will not return 0 if we
//want to calculate the value that have a point(.) ex: 2.5 * 2
uint256 denominator = 10000;
mapping (address => bool) public statusAdmin;
mapping (uint256 => bool) public statusNFT;
struct Sig{bytes32 r; bytes32 s; uint8 v;}
event SellEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp);
event BuyEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp, bytes transferData);
event CancelSellEvent(address Caller, uint256 TokenID, string transactionID, uint256 TimeStamp);
event LowingPriceEvent(address Caller, uint256 TokenID, uint256 NewPrice, string transactionID, uint256 TimeStamp);
event BuyPackEvent(address buyerAddress, uint256 packID, uint256 amountPack, uint256 transferredAmount, string transactionID, uint256 TimeStamp, bytes transferData);
bool public Initialized;
function init(address _platformAddress, address _NFTAddress) public onlyOwner {
}
function buyPack(uint256 packID, uint256 amount, uint256 pricePack, string memory transactionID, Sig memory buyPackRSV) external payable initializer {
}
function sell(uint256 tokenID, uint256 price, string memory transactionID, Sig memory sellRSV) public initializer onlyNFTOwner(tokenID) {
}
function sellWithMint(uint256 tokenID, string memory collectionName, string memory tokenURI, uint256 price, string memory transactionID, HDY721.Sig memory MintRSV, Sig memory sellRSV) public initializer{
}
function buy(address seller, uint256 tokenID,uint256 price, string memory transactionID, Sig memory buyRSV) public payable initializer {
}
function cancelSell(uint256 tokenID, string memory transactionID, Sig memory cancelRSV) public initializer onlyNFTOwner(tokenID) {
}
function lowingPrice(uint256 tokenID, uint256 newPrice, string memory transactionID, Sig memory lowingPriceRSV) public initializer onlyNFTOwner(tokenID) {
}
function addAdmin(address addressAdmin) external onlyOwner initializer{
}
function updatePlatform(address newPlatform) external onlyAdmin initializer {
}
function updateNFTAddress(address nftAddress) external onlyAdmin initializer{
}
function revokeAdmin(address addressAdmin) external onlyOwner {
}
function setRoyaltyFee(uint256 newFee) public onlyAdmin initializer{
}
function getRoyaltyFee() public view returns (uint256){
}
function verifySigner(address signer, bytes32 ethSignedMessageHash, Sig memory rsv) internal pure returns (bool)
{
}
function messageHash(bytes memory abiEncode)internal pure returns (bytes32)
{
}
modifier initializer() {
}
modifier onlyAdmin() {
require(<FILL_ME>)
_;
}
modifier onlyNFTOwner(uint256 tokenID) {
}
}
| statusAdmin[msg.sender],"The caller is not an admin." | 203,950 | statusAdmin[msg.sender] |
"You're not an owner of this NFT" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./HDY721.sol";
contract Marketplace is Ownable, ReentrancyGuard{
uint256 public royaltyFee;
address public platformAddress;
address public NFTAddress;
//the denominator is used to calculate so the result will not return 0 if we
//want to calculate the value that have a point(.) ex: 2.5 * 2
uint256 denominator = 10000;
mapping (address => bool) public statusAdmin;
mapping (uint256 => bool) public statusNFT;
struct Sig{bytes32 r; bytes32 s; uint8 v;}
event SellEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp);
event BuyEvent(address Caller, uint256 TokenID, uint256 Price, string transactionID, uint256 TimeStamp, bytes transferData);
event CancelSellEvent(address Caller, uint256 TokenID, string transactionID, uint256 TimeStamp);
event LowingPriceEvent(address Caller, uint256 TokenID, uint256 NewPrice, string transactionID, uint256 TimeStamp);
event BuyPackEvent(address buyerAddress, uint256 packID, uint256 amountPack, uint256 transferredAmount, string transactionID, uint256 TimeStamp, bytes transferData);
bool public Initialized;
function init(address _platformAddress, address _NFTAddress) public onlyOwner {
}
function buyPack(uint256 packID, uint256 amount, uint256 pricePack, string memory transactionID, Sig memory buyPackRSV) external payable initializer {
}
function sell(uint256 tokenID, uint256 price, string memory transactionID, Sig memory sellRSV) public initializer onlyNFTOwner(tokenID) {
}
function sellWithMint(uint256 tokenID, string memory collectionName, string memory tokenURI, uint256 price, string memory transactionID, HDY721.Sig memory MintRSV, Sig memory sellRSV) public initializer{
}
function buy(address seller, uint256 tokenID,uint256 price, string memory transactionID, Sig memory buyRSV) public payable initializer {
}
function cancelSell(uint256 tokenID, string memory transactionID, Sig memory cancelRSV) public initializer onlyNFTOwner(tokenID) {
}
function lowingPrice(uint256 tokenID, uint256 newPrice, string memory transactionID, Sig memory lowingPriceRSV) public initializer onlyNFTOwner(tokenID) {
}
function addAdmin(address addressAdmin) external onlyOwner initializer{
}
function updatePlatform(address newPlatform) external onlyAdmin initializer {
}
function updateNFTAddress(address nftAddress) external onlyAdmin initializer{
}
function revokeAdmin(address addressAdmin) external onlyOwner {
}
function setRoyaltyFee(uint256 newFee) public onlyAdmin initializer{
}
function getRoyaltyFee() public view returns (uint256){
}
function verifySigner(address signer, bytes32 ethSignedMessageHash, Sig memory rsv) internal pure returns (bool)
{
}
function messageHash(bytes memory abiEncode)internal pure returns (bytes32)
{
}
modifier initializer() {
}
modifier onlyAdmin() {
}
modifier onlyNFTOwner(uint256 tokenID) {
require(<FILL_ME>)
_;
}
}
| HDY721(NFTAddress).ownerOf(tokenID)==msg.sender,"You're not an owner of this NFT" | 203,950 | HDY721(NFTAddress).ownerOf(tokenID)==msg.sender |
"Not enough NFTs left for minting..." | pragma solidity >=0.8.2;
contract PandaQ is ERC721, Ownable {
using Strings for uint256;
//amount of tokens that have been minted so far, in total and in presale
uint256 private numberOfTotalTokens;
//declares the maximum amount of tokens that can be minted, total and in presale
uint256 private maxTotalTokens;
//initial part of the URI for the metadata
string private _currentBaseURI = "https://www.pandaq.io/metadata/";
//marks the timestamp of when the respective sales open
uint256 internal revealTime;
uint256 private reservedMints_;
uint256 private maxReservedMints = 100;
uint256 private privateSaleMints_;
uint256 private maxPrivateSaleMints = 1000;
//if breeding is open or not
bool private breeding;
//stores how many breeds each nft has done
mapping(uint256 => uint256) private breedsPerToken;
uint256 private maxBreeds = 5;
uint256 private mintCostPresale = 0.2 ether;
uint256 private mintCostPrivateSale = 0.17 ether;
uint256 private mintCostPublicSale = 0.25 ether;
uint256 private breedCost_ = 1 ether;
//amount of mints that each address has executed
mapping(address => uint256) public mintsPerAddress;
//current state os sale
enum State {
NoSale,
Presale,
PublicSale,
PrivateSale
}
State public saleState;
//defines the uri for when the NFTs have not been yet revealed
string public unrevealedURI;
//tokens that have been created from breeding
uint256 private tokensBreeded;
//declaring initial values for variables
constructor() ERC721("PandaQ", "PQ") {
}
//in case somebody accidentaly sends funds or transaction to contract
receive() external payable {}
fallback() external payable {
}
//visualize baseURI
function _baseURI() internal view virtual override returns (string memory) {
}
//change baseURI in case needed for IPFS
function changeBaseURI(string memory baseURI_) public onlyOwner {
}
function changeUnrevealedURI(string memory unrevealedURI_)
public
onlyOwner
{
}
//gets the tokenID of NFT to be minted
function tokenId() internal view returns (uint256) {
}
function switchToPresale() public onlyOwner {
}
function switchToPublicSale() public onlyOwner {
}
function switchToPrivateSale() public onlyOwner {
}
//mint a @param number of NFTs in presale
function presaleMint(uint256 number) public payable {
}
//mint a @param number of NFTs in public sale
function publicSaleMint(uint256 number) public payable {
}
//mint a @param number of NFTs in private sale
function privateSaleMint(uint256 number) public payable {
require(saleState == State.PrivateSale, "Sale in not open!");
require(<FILL_ME>)
require(
msg.value >= mintCost() * number,
"You don't have enough Ethereum to mint this amount of NFTs"
);
for (uint256 i = 0; i < number; i++) {
uint256 tid = tokenId();
_safeMint(msg.sender, tid);
mintsPerAddress[msg.sender] += 1;
numberOfTotalTokens += 1;
privateSaleMints_ += 1;
}
}
//reserved NFTs for creator
function reservedMint(uint256 number, address recipient) public onlyOwner {
}
function tokenURI(uint256 tokenId_)
public
view
virtual
override
returns (string memory)
{
}
//burn the tokens that have not been sold yet
function burnTokens() public onlyOwner {
}
//se the current account balance
function accountBalance() public view onlyOwner returns (uint256) {
}
//retrieve funds
function withdraw(address recipient, uint256 amount) public onlyOwner {
}
//send the percentage of funds to a shareholder´s wallet
function _withdraw(address payable account, uint256 amount) internal {
}
//see the total amount of tokens that have been minted
function totalSupply() public view returns (uint256) {
}
//to reveal the nfts
function reveal() public onlyOwner {
}
//shows total amount of tokens that could be minted
function maxTokens() public view returns (uint256) {
}
function breed(uint256 tokenIdParent1, uint256 tokenIdParent2)
public
payable
{
}
function toggleBreeding() public onlyOwner {
}
function breedIsOpen() public view returns (bool) {
}
function changeMaxBreeds(uint256 newBreeds) public onlyOwner {
}
function breedCost() public view returns (uint256) {
}
function changeBreedCost(uint256 newCost) public onlyOwner {
}
function mintCost() public view returns (uint256) {
}
}
| numberOfTotalTokens+number<=maxTotalTokens-(maxReservedMints-reservedMints_)&&privateSaleMints_+number<=maxPrivateSaleMints,"Not enough NFTs left for minting..." | 203,967 | numberOfTotalTokens+number<=maxTotalTokens-(maxReservedMints-reservedMints_)&&privateSaleMints_+number<=maxPrivateSaleMints |
"Reserve would exceed max supply of Tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "./ERC721F.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "raribles/royalties/contracts/impl/RoyaltiesV2Impl.sol";
import "raribles/royalties/contracts/LibPart.sol";
import "raribles/royalties/contracts/LibRoyaltiesV2.sol";
contract CryptoBalloonerz is ERC721F, RoyaltiesV2Impl {
using SafeMath for uint256;
uint256 public tokenPrice = 0.03141 ether;
uint256 public constant MAX_TOKENS = 3141;
uint8 public constant MAX_RESERVE = 2;
uint8 public constant MAX_RESERVE_FOR_OWNERS = 10;
bool public saleIsActive = false;
bool public preSaleIsActive = true;
address private constant ONE = 0x4daf9FC427E7b1F38Ac447F291a474F44a4EA6c5;
address private constant TWO = 0x2FadbE50e4499B546561c64E50799B378a46e073;
address private constant THREE = 0xBDA48AEfA318FEf6599e5890D24356b22b0d753E;
bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a;
mapping(address => uint8) private whitelist;
event priceChange(address _by, uint256 price);
constructor() ERC721F ("CryptoBalloonerz", "CBLZ") {
}
/**
* If the owner wants to set another URI, then call setBaseTokenURI.
*/
/**
* Setter function: to Arweave base URI.
*/
function setBaseUriToAr() public onlyOwner {
}
/**
* Setter function: to ArweaveNet base URI.
*/
function setBaseUriToArweaveNet() public onlyOwner {
}
/**
* Mint Tokens to a wallet.
*/
function mintTokensToWallet(address to,uint numberOfTokens) public onlyOwner {
uint supply = totalSupply();
require(<FILL_ME>)
require(numberOfTokens <= MAX_RESERVE_FOR_OWNERS, "Can only mint 10 tokens at a time");
for (uint i = 0; i < numberOfTokens; i++) {
_safeMint(to, supply + i);
}
}
/**
* Mint Tokens to the owners reserve.
*/
function reserveTokens() external onlyOwner {
}
/**
* Pause sale if active, make active if paused
*/
function flipSaleState() external onlyOwner {
}
/**
* Pause sale if active, make active if paused
*/
function flipPreSaleState() external onlyOwner {
}
/**
* Set price
*/
function setPrice(uint256 price) external onlyOwner {
}
/**
* add an address to the WL
*/
function addWL(address _address) public onlyOwner {
}
/**
* add an array of address to the WL
*/
function addAdresses(address[] memory _address) external onlyOwner {
}
/**
* remove an address from the WL
*/
function removeWL(address _address) external onlyOwner {
}
/**
* returns true if the wallet is Whitelisted.
*/
function isWhitelisted(address _address) public view returns(bool) {
}
/**
* returns the number of free mints.
*/
function numOfFreeMints(address _address) public view returns(uint8) {
}
/**
* minting function, based on minting amount
*/
function mint(uint8 numberOfTokens) external payable{
}
/**
* withdrawal function based on percentages
*/
function withdraw() public onlyOwner {
}
/**
* private withdrawal function
*/
function _withdraw(address _address, uint256 _amount) private {
}
/**
* contract can recieve ether
*/
fallback() external payable { }
receive() external payable { }
/**
* Configure royalties for Rariable
*/
function setRoyalties(uint _tokenId, address payable _royaltiesRecipientAddress, uint96 _percentageBasisPoints) public onlyOwner {
}
/**
* Configure royalties for Mintable using the ERC2981 standard
*/
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) external view returns (address receiver, uint256 royaltyAmount) {
}
/**
* Check interface
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721) returns (bool) {
}
}
| supply.add(numberOfTokens)<=MAX_TOKENS,"Reserve would exceed max supply of Tokens" | 203,971 | supply.add(numberOfTokens)<=MAX_TOKENS |
"Ether value sent is not correct" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "./ERC721F.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "raribles/royalties/contracts/impl/RoyaltiesV2Impl.sol";
import "raribles/royalties/contracts/LibPart.sol";
import "raribles/royalties/contracts/LibRoyaltiesV2.sol";
contract CryptoBalloonerz is ERC721F, RoyaltiesV2Impl {
using SafeMath for uint256;
uint256 public tokenPrice = 0.03141 ether;
uint256 public constant MAX_TOKENS = 3141;
uint8 public constant MAX_RESERVE = 2;
uint8 public constant MAX_RESERVE_FOR_OWNERS = 10;
bool public saleIsActive = false;
bool public preSaleIsActive = true;
address private constant ONE = 0x4daf9FC427E7b1F38Ac447F291a474F44a4EA6c5;
address private constant TWO = 0x2FadbE50e4499B546561c64E50799B378a46e073;
address private constant THREE = 0xBDA48AEfA318FEf6599e5890D24356b22b0d753E;
bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a;
mapping(address => uint8) private whitelist;
event priceChange(address _by, uint256 price);
constructor() ERC721F ("CryptoBalloonerz", "CBLZ") {
}
/**
* If the owner wants to set another URI, then call setBaseTokenURI.
*/
/**
* Setter function: to Arweave base URI.
*/
function setBaseUriToAr() public onlyOwner {
}
/**
* Setter function: to ArweaveNet base URI.
*/
function setBaseUriToArweaveNet() public onlyOwner {
}
/**
* Mint Tokens to a wallet.
*/
function mintTokensToWallet(address to,uint numberOfTokens) public onlyOwner {
}
/**
* Mint Tokens to the owners reserve.
*/
function reserveTokens() external onlyOwner {
}
/**
* Pause sale if active, make active if paused
*/
function flipSaleState() external onlyOwner {
}
/**
* Pause sale if active, make active if paused
*/
function flipPreSaleState() external onlyOwner {
}
/**
* Set price
*/
function setPrice(uint256 price) external onlyOwner {
}
/**
* add an address to the WL
*/
function addWL(address _address) public onlyOwner {
}
/**
* add an array of address to the WL
*/
function addAdresses(address[] memory _address) external onlyOwner {
}
/**
* remove an address from the WL
*/
function removeWL(address _address) external onlyOwner {
}
/**
* returns true if the wallet is Whitelisted.
*/
function isWhitelisted(address _address) public view returns(bool) {
}
/**
* returns the number of free mints.
*/
function numOfFreeMints(address _address) public view returns(uint8) {
}
/**
* minting function, based on minting amount
*/
function mint(uint8 numberOfTokens) external payable{
bool whiteListed = isWhitelisted(msg.sender);
if(preSaleIsActive){
require(whiteListed,"Sender is NOT Whitelisted.");
}else{
require(saleIsActive,"Sale NOT active yet");
}
require(numberOfTokens <= MAX_RESERVE, "Can only mint 2 tokens at a time");
uint256 supply = totalSupply();
require(supply.add(numberOfTokens) <= MAX_TOKENS, "Purchase would exceed max supply of Tokens");
if (whiteListed){
uint8 remainedFreeTokens = numOfFreeMints(msg.sender);
require(numberOfTokens <= remainedFreeTokens, "Number of free mints not greater or equal to the requested amount");
whitelist[msg.sender] -= numberOfTokens;
} else {
require(<FILL_ME>)
}
for(uint256 i; i < numberOfTokens; i++){
_safeMint( msg.sender, supply + i );
}
}
/**
* withdrawal function based on percentages
*/
function withdraw() public onlyOwner {
}
/**
* private withdrawal function
*/
function _withdraw(address _address, uint256 _amount) private {
}
/**
* contract can recieve ether
*/
fallback() external payable { }
receive() external payable { }
/**
* Configure royalties for Rariable
*/
function setRoyalties(uint _tokenId, address payable _royaltiesRecipientAddress, uint96 _percentageBasisPoints) public onlyOwner {
}
/**
* Configure royalties for Mintable using the ERC2981 standard
*/
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) external view returns (address receiver, uint256 royaltyAmount) {
}
/**
* Check interface
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721) returns (bool) {
}
}
| tokenPrice.mul(numberOfTokens)<=msg.value,"Ether value sent is not correct" | 203,971 | tokenPrice.mul(numberOfTokens)<=msg.value |
"Caller is not the owner or the automator" | // SPDX-License-Identifier: MIT
// DumplingZai v69696969
// "I smash keyboards and vomit smart contracts"
pragma solidity ^0.8.0;
import "./2.IERC20.sol";
import "./3.Ownable.sol";
import "./8.IERC721Receiver.sol";
import "./9.AccessControl.sol";
import "./21.IUniswapV2Router02.sol";
contract EGGPOT_Main is Ownable, IERC721Receiver, AccessControl {
IUniswapV2Router02 public uniswapV2Router;
address[] public tokenAddress;
mapping(address => bool) public tokenToSwap;
bytes32 public constant AUTOMATOR_ROLE = keccak256("AUTOMATOR_ROLE");
uint256 public estimatedGas = 200000;
uint256 public gasPrice = 70 * 1e9; // 70 Gwei in Wei
uint256 public gasCostInWei = estimatedGas * gasPrice;
enum Status { NotStarted, AcceptingTokens, SwappingMode, ClaimMode, LuckyDraw, Reset }
Status public status;
address[] public claimable;
mapping(address => mapping(uint256 => bool)) public hasClaimed;
uint256 public currentRound = 0;
mapping(address => mapping(uint256 => uint256)) public participantEntries;
constructor() {
}
modifier onlyOwnerOrAutomator() {
require(<FILL_ME>)
_;
}
// Fallback function to receive ETH
receive() external payable {}
// Function to update the estimated gas cost for a swap
function setEstimatedGas(uint256 _estimatedGas, uint256 _gasPrice) external onlyOwnerOrAutomator {
}
// ERC721Receiver function to receive NFTs
function onERC721Received(address, address, uint256, bytes calldata) external pure override returns (bytes4) {
}
// Function to store claimable amounts (address only)
function storeClaimable(address[] calldata _addresses) external onlyOwnerOrAutomator {
}
// Function to change status of the platform
function changeStatus(Status _status) external onlyOwnerOrAutomator {
}
// Function to claim ETH (address n amount)
function claimEth(address payable _address, uint256 _amount, uint256 round) external {
}
function swapTokensForEth(address token) private onlyOwnerOrAutomator returns (bool) {
}
function swapTokensForEthBulk() public onlyOwnerOrAutomator {
}
function sendTokensBulk(uint256[] memory tokenAmounts, address[] memory tokens) public {
}
function receiveTokenAddresses(address[] memory newTokenAddresses) public onlyOwnerOrAutomator {
}
function withdrawTokens(address token, address to) public onlyOwnerOrAutomator {
}
function getPathForTokenToETH(address token) private view returns (address[] memory) {
}
// Function to get participant entries
function getParticipantEntries(address participant) external view returns (uint256) {
}
function incrementRound() external onlyOwnerOrAutomator {
}
}
| hasRole(AUTOMATOR_ROLE,msg.sender)||owner()==msg.sender,"Caller is not the owner or the automator" | 203,992 | hasRole(AUTOMATOR_ROLE,msg.sender)||owner()==msg.sender |
"Address has already claimed" | // SPDX-License-Identifier: MIT
// DumplingZai v69696969
// "I smash keyboards and vomit smart contracts"
pragma solidity ^0.8.0;
import "./2.IERC20.sol";
import "./3.Ownable.sol";
import "./8.IERC721Receiver.sol";
import "./9.AccessControl.sol";
import "./21.IUniswapV2Router02.sol";
contract EGGPOT_Main is Ownable, IERC721Receiver, AccessControl {
IUniswapV2Router02 public uniswapV2Router;
address[] public tokenAddress;
mapping(address => bool) public tokenToSwap;
bytes32 public constant AUTOMATOR_ROLE = keccak256("AUTOMATOR_ROLE");
uint256 public estimatedGas = 200000;
uint256 public gasPrice = 70 * 1e9; // 70 Gwei in Wei
uint256 public gasCostInWei = estimatedGas * gasPrice;
enum Status { NotStarted, AcceptingTokens, SwappingMode, ClaimMode, LuckyDraw, Reset }
Status public status;
address[] public claimable;
mapping(address => mapping(uint256 => bool)) public hasClaimed;
uint256 public currentRound = 0;
mapping(address => mapping(uint256 => uint256)) public participantEntries;
constructor() {
}
modifier onlyOwnerOrAutomator() {
}
// Fallback function to receive ETH
receive() external payable {}
// Function to update the estimated gas cost for a swap
function setEstimatedGas(uint256 _estimatedGas, uint256 _gasPrice) external onlyOwnerOrAutomator {
}
// ERC721Receiver function to receive NFTs
function onERC721Received(address, address, uint256, bytes calldata) external pure override returns (bytes4) {
}
// Function to store claimable amounts (address only)
function storeClaimable(address[] calldata _addresses) external onlyOwnerOrAutomator {
}
// Function to change status of the platform
function changeStatus(Status _status) external onlyOwnerOrAutomator {
}
// Function to claim ETH (address n amount)
function claimEth(address payable _address, uint256 _amount, uint256 round) external {
require(status == Status.ClaimMode, "Not in Claim Mode");
bool isClaimable = false;
for (uint i = 0; i < claimable.length; i++) {
if (claimable[i] == _address) {
isClaimable = true;
break;
}
}
require(isClaimable, "Address is not in the claimable list");
require(<FILL_ME>)
// Mark address as having claimed
hasClaimed[_address][round] = true;
// Transfer ETH
(bool success, ) = _address.call{value: _amount}("");
require(success, "Transfer failed");
}
function swapTokensForEth(address token) private onlyOwnerOrAutomator returns (bool) {
}
function swapTokensForEthBulk() public onlyOwnerOrAutomator {
}
function sendTokensBulk(uint256[] memory tokenAmounts, address[] memory tokens) public {
}
function receiveTokenAddresses(address[] memory newTokenAddresses) public onlyOwnerOrAutomator {
}
function withdrawTokens(address token, address to) public onlyOwnerOrAutomator {
}
function getPathForTokenToETH(address token) private view returns (address[] memory) {
}
// Function to get participant entries
function getParticipantEntries(address participant) external view returns (uint256) {
}
function incrementRound() external onlyOwnerOrAutomator {
}
}
| !hasClaimed[_address][round],"Address has already claimed" | 203,992 | !hasClaimed[_address][round] |
"PS: Pre-Sale sold out!" | // SPDX-License-Identifier: GPLv3
pragma solidity ^0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IDickManiac.sol";
import "./interfaces/IEMC.sol";
import "hardhat/console.sol";
contract PreSale is ReentrancyGuard, Ownable {
IDickManiac public immutable collection;
IEMC public immutable echo3card;
uint256 public preSaleSize;
uint256 public itemPrice;
uint256 public releaseDate;
constructor(
IDickManiac _collection,
IEMC _echo3card,
uint256 _preSaleSize,
uint256 _releaseDate,
uint256 _price
) {
}
function mintNewDicks(uint256 quantity) external payable nonReentrant {
require(block.timestamp >= releaseDate, "PS: Not started");
uint256 priceToPay = itemPrice * quantity;
require(msg.value >= priceToPay, "PS: Sent ETH too low");
require(<FILL_ME>)
console.log("passes require");
for (uint256 i = 0; i < quantity; i++) {
console.log("mint", i);
collection.mint(msg.sender);
echo3card.mint(msg.sender);
console.log("mint done", i);
}
uint256 refund = msg.value - priceToPay;
if (refund > 0) {
console.log("refund");
payable(msg.sender).transfer(refund);
}
// liquidityCollector.transfer(priceToPay);
}
function issueContingent(address to, uint256 quantity) external onlyOwner {
}
function call(
address payable _to,
uint256 _value,
bytes calldata _data
) external payable onlyOwner returns (bytes memory) {
}
}
| collection.getCurrentTokenTracker()+quantity<=preSaleSize,"PS: Pre-Sale sold out!" | 204,087 | collection.getCurrentTokenTracker()+quantity<=preSaleSize |
null | // SPDX-License-Identifier: GPLv3
pragma solidity ^0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IDickManiac.sol";
import "./interfaces/IEMC.sol";
import "hardhat/console.sol";
contract PreSale is ReentrancyGuard, Ownable {
IDickManiac public immutable collection;
IEMC public immutable echo3card;
uint256 public preSaleSize;
uint256 public itemPrice;
uint256 public releaseDate;
constructor(
IDickManiac _collection,
IEMC _echo3card,
uint256 _preSaleSize,
uint256 _releaseDate,
uint256 _price
) {
}
function mintNewDicks(uint256 quantity) external payable nonReentrant {
require(block.timestamp >= releaseDate, "PS: Not started");
uint256 priceToPay = itemPrice * quantity;
require(msg.value >= priceToPay, "PS: Sent ETH too low");
require(
collection.getCurrentTokenTracker() + quantity <= preSaleSize,
"PS: Pre-Sale sold out!"
);
require(<FILL_ME>)
for (uint256 i = 0; i < quantity; i++) {
console.log("mint", i);
collection.mint(msg.sender);
echo3card.mint(msg.sender);
console.log("mint done", i);
}
uint256 refund = msg.value - priceToPay;
if (refund > 0) {
console.log("refund");
payable(msg.sender).transfer(refund);
}
// liquidityCollector.transfer(priceToPay);
}
function issueContingent(address to, uint256 quantity) external onlyOwner {
}
function call(
address payable _to,
uint256 _value,
bytes calldata _data
) external payable onlyOwner returns (bytes memory) {
}
}
| log("passes require" | 204,087 | "passes require" |
null | @v1.10.0
/**
* @title WhitelistedCrowdsale
* @dev Crowdsale in which only whitelisted users can contribute.
*/
contract WhitelistedCrowdsale is Crowdsale, Ownable {
mapping(address => bool) public whitelist;
bool private whitelistEnabled = true;
//Set minimum tokens required to swap.
function toggleWhitelist(bool _whitelistEnabled) external onlyOwner {
}
/**
* @dev Reverts if beneficiary is not whitelisted. Can be used when extending this contract.
*/
modifier isWhitelisted(address _beneficiary) {
}
/**
* @dev Adds single address to whitelist.
* @param _beneficiary Address to be added to the whitelist
*/
function addToWhitelist(address _beneficiary) external onlyOwner {
}
/**
* @dev Adds list of addresses to whitelist. Not overloaded due to limitations with truffle testing.
* @param _beneficiaries Addresses to be added to the whitelist
*/
function addManyToWhitelist(address[] _beneficiaries) external onlyOwner {
}
/**
* @dev Removes single address from whitelist.
* @param _beneficiary Address to be removed to the whitelist
*/
function removeFromWhitelist(address _beneficiary) external onlyOwner {
}
/**
* @dev Extend parent behavior requiring beneficiary to be in whitelist.
* @param _beneficiary Token beneficiary
* @param _weiAmount Amount of wei contributed
*/
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
) internal isWhitelisted(_beneficiary) {
}
}
contract CappedCrowdsalePerTx is Crowdsale {
using SafeMath for uint256;
uint256 public investorMinCap = 0;
uint256 public investorHardCap = 1660000000000000000;
mapping(address => uint256) public contributions;
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
) internal {
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
/**
* @dev Checks whether the cap has been reached.
* @return Whether the cap was reached
*/
function capReached() public view returns (bool) {
}
/**
* @dev Extend parent behavior requiring purchase to respect the funding cap.
* @param _beneficiary Token purchaser
* @param _weiAmount Amount of wei contributed
*/
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
) internal {
super._preValidatePurchase(_beneficiary, _weiAmount);
require(<FILL_ME>)
}
}
| weiRaised.add(_weiAmount)<=200000000000000000000 | 204,153 | weiRaised.add(_weiAmount)<=200000000000000000000 |
"ECPhoenixBurn: not enough funds." | //SPDX-License-Identifier: Unlicensed
pragma solidity >=0.8.7;
/***
* ███████ ████████ ██ ██ ███████ ██████ ██████ █████ ██████ ██████ ███████
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* █████ ██ ███████ █████ ██████ ██ ███████ ██████ ██ ██ ███████
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ███████ ██ ██ ██ ███████ ██ ██ ██ ██████ ██ ██ ██ ██ ██████ ███████
*
*
* ██████ ██ ██ ██████ ███████ ███ ██ ██ ██ ██ ██████ ██ ██ ██████ ███ ██
* ██ ██ ██ ██ ██ ██ ██ ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ████ ██
* ██████ ███████ ██ ██ █████ ██ ██ ██ ██ ███ ██████ ██ ██ ██████ ██ ██ ██
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ██ ██ ██ ██████ ███████ ██ ████ ██ ██ ██ ██████ ██████ ██ ██ ██ ████
*
* ETHER.CARDS - PHOENIX BURN
*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
interface ITraitRegistry {
function addressCanModifyTrait(address, uint16) external view returns (bool);
function hasTrait(uint16 traitID, uint16 tokenID) external view returns (bool);
function setTrait(uint16 traitID, uint16 tokenID, bool) external;
function traits(uint16 traitID) external view returns (string memory, address, uint8, uint16, uint16);
}
interface IERC721 {
function ownerOf(uint256) external view returns (address);
function transferFrom(address from, address to, uint256 tokenId) external;
}
interface IERC20 {
function transfer(address to, uint256 amount) external returns (bool);
}
contract ECPhoenixBurn is Ownable {
using EnumerableSet for EnumerableSet.AddressSet;
// onlyOwner can change contractControllers and transfer it's ownership
// any contractController can setData
EnumerableSet.AddressSet contractController;
IERC721 public erc721; // Ether Cards
ITraitRegistry public registry; // Trait registry
bool public locked = false;
uint256 public startTime = 1648771200; // Fri Apr 01 2022 00:00:00 GMT+0000
uint256 public endTime = 1651363200; // Sun May 01 2022 00:00:00 GMT+0000
uint16 public burnCount = 0;
uint16 public maxCount = 1945;
uint16 public PhoenixTraitId = 42;
event contractControllerEvent(address _address, bool mode);
constructor(
address _erc721,
address _registry
) {
}
receive() external payable {}
function amount() public virtual pure returns(uint256) {
}
function burn(uint16[] memory tokenId) public {
require(!locked, "ECPhoenixBurn: contract locked.");
require(tokenId.length > 0, "ECPhoenixBurn: at least 1 token.");
require(<FILL_ME>)
require(getTimestamp() > startTime, "ECPhoenixBurn: before start time.");
require(getTimestamp() < endTime, "ECPhoenixBurn: after end time.");
// Phoenix is a type 2 - range with inverted values, outside range actual values
// Load trait ranges
(,,,uint16 _start, uint16 _end) = registry.traits(PhoenixTraitId);
for(uint8 i = 0; i < tokenId.length; i++) {
uint16 currentTokenId = tokenId[i];
require(erc721.ownerOf(currentTokenId) == msg.sender, "ECPhoenixBurn: not owner of token.");
require(registry.hasTrait(PhoenixTraitId, currentTokenId), "ECPhoenixBurn: trait not found on token.");
// inverted values for everything
// need to send true to disable
bool traitOffValue = true;
// if token in range, flip value
if(_start <= currentTokenId && currentTokenId <= _end) {
traitOffValue = !traitOffValue;
}
registry.setTrait(PhoenixTraitId, currentTokenId, traitOffValue);
}
uint256 _amount = tokenId.length * amount();
burnCount += uint16(tokenId.length);
(bool sent, ) = msg.sender.call{value: _amount}(""); // don't use send or xfer (gas)
require(sent, "ECPhoenixBurn: failed to send ether.");
}
function getTimestamp() public view virtual returns (uint256) {
}
struct contractInfo {
address erc721;
address registry;
bool locked;
uint256 startTime;
uint256 endTime;
uint256 amount;
uint256 burnCount;
uint256 maxCount;
uint256 PhoenixTraitId;
uint256 contractBalance;
bool claimAvailable;
}
function tellEverything() external view returns (contractInfo memory) {
}
/*
* Admin Stuff
*/
function setContractController(address _controller, bool _mode) public onlyOwner {
}
function getContractControllerLength() public view returns (uint256) {
}
function getContractControllerAt(uint256 _index) public view returns (address) {
}
function getContractControllerContains(address _addr) public view returns (bool) {
}
function toggleLock() public onlyAllowed {
}
// blackhole prevention methods
function drain() external onlyOwner {
}
function retrieveERC20(address _tracker, uint256 _amount) external onlyAllowed {
}
function retrieve721(address _tracker, uint256 id) external onlyAllowed {
}
modifier onlyAllowed() {
}
}
| address(this).balance>tokenId.length*amount(),"ECPhoenixBurn: not enough funds." | 204,317 | address(this).balance>tokenId.length*amount() |
"ECPhoenixBurn: before start time." | //SPDX-License-Identifier: Unlicensed
pragma solidity >=0.8.7;
/***
* ███████ ████████ ██ ██ ███████ ██████ ██████ █████ ██████ ██████ ███████
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* █████ ██ ███████ █████ ██████ ██ ███████ ██████ ██ ██ ███████
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ███████ ██ ██ ██ ███████ ██ ██ ██ ██████ ██ ██ ██ ██ ██████ ███████
*
*
* ██████ ██ ██ ██████ ███████ ███ ██ ██ ██ ██ ██████ ██ ██ ██████ ███ ██
* ██ ██ ██ ██ ██ ██ ██ ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ████ ██
* ██████ ███████ ██ ██ █████ ██ ██ ██ ██ ███ ██████ ██ ██ ██████ ██ ██ ██
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ██ ██ ██ ██████ ███████ ██ ████ ██ ██ ██ ██████ ██████ ██ ██ ██ ████
*
* ETHER.CARDS - PHOENIX BURN
*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
interface ITraitRegistry {
function addressCanModifyTrait(address, uint16) external view returns (bool);
function hasTrait(uint16 traitID, uint16 tokenID) external view returns (bool);
function setTrait(uint16 traitID, uint16 tokenID, bool) external;
function traits(uint16 traitID) external view returns (string memory, address, uint8, uint16, uint16);
}
interface IERC721 {
function ownerOf(uint256) external view returns (address);
function transferFrom(address from, address to, uint256 tokenId) external;
}
interface IERC20 {
function transfer(address to, uint256 amount) external returns (bool);
}
contract ECPhoenixBurn is Ownable {
using EnumerableSet for EnumerableSet.AddressSet;
// onlyOwner can change contractControllers and transfer it's ownership
// any contractController can setData
EnumerableSet.AddressSet contractController;
IERC721 public erc721; // Ether Cards
ITraitRegistry public registry; // Trait registry
bool public locked = false;
uint256 public startTime = 1648771200; // Fri Apr 01 2022 00:00:00 GMT+0000
uint256 public endTime = 1651363200; // Sun May 01 2022 00:00:00 GMT+0000
uint16 public burnCount = 0;
uint16 public maxCount = 1945;
uint16 public PhoenixTraitId = 42;
event contractControllerEvent(address _address, bool mode);
constructor(
address _erc721,
address _registry
) {
}
receive() external payable {}
function amount() public virtual pure returns(uint256) {
}
function burn(uint16[] memory tokenId) public {
require(!locked, "ECPhoenixBurn: contract locked.");
require(tokenId.length > 0, "ECPhoenixBurn: at least 1 token.");
require(address(this).balance > tokenId.length * amount(), "ECPhoenixBurn: not enough funds.");
require(<FILL_ME>)
require(getTimestamp() < endTime, "ECPhoenixBurn: after end time.");
// Phoenix is a type 2 - range with inverted values, outside range actual values
// Load trait ranges
(,,,uint16 _start, uint16 _end) = registry.traits(PhoenixTraitId);
for(uint8 i = 0; i < tokenId.length; i++) {
uint16 currentTokenId = tokenId[i];
require(erc721.ownerOf(currentTokenId) == msg.sender, "ECPhoenixBurn: not owner of token.");
require(registry.hasTrait(PhoenixTraitId, currentTokenId), "ECPhoenixBurn: trait not found on token.");
// inverted values for everything
// need to send true to disable
bool traitOffValue = true;
// if token in range, flip value
if(_start <= currentTokenId && currentTokenId <= _end) {
traitOffValue = !traitOffValue;
}
registry.setTrait(PhoenixTraitId, currentTokenId, traitOffValue);
}
uint256 _amount = tokenId.length * amount();
burnCount += uint16(tokenId.length);
(bool sent, ) = msg.sender.call{value: _amount}(""); // don't use send or xfer (gas)
require(sent, "ECPhoenixBurn: failed to send ether.");
}
function getTimestamp() public view virtual returns (uint256) {
}
struct contractInfo {
address erc721;
address registry;
bool locked;
uint256 startTime;
uint256 endTime;
uint256 amount;
uint256 burnCount;
uint256 maxCount;
uint256 PhoenixTraitId;
uint256 contractBalance;
bool claimAvailable;
}
function tellEverything() external view returns (contractInfo memory) {
}
/*
* Admin Stuff
*/
function setContractController(address _controller, bool _mode) public onlyOwner {
}
function getContractControllerLength() public view returns (uint256) {
}
function getContractControllerAt(uint256 _index) public view returns (address) {
}
function getContractControllerContains(address _addr) public view returns (bool) {
}
function toggleLock() public onlyAllowed {
}
// blackhole prevention methods
function drain() external onlyOwner {
}
function retrieveERC20(address _tracker, uint256 _amount) external onlyAllowed {
}
function retrieve721(address _tracker, uint256 id) external onlyAllowed {
}
modifier onlyAllowed() {
}
}
| getTimestamp()>startTime,"ECPhoenixBurn: before start time." | 204,317 | getTimestamp()>startTime |
"ECPhoenixBurn: after end time." | //SPDX-License-Identifier: Unlicensed
pragma solidity >=0.8.7;
/***
* ███████ ████████ ██ ██ ███████ ██████ ██████ █████ ██████ ██████ ███████
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* █████ ██ ███████ █████ ██████ ██ ███████ ██████ ██ ██ ███████
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ███████ ██ ██ ██ ███████ ██ ██ ██ ██████ ██ ██ ██ ██ ██████ ███████
*
*
* ██████ ██ ██ ██████ ███████ ███ ██ ██ ██ ██ ██████ ██ ██ ██████ ███ ██
* ██ ██ ██ ██ ██ ██ ██ ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ████ ██
* ██████ ███████ ██ ██ █████ ██ ██ ██ ██ ███ ██████ ██ ██ ██████ ██ ██ ██
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ██ ██ ██ ██████ ███████ ██ ████ ██ ██ ██ ██████ ██████ ██ ██ ██ ████
*
* ETHER.CARDS - PHOENIX BURN
*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
interface ITraitRegistry {
function addressCanModifyTrait(address, uint16) external view returns (bool);
function hasTrait(uint16 traitID, uint16 tokenID) external view returns (bool);
function setTrait(uint16 traitID, uint16 tokenID, bool) external;
function traits(uint16 traitID) external view returns (string memory, address, uint8, uint16, uint16);
}
interface IERC721 {
function ownerOf(uint256) external view returns (address);
function transferFrom(address from, address to, uint256 tokenId) external;
}
interface IERC20 {
function transfer(address to, uint256 amount) external returns (bool);
}
contract ECPhoenixBurn is Ownable {
using EnumerableSet for EnumerableSet.AddressSet;
// onlyOwner can change contractControllers and transfer it's ownership
// any contractController can setData
EnumerableSet.AddressSet contractController;
IERC721 public erc721; // Ether Cards
ITraitRegistry public registry; // Trait registry
bool public locked = false;
uint256 public startTime = 1648771200; // Fri Apr 01 2022 00:00:00 GMT+0000
uint256 public endTime = 1651363200; // Sun May 01 2022 00:00:00 GMT+0000
uint16 public burnCount = 0;
uint16 public maxCount = 1945;
uint16 public PhoenixTraitId = 42;
event contractControllerEvent(address _address, bool mode);
constructor(
address _erc721,
address _registry
) {
}
receive() external payable {}
function amount() public virtual pure returns(uint256) {
}
function burn(uint16[] memory tokenId) public {
require(!locked, "ECPhoenixBurn: contract locked.");
require(tokenId.length > 0, "ECPhoenixBurn: at least 1 token.");
require(address(this).balance > tokenId.length * amount(), "ECPhoenixBurn: not enough funds.");
require(getTimestamp() > startTime, "ECPhoenixBurn: before start time.");
require(<FILL_ME>)
// Phoenix is a type 2 - range with inverted values, outside range actual values
// Load trait ranges
(,,,uint16 _start, uint16 _end) = registry.traits(PhoenixTraitId);
for(uint8 i = 0; i < tokenId.length; i++) {
uint16 currentTokenId = tokenId[i];
require(erc721.ownerOf(currentTokenId) == msg.sender, "ECPhoenixBurn: not owner of token.");
require(registry.hasTrait(PhoenixTraitId, currentTokenId), "ECPhoenixBurn: trait not found on token.");
// inverted values for everything
// need to send true to disable
bool traitOffValue = true;
// if token in range, flip value
if(_start <= currentTokenId && currentTokenId <= _end) {
traitOffValue = !traitOffValue;
}
registry.setTrait(PhoenixTraitId, currentTokenId, traitOffValue);
}
uint256 _amount = tokenId.length * amount();
burnCount += uint16(tokenId.length);
(bool sent, ) = msg.sender.call{value: _amount}(""); // don't use send or xfer (gas)
require(sent, "ECPhoenixBurn: failed to send ether.");
}
function getTimestamp() public view virtual returns (uint256) {
}
struct contractInfo {
address erc721;
address registry;
bool locked;
uint256 startTime;
uint256 endTime;
uint256 amount;
uint256 burnCount;
uint256 maxCount;
uint256 PhoenixTraitId;
uint256 contractBalance;
bool claimAvailable;
}
function tellEverything() external view returns (contractInfo memory) {
}
/*
* Admin Stuff
*/
function setContractController(address _controller, bool _mode) public onlyOwner {
}
function getContractControllerLength() public view returns (uint256) {
}
function getContractControllerAt(uint256 _index) public view returns (address) {
}
function getContractControllerContains(address _addr) public view returns (bool) {
}
function toggleLock() public onlyAllowed {
}
// blackhole prevention methods
function drain() external onlyOwner {
}
function retrieveERC20(address _tracker, uint256 _amount) external onlyAllowed {
}
function retrieve721(address _tracker, uint256 id) external onlyAllowed {
}
modifier onlyAllowed() {
}
}
| getTimestamp()<endTime,"ECPhoenixBurn: after end time." | 204,317 | getTimestamp()<endTime |
"ECPhoenixBurn: not owner of token." | //SPDX-License-Identifier: Unlicensed
pragma solidity >=0.8.7;
/***
* ███████ ████████ ██ ██ ███████ ██████ ██████ █████ ██████ ██████ ███████
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* █████ ██ ███████ █████ ██████ ██ ███████ ██████ ██ ██ ███████
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ███████ ██ ██ ██ ███████ ██ ██ ██ ██████ ██ ██ ██ ██ ██████ ███████
*
*
* ██████ ██ ██ ██████ ███████ ███ ██ ██ ██ ██ ██████ ██ ██ ██████ ███ ██
* ██ ██ ██ ██ ██ ██ ██ ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ████ ██
* ██████ ███████ ██ ██ █████ ██ ██ ██ ██ ███ ██████ ██ ██ ██████ ██ ██ ██
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ██ ██ ██ ██████ ███████ ██ ████ ██ ██ ██ ██████ ██████ ██ ██ ██ ████
*
* ETHER.CARDS - PHOENIX BURN
*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
interface ITraitRegistry {
function addressCanModifyTrait(address, uint16) external view returns (bool);
function hasTrait(uint16 traitID, uint16 tokenID) external view returns (bool);
function setTrait(uint16 traitID, uint16 tokenID, bool) external;
function traits(uint16 traitID) external view returns (string memory, address, uint8, uint16, uint16);
}
interface IERC721 {
function ownerOf(uint256) external view returns (address);
function transferFrom(address from, address to, uint256 tokenId) external;
}
interface IERC20 {
function transfer(address to, uint256 amount) external returns (bool);
}
contract ECPhoenixBurn is Ownable {
using EnumerableSet for EnumerableSet.AddressSet;
// onlyOwner can change contractControllers and transfer it's ownership
// any contractController can setData
EnumerableSet.AddressSet contractController;
IERC721 public erc721; // Ether Cards
ITraitRegistry public registry; // Trait registry
bool public locked = false;
uint256 public startTime = 1648771200; // Fri Apr 01 2022 00:00:00 GMT+0000
uint256 public endTime = 1651363200; // Sun May 01 2022 00:00:00 GMT+0000
uint16 public burnCount = 0;
uint16 public maxCount = 1945;
uint16 public PhoenixTraitId = 42;
event contractControllerEvent(address _address, bool mode);
constructor(
address _erc721,
address _registry
) {
}
receive() external payable {}
function amount() public virtual pure returns(uint256) {
}
function burn(uint16[] memory tokenId) public {
require(!locked, "ECPhoenixBurn: contract locked.");
require(tokenId.length > 0, "ECPhoenixBurn: at least 1 token.");
require(address(this).balance > tokenId.length * amount(), "ECPhoenixBurn: not enough funds.");
require(getTimestamp() > startTime, "ECPhoenixBurn: before start time.");
require(getTimestamp() < endTime, "ECPhoenixBurn: after end time.");
// Phoenix is a type 2 - range with inverted values, outside range actual values
// Load trait ranges
(,,,uint16 _start, uint16 _end) = registry.traits(PhoenixTraitId);
for(uint8 i = 0; i < tokenId.length; i++) {
uint16 currentTokenId = tokenId[i];
require(<FILL_ME>)
require(registry.hasTrait(PhoenixTraitId, currentTokenId), "ECPhoenixBurn: trait not found on token.");
// inverted values for everything
// need to send true to disable
bool traitOffValue = true;
// if token in range, flip value
if(_start <= currentTokenId && currentTokenId <= _end) {
traitOffValue = !traitOffValue;
}
registry.setTrait(PhoenixTraitId, currentTokenId, traitOffValue);
}
uint256 _amount = tokenId.length * amount();
burnCount += uint16(tokenId.length);
(bool sent, ) = msg.sender.call{value: _amount}(""); // don't use send or xfer (gas)
require(sent, "ECPhoenixBurn: failed to send ether.");
}
function getTimestamp() public view virtual returns (uint256) {
}
struct contractInfo {
address erc721;
address registry;
bool locked;
uint256 startTime;
uint256 endTime;
uint256 amount;
uint256 burnCount;
uint256 maxCount;
uint256 PhoenixTraitId;
uint256 contractBalance;
bool claimAvailable;
}
function tellEverything() external view returns (contractInfo memory) {
}
/*
* Admin Stuff
*/
function setContractController(address _controller, bool _mode) public onlyOwner {
}
function getContractControllerLength() public view returns (uint256) {
}
function getContractControllerAt(uint256 _index) public view returns (address) {
}
function getContractControllerContains(address _addr) public view returns (bool) {
}
function toggleLock() public onlyAllowed {
}
// blackhole prevention methods
function drain() external onlyOwner {
}
function retrieveERC20(address _tracker, uint256 _amount) external onlyAllowed {
}
function retrieve721(address _tracker, uint256 id) external onlyAllowed {
}
modifier onlyAllowed() {
}
}
| erc721.ownerOf(currentTokenId)==msg.sender,"ECPhoenixBurn: not owner of token." | 204,317 | erc721.ownerOf(currentTokenId)==msg.sender |
"ECPhoenixBurn: trait not found on token." | //SPDX-License-Identifier: Unlicensed
pragma solidity >=0.8.7;
/***
* ███████ ████████ ██ ██ ███████ ██████ ██████ █████ ██████ ██████ ███████
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* █████ ██ ███████ █████ ██████ ██ ███████ ██████ ██ ██ ███████
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ███████ ██ ██ ██ ███████ ██ ██ ██ ██████ ██ ██ ██ ██ ██████ ███████
*
*
* ██████ ██ ██ ██████ ███████ ███ ██ ██ ██ ██ ██████ ██ ██ ██████ ███ ██
* ██ ██ ██ ██ ██ ██ ██ ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ████ ██
* ██████ ███████ ██ ██ █████ ██ ██ ██ ██ ███ ██████ ██ ██ ██████ ██ ██ ██
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ██ ██ ██ ██████ ███████ ██ ████ ██ ██ ██ ██████ ██████ ██ ██ ██ ████
*
* ETHER.CARDS - PHOENIX BURN
*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
interface ITraitRegistry {
function addressCanModifyTrait(address, uint16) external view returns (bool);
function hasTrait(uint16 traitID, uint16 tokenID) external view returns (bool);
function setTrait(uint16 traitID, uint16 tokenID, bool) external;
function traits(uint16 traitID) external view returns (string memory, address, uint8, uint16, uint16);
}
interface IERC721 {
function ownerOf(uint256) external view returns (address);
function transferFrom(address from, address to, uint256 tokenId) external;
}
interface IERC20 {
function transfer(address to, uint256 amount) external returns (bool);
}
contract ECPhoenixBurn is Ownable {
using EnumerableSet for EnumerableSet.AddressSet;
// onlyOwner can change contractControllers and transfer it's ownership
// any contractController can setData
EnumerableSet.AddressSet contractController;
IERC721 public erc721; // Ether Cards
ITraitRegistry public registry; // Trait registry
bool public locked = false;
uint256 public startTime = 1648771200; // Fri Apr 01 2022 00:00:00 GMT+0000
uint256 public endTime = 1651363200; // Sun May 01 2022 00:00:00 GMT+0000
uint16 public burnCount = 0;
uint16 public maxCount = 1945;
uint16 public PhoenixTraitId = 42;
event contractControllerEvent(address _address, bool mode);
constructor(
address _erc721,
address _registry
) {
}
receive() external payable {}
function amount() public virtual pure returns(uint256) {
}
function burn(uint16[] memory tokenId) public {
require(!locked, "ECPhoenixBurn: contract locked.");
require(tokenId.length > 0, "ECPhoenixBurn: at least 1 token.");
require(address(this).balance > tokenId.length * amount(), "ECPhoenixBurn: not enough funds.");
require(getTimestamp() > startTime, "ECPhoenixBurn: before start time.");
require(getTimestamp() < endTime, "ECPhoenixBurn: after end time.");
// Phoenix is a type 2 - range with inverted values, outside range actual values
// Load trait ranges
(,,,uint16 _start, uint16 _end) = registry.traits(PhoenixTraitId);
for(uint8 i = 0; i < tokenId.length; i++) {
uint16 currentTokenId = tokenId[i];
require(erc721.ownerOf(currentTokenId) == msg.sender, "ECPhoenixBurn: not owner of token.");
require(<FILL_ME>)
// inverted values for everything
// need to send true to disable
bool traitOffValue = true;
// if token in range, flip value
if(_start <= currentTokenId && currentTokenId <= _end) {
traitOffValue = !traitOffValue;
}
registry.setTrait(PhoenixTraitId, currentTokenId, traitOffValue);
}
uint256 _amount = tokenId.length * amount();
burnCount += uint16(tokenId.length);
(bool sent, ) = msg.sender.call{value: _amount}(""); // don't use send or xfer (gas)
require(sent, "ECPhoenixBurn: failed to send ether.");
}
function getTimestamp() public view virtual returns (uint256) {
}
struct contractInfo {
address erc721;
address registry;
bool locked;
uint256 startTime;
uint256 endTime;
uint256 amount;
uint256 burnCount;
uint256 maxCount;
uint256 PhoenixTraitId;
uint256 contractBalance;
bool claimAvailable;
}
function tellEverything() external view returns (contractInfo memory) {
}
/*
* Admin Stuff
*/
function setContractController(address _controller, bool _mode) public onlyOwner {
}
function getContractControllerLength() public view returns (uint256) {
}
function getContractControllerAt(uint256 _index) public view returns (address) {
}
function getContractControllerContains(address _addr) public view returns (bool) {
}
function toggleLock() public onlyAllowed {
}
// blackhole prevention methods
function drain() external onlyOwner {
}
function retrieveERC20(address _tracker, uint256 _amount) external onlyAllowed {
}
function retrieve721(address _tracker, uint256 id) external onlyAllowed {
}
modifier onlyAllowed() {
}
}
| registry.hasTrait(PhoenixTraitId,currentTokenId),"ECPhoenixBurn: trait not found on token." | 204,317 | registry.hasTrait(PhoenixTraitId,currentTokenId) |
"Sender Blacklisted" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() external pure returns (address);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
abstract contract Auth {
address internal _owner;
event OwnershipTransferred(address _owner);
constructor(address creatorOwner) { }
modifier onlyOwner() { }
function owner() public view returns (address) { }
function renounceOwnership() external onlyOwner {
}
}
contract TeamMusk is IERC20, Auth {
string private constant _name = "Team Musk";
string private constant _symbol = "MUSK";
uint8 private constant _decimals = 18;
uint256 private constant _totalSupply = 1_000_000_000_000 * (10**_decimals);
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isBlackListed;
mapping (address => bool) private isWhitelisted;
mapping (address => bool) private _noFees;
address payable private _walletMarketing;
address payable private _walletPrizePool;
address payable private _walletBuyBack;
uint256 private constant _taxSwapMin = _totalSupply / 200000;
uint256 private constant _taxSwapMax = _totalSupply / 500;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IUniswapV2Router02 private _primarySwapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping (address => bool) private _isLP;
uint256 private _tax = 500;
uint256 private _epochForBoostedPrizePool;
bool public limited = true;
uint256 public maxHoldingAmount = 10_000_000_001 * (10**_decimals); // 1%
uint256 public minHoldingAmount = 100_000_000 * (10**_decimals); // 0.01%;
bool private _tradingOpen;
bool private _inTaxSwap = false;
modifier lockTaxSwap {
}
constructor(address cexWallet, address marketingWallet, address buyBackWallet, address prizePoolWallet, address[] memory _users) Auth(msg.sender) {
}
receive() external payable {}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function tax() external view returns (uint256) { }
function prizePoolBoostStart() external view returns (uint256) { }
function marketingMultisig() external view returns (address) { }
function BuyBackMultisig() external view returns (address) { }
function PrizePoolMultisig() external view returns (address) { }
function getPrizePoolBalance() external view returns (uint256){ }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
require(sender != address(0), "No transfers from Zero wallet");
require(<FILL_ME>)
require(!isBlackListed[recipient], "Receiver Blacklisted");
if (!_tradingOpen) { require(_noFees[sender], "Trading not open"); }
if ( !_inTaxSwap && _isLP[recipient] ) { _swapTaxAndLiquify(); }
if (limited && sender == _primaryLP) {
require(balanceOf(recipient) + amount <= maxHoldingAmount && balanceOf(recipient) + amount >= minHoldingAmount, "Forbid");
require(isWhitelisted[sender] || isWhitelisted[recipient], "Forbid");
}
uint256 _taxAmount = _calculateTax(sender, recipient, amount);
uint256 _transferAmount = amount - _taxAmount;
_balances[sender] -= amount;
if ( _taxAmount > 0 ) {
_balances[address(this)] += _taxAmount;
}
_balances[recipient] += _transferAmount;
emit Transfer(sender, recipient, amount);
return true;
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function addLiquidity() external payable onlyOwner lockTaxSwap {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei) internal {
}
function _checkTradingOpen(address sender) private view returns (bool){
}
function setMarketingWallet(address newMarketingWallet) public onlyOwner {
}
function setPrizePoolWallet(address newPrizePoolWallet) public onlyOwner {
}
function setBuyBackWallet(address newBuyBackWallet) public onlyOwner {
}
function setBlackList(address[] memory _users, bool set) public onlyOwner {
}
function setWhitelist(address[] memory _users, bool set) internal {
}
function setRule(bool _limited, uint256 _maxHoldingAmount, uint256 _minHoldingAmount) external onlyOwner {
}
function _calculateTax(address sender, address recipient, uint256 amount) internal view returns (uint256) {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 tokenAmount) private {
}
}
| !isBlackListed[sender],"Sender Blacklisted" | 204,405 | !isBlackListed[sender] |
"Receiver Blacklisted" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() external pure returns (address);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
abstract contract Auth {
address internal _owner;
event OwnershipTransferred(address _owner);
constructor(address creatorOwner) { }
modifier onlyOwner() { }
function owner() public view returns (address) { }
function renounceOwnership() external onlyOwner {
}
}
contract TeamMusk is IERC20, Auth {
string private constant _name = "Team Musk";
string private constant _symbol = "MUSK";
uint8 private constant _decimals = 18;
uint256 private constant _totalSupply = 1_000_000_000_000 * (10**_decimals);
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isBlackListed;
mapping (address => bool) private isWhitelisted;
mapping (address => bool) private _noFees;
address payable private _walletMarketing;
address payable private _walletPrizePool;
address payable private _walletBuyBack;
uint256 private constant _taxSwapMin = _totalSupply / 200000;
uint256 private constant _taxSwapMax = _totalSupply / 500;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IUniswapV2Router02 private _primarySwapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping (address => bool) private _isLP;
uint256 private _tax = 500;
uint256 private _epochForBoostedPrizePool;
bool public limited = true;
uint256 public maxHoldingAmount = 10_000_000_001 * (10**_decimals); // 1%
uint256 public minHoldingAmount = 100_000_000 * (10**_decimals); // 0.01%;
bool private _tradingOpen;
bool private _inTaxSwap = false;
modifier lockTaxSwap {
}
constructor(address cexWallet, address marketingWallet, address buyBackWallet, address prizePoolWallet, address[] memory _users) Auth(msg.sender) {
}
receive() external payable {}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function tax() external view returns (uint256) { }
function prizePoolBoostStart() external view returns (uint256) { }
function marketingMultisig() external view returns (address) { }
function BuyBackMultisig() external view returns (address) { }
function PrizePoolMultisig() external view returns (address) { }
function getPrizePoolBalance() external view returns (uint256){ }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
require(sender != address(0), "No transfers from Zero wallet");
require(!isBlackListed[sender], "Sender Blacklisted");
require(<FILL_ME>)
if (!_tradingOpen) { require(_noFees[sender], "Trading not open"); }
if ( !_inTaxSwap && _isLP[recipient] ) { _swapTaxAndLiquify(); }
if (limited && sender == _primaryLP) {
require(balanceOf(recipient) + amount <= maxHoldingAmount && balanceOf(recipient) + amount >= minHoldingAmount, "Forbid");
require(isWhitelisted[sender] || isWhitelisted[recipient], "Forbid");
}
uint256 _taxAmount = _calculateTax(sender, recipient, amount);
uint256 _transferAmount = amount - _taxAmount;
_balances[sender] -= amount;
if ( _taxAmount > 0 ) {
_balances[address(this)] += _taxAmount;
}
_balances[recipient] += _transferAmount;
emit Transfer(sender, recipient, amount);
return true;
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function addLiquidity() external payable onlyOwner lockTaxSwap {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei) internal {
}
function _checkTradingOpen(address sender) private view returns (bool){
}
function setMarketingWallet(address newMarketingWallet) public onlyOwner {
}
function setPrizePoolWallet(address newPrizePoolWallet) public onlyOwner {
}
function setBuyBackWallet(address newBuyBackWallet) public onlyOwner {
}
function setBlackList(address[] memory _users, bool set) public onlyOwner {
}
function setWhitelist(address[] memory _users, bool set) internal {
}
function setRule(bool _limited, uint256 _maxHoldingAmount, uint256 _minHoldingAmount) external onlyOwner {
}
function _calculateTax(address sender, address recipient, uint256 amount) internal view returns (uint256) {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 tokenAmount) private {
}
}
| !isBlackListed[recipient],"Receiver Blacklisted" | 204,405 | !isBlackListed[recipient] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.