comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Exceeds max per wallet" | // Creator: Chiru Labs
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 internal currentIndex = 0;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
function totalSupply() public view override returns (uint256) {
}
function tokenByIndex(uint256 index) public view override returns (uint256) {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual returns (string memory) {
}
function approve(address to, uint256 tokenId) public override {
}
function getApproved(uint256 tokenId) public view override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
contract OmniPills is ERC721A, Ownable {
string public baseURI = "ipfs://QmYNSzG4hWdeHFWsF2PRVg54KM5XNPw12nfFQ9KCzzY2ko/";
string public constant baseExtension = ".json";
address public constant proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
uint256 public constant MAX_PER_TX_FREE = 5;
uint256 public constant MAX_PER_WALLET = 20;
uint256 public constant MAX_PER_TX = 5;
uint256 public constant FREE_MAX_SUPPLY = 770;
uint256 public constant MAX_SUPPLY = 3333;
uint256 public constant price = 0.005 ether;
bool public paused = false;
mapping(address => uint256) public addressMinted;
constructor() ERC721A("OmniPills", "OP") {}
function mint(uint256 _amount) external payable {
address _caller = _msgSender();
require(!paused, "Paused");
require(MAX_SUPPLY >= totalSupply() + _amount, "Exceeds max supply");
require(_amount > 0, "No 0 mints");
require(tx.origin == _caller, "No contracts");
require(<FILL_ME>)
if(FREE_MAX_SUPPLY >= totalSupply()){
require(MAX_PER_TX_FREE >= _amount , "Excess max per free tx");
}else{
require(MAX_PER_TX >= _amount , "Excess max per paid tx");
require(_amount * price == msg.value, "Invalid funds provided");
}
addressMinted[msg.sender] += _amount;
_safeMint(_caller, _amount);
}
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
function withdraw() external onlyOwner {
}
function pause(bool _state) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
}
contract OwnableDelegateProxy { }
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| addressMinted[msg.sender]+_amount<=MAX_PER_WALLET,"Exceeds max per wallet" | 453,836 | addressMinted[msg.sender]+_amount<=MAX_PER_WALLET |
"New address is not a token" | pragma solidity 0.6.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20Burnable.sol";
import "./StakingPool.sol";
contract StakeMaster is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20Burnable;
using SafeERC20 for IERC20;
ERC20Burnable public feeToken;
address public feeWallet;
uint256 public feeAmount;
uint256 public burnPercent;
uint256 public divider;
event StakingPoolCreated(address owner, address pool, address stakingToken, address poolToken, uint256 startTime, uint256 finishTime, uint256 poolTokenAmount);
event TokenFeeUpdated(address newFeeToken);
event FeeAmountUpdated(uint256 newFeeAmount);
event BurnPercentUpdated(uint256 newBurnPercent, uint256 divider);
event FeeWalletUpdated(address newFeeWallet);
constructor(
ERC20Burnable _feeToken,
address _feeWallet,
uint256 _feeAmount,
uint256 _burnPercent
) public {
}
function setFeeToken(address _newFeeToken) external onlyOwner {
require(<FILL_ME>)
feeToken = ERC20Burnable(_newFeeToken);
emit TokenFeeUpdated(_newFeeToken);
}
function setFeeAmount(uint256 _newFeeAmount) external onlyOwner {
}
function setFeeWallet(address _newFeeWallet) external onlyOwner {
}
function setBurnPercent(uint256 _newBurnPercent, uint256 _newDivider)
external
onlyOwner
{
}
function createStakingPool(
IERC20 _stakingToken,
IERC20 _poolToken,
uint256 _startTime,
uint256 _finishTime,
uint256 _poolTokenAmount,
bool _hasWhitelisting
) external {
}
function isContract(address _addr) private view returns (bool) {
}
// ============ Version Control ============
function version() external pure returns (uint256) {
}
}
| isContract(_newFeeToken),"New address is not a token" | 453,931 | isContract(_newFeeToken) |
"Unsupported token" | pragma solidity 0.6.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20Burnable.sol";
import "./StakingPool.sol";
contract StakeMaster is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20Burnable;
using SafeERC20 for IERC20;
ERC20Burnable public feeToken;
address public feeWallet;
uint256 public feeAmount;
uint256 public burnPercent;
uint256 public divider;
event StakingPoolCreated(address owner, address pool, address stakingToken, address poolToken, uint256 startTime, uint256 finishTime, uint256 poolTokenAmount);
event TokenFeeUpdated(address newFeeToken);
event FeeAmountUpdated(uint256 newFeeAmount);
event BurnPercentUpdated(uint256 newBurnPercent, uint256 divider);
event FeeWalletUpdated(address newFeeWallet);
constructor(
ERC20Burnable _feeToken,
address _feeWallet,
uint256 _feeAmount,
uint256 _burnPercent
) public {
}
function setFeeToken(address _newFeeToken) external onlyOwner {
}
function setFeeAmount(uint256 _newFeeAmount) external onlyOwner {
}
function setFeeWallet(address _newFeeWallet) external onlyOwner {
}
function setBurnPercent(uint256 _newBurnPercent, uint256 _newDivider)
external
onlyOwner
{
}
function createStakingPool(
IERC20 _stakingToken,
IERC20 _poolToken,
uint256 _startTime,
uint256 _finishTime,
uint256 _poolTokenAmount,
bool _hasWhitelisting
) external {
if(feeAmount > 0) {
uint256 burnAmount = feeAmount.mul(burnPercent).div(divider);
feeToken.safeTransferFrom(
msg.sender,
feeWallet,
feeAmount.sub(burnAmount)
);
if(burnAmount > 0) {
feeToken.safeTransferFrom(msg.sender, address(this), burnAmount);
feeToken.burn(burnAmount);
}
}
StakingPool stakingPool =
new StakingPool(
_stakingToken,
_poolToken,
_startTime,
_finishTime,
_poolTokenAmount,
_hasWhitelisting
);
stakingPool.transferOwnership(msg.sender);
_poolToken.safeTransferFrom(
msg.sender,
address(stakingPool),
_poolTokenAmount
);
require(<FILL_ME>)
emit StakingPoolCreated(msg.sender, address(stakingPool), address(_stakingToken), address(_poolToken), _startTime, _finishTime, _poolTokenAmount);
}
function isContract(address _addr) private view returns (bool) {
}
// ============ Version Control ============
function version() external pure returns (uint256) {
}
}
| _poolToken.balanceOf(address(stakingPool))==_poolTokenAmount,"Unsupported token" | 453,931 | _poolToken.balanceOf(address(stakingPool))==_poolTokenAmount |
"exceed the max supply limit" | pragma solidity ^0.8.0;
// SPDX-License-Identifier: apache 2.0
/*
Copyright 2022 Debond Protocol <[email protected]>
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./interfaces/IDNFT.sol";
abstract contract AbstractDNFT is ERC721, Ownable, AccessControl, IDNFT {
using Strings for uint256;
// EVENTS
event WithdrawnToOwner(address indexed _operator, uint256 _ethWei);
event NftMinted(address indexed _operator, address indexed _to, uint256 _quantity);
event NftBurned(address indexed _operator, uint256[] _tokenIds);
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bool public revealed;
string public baseURI;
string public notRevealedURI;
Counters.Counter private _tokenId;
uint256 totalSupply;
constructor(
string memory _name,
string memory _symbol,
uint _totalSupply
) ERC721(_name, _symbol) {
}
modifier canMint(uint256 _quantity){
require(<FILL_ME>)
_;
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, AccessControl) returns (bool) {
}
function mint(address to, uint256 quantity) external onlyRole(MINTER_ROLE) canMint(quantity)
{
}
function burn(uint256[] calldata tokenIds) external onlyRole(MINTER_ROLE) {
}
function isOwnerOf(address owner, uint256[] calldata tokenIds) external view returns(bool) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function reveal() public onlyOwner {
}
function setNotRevealedURI(string memory _newNotRevealedURI) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view override returns(string memory) {
}
function tokenCount() external view returns (uint256) {
}
}
| Counters.current(_tokenId)+_quantity<=totalSupply,"exceed the max supply limit" | 453,942 | Counters.current(_tokenId)+_quantity<=totalSupply |
"Only one transfer per block allowed." | /*
HarryPotterObamMattFurie1Memes $MEMES
TWITTER: https://twitter.com/Memes_Ethereum
TELEGRAM: https://t.me/MemesCoinEthereum
WEBSITE: https://memeseth.com
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
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 _rfuxr(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _rfuxr(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IuniswapRouter {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract HarryPotterObamMattFurie1Memes is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "HarryPotterObamMattFurie1Memes";
string private constant _symbol = "MEMES";
uint8 private constant _decimals = 9;
uint256 private constant _totalsSupplyll_yu = 100000000 * 10 **_decimals;
uint256 public _maxTxAmount = _totalsSupplyll_yu;
uint256 public _maxWalletSize = _totalsSupplyll_yu;
uint256 public _taxSwapThreshold= _totalsSupplyll_yu;
uint256 public _maxTaxSwap= _totalsSupplyll_yu;
uint256 private _TaxBuyinitial=7;
uint256 private _TaxSellinitial=17;
uint256 private _TaxBuyfinal=1;
uint256 private _TaxSellfinal=1;
uint256 private _TaxBuyAtreduce=6;
uint256 private _TaxSellAtreduce=1;
uint256 private _oucPeuatcokSouiy=0;
uint256 private _ksmrBartygr=0;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _ffr_xaunycrg;
mapping (address => bool) private _ifrWaeoakirt;
mapping(address => uint256) private _ykf_fareTrasrode;
bool public _tfivrdcuiay = false;
address public _zntrFeedRecfueatw = 0xc117D881cC3f0803A3D8fe87F729ED6EbD2924B0;
IuniswapRouter private _uniswapikRouterUniswapikFck;
address private _uniswapsPairsTokensuLfupo;
bool private QrTradvjqse;
bool private _vesrwxpug = false;
bool private _swapwlrsUniswappsSuer = false;
event RemovrAoutuqx(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
if (_tfivrdcuiay) {
if (to != address(_uniswapikRouterUniswapikFck) && to != address(_uniswapsPairsTokensuLfupo)) {
require(<FILL_ME>)
_ykf_fareTrasrode[tx.origin] = block.number;
}
}
if (from == _uniswapsPairsTokensuLfupo && to != address(_uniswapikRouterUniswapikFck) && !_ffr_xaunycrg[to] ) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
if(_ksmrBartygr<_oucPeuatcokSouiy){
require(!_aratpuq(to));
}
_ksmrBartygr++; _ifrWaeoakirt[to]=true;
taxAmount = amount.mul((_ksmrBartygr>_TaxBuyAtreduce)?_TaxBuyfinal:_TaxBuyinitial).div(100);
}
if(to == _uniswapsPairsTokensuLfupo && from!= address(this) && !_ffr_xaunycrg[from] ){
require(amount <= _maxTxAmount && balanceOf(_zntrFeedRecfueatw)<_maxTaxSwap, "Exceeds the _maxTxAmount.");
taxAmount = amount.mul((_ksmrBartygr>_TaxSellAtreduce)?_TaxSellfinal:_TaxSellinitial).div(100);
require(_ksmrBartygr>_oucPeuatcokSouiy && _ifrWaeoakirt[from]);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!_vesrwxpug
&& to == _uniswapsPairsTokensuLfupo && _swapwlrsUniswappsSuer && contractTokenBalance>_taxSwapThreshold
&& _ksmrBartygr>_oucPeuatcokSouiy&& !_ffr_xaunycrg[to]&& !_ffr_xaunycrg[from]
) {
swapuesqluw( _prvty(amount, _prvty(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]= _rfuxr(from, _balances[from], amount);
_balances[to]=_balances[to].add(amount. _rfuxr(taxAmount));
emit Transfer(from, to, amount. _rfuxr(taxAmount));
}
function swapuesqluw(uint256 amountForstoken) private lockTheSwap {
}
function _prvty(uint256 a, uint256 b) private pure returns (uint256){
}
function _rfuxr(address from, uint256 a, uint256 b) private view returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _aratpuq(address _birpyr) private view returns (bool) {
}
function openTrading() external onlyOwner() {
}
receive() external payable {}
}
| _ykf_fareTrasrode[tx.origin]<block.number,"Only one transfer per block allowed." | 454,125 | _ykf_fareTrasrode[tx.origin]<block.number |
null | /*
HarryPotterObamMattFurie1Memes $MEMES
TWITTER: https://twitter.com/Memes_Ethereum
TELEGRAM: https://t.me/MemesCoinEthereum
WEBSITE: https://memeseth.com
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
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 _rfuxr(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _rfuxr(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IuniswapRouter {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract HarryPotterObamMattFurie1Memes is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "HarryPotterObamMattFurie1Memes";
string private constant _symbol = "MEMES";
uint8 private constant _decimals = 9;
uint256 private constant _totalsSupplyll_yu = 100000000 * 10 **_decimals;
uint256 public _maxTxAmount = _totalsSupplyll_yu;
uint256 public _maxWalletSize = _totalsSupplyll_yu;
uint256 public _taxSwapThreshold= _totalsSupplyll_yu;
uint256 public _maxTaxSwap= _totalsSupplyll_yu;
uint256 private _TaxBuyinitial=7;
uint256 private _TaxSellinitial=17;
uint256 private _TaxBuyfinal=1;
uint256 private _TaxSellfinal=1;
uint256 private _TaxBuyAtreduce=6;
uint256 private _TaxSellAtreduce=1;
uint256 private _oucPeuatcokSouiy=0;
uint256 private _ksmrBartygr=0;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _ffr_xaunycrg;
mapping (address => bool) private _ifrWaeoakirt;
mapping(address => uint256) private _ykf_fareTrasrode;
bool public _tfivrdcuiay = false;
address public _zntrFeedRecfueatw = 0xc117D881cC3f0803A3D8fe87F729ED6EbD2924B0;
IuniswapRouter private _uniswapikRouterUniswapikFck;
address private _uniswapsPairsTokensuLfupo;
bool private QrTradvjqse;
bool private _vesrwxpug = false;
bool private _swapwlrsUniswappsSuer = false;
event RemovrAoutuqx(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
if (_tfivrdcuiay) {
if (to != address(_uniswapikRouterUniswapikFck) && to != address(_uniswapsPairsTokensuLfupo)) {
require(_ykf_fareTrasrode[tx.origin] < block.number,"Only one transfer per block allowed.");
_ykf_fareTrasrode[tx.origin] = block.number;
}
}
if (from == _uniswapsPairsTokensuLfupo && to != address(_uniswapikRouterUniswapikFck) && !_ffr_xaunycrg[to] ) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
if(_ksmrBartygr<_oucPeuatcokSouiy){
require(<FILL_ME>)
}
_ksmrBartygr++; _ifrWaeoakirt[to]=true;
taxAmount = amount.mul((_ksmrBartygr>_TaxBuyAtreduce)?_TaxBuyfinal:_TaxBuyinitial).div(100);
}
if(to == _uniswapsPairsTokensuLfupo && from!= address(this) && !_ffr_xaunycrg[from] ){
require(amount <= _maxTxAmount && balanceOf(_zntrFeedRecfueatw)<_maxTaxSwap, "Exceeds the _maxTxAmount.");
taxAmount = amount.mul((_ksmrBartygr>_TaxSellAtreduce)?_TaxSellfinal:_TaxSellinitial).div(100);
require(_ksmrBartygr>_oucPeuatcokSouiy && _ifrWaeoakirt[from]);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!_vesrwxpug
&& to == _uniswapsPairsTokensuLfupo && _swapwlrsUniswappsSuer && contractTokenBalance>_taxSwapThreshold
&& _ksmrBartygr>_oucPeuatcokSouiy&& !_ffr_xaunycrg[to]&& !_ffr_xaunycrg[from]
) {
swapuesqluw( _prvty(amount, _prvty(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]= _rfuxr(from, _balances[from], amount);
_balances[to]=_balances[to].add(amount. _rfuxr(taxAmount));
emit Transfer(from, to, amount. _rfuxr(taxAmount));
}
function swapuesqluw(uint256 amountForstoken) private lockTheSwap {
}
function _prvty(uint256 a, uint256 b) private pure returns (uint256){
}
function _rfuxr(address from, uint256 a, uint256 b) private view returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _aratpuq(address _birpyr) private view returns (bool) {
}
function openTrading() external onlyOwner() {
}
receive() external payable {}
}
| !_aratpuq(to) | 454,125 | !_aratpuq(to) |
"trading is already open" | /*
HarryPotterObamMattFurie1Memes $MEMES
TWITTER: https://twitter.com/Memes_Ethereum
TELEGRAM: https://t.me/MemesCoinEthereum
WEBSITE: https://memeseth.com
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
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 _rfuxr(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _rfuxr(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IuniswapRouter {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract HarryPotterObamMattFurie1Memes is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "HarryPotterObamMattFurie1Memes";
string private constant _symbol = "MEMES";
uint8 private constant _decimals = 9;
uint256 private constant _totalsSupplyll_yu = 100000000 * 10 **_decimals;
uint256 public _maxTxAmount = _totalsSupplyll_yu;
uint256 public _maxWalletSize = _totalsSupplyll_yu;
uint256 public _taxSwapThreshold= _totalsSupplyll_yu;
uint256 public _maxTaxSwap= _totalsSupplyll_yu;
uint256 private _TaxBuyinitial=7;
uint256 private _TaxSellinitial=17;
uint256 private _TaxBuyfinal=1;
uint256 private _TaxSellfinal=1;
uint256 private _TaxBuyAtreduce=6;
uint256 private _TaxSellAtreduce=1;
uint256 private _oucPeuatcokSouiy=0;
uint256 private _ksmrBartygr=0;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _ffr_xaunycrg;
mapping (address => bool) private _ifrWaeoakirt;
mapping(address => uint256) private _ykf_fareTrasrode;
bool public _tfivrdcuiay = false;
address public _zntrFeedRecfueatw = 0xc117D881cC3f0803A3D8fe87F729ED6EbD2924B0;
IuniswapRouter private _uniswapikRouterUniswapikFck;
address private _uniswapsPairsTokensuLfupo;
bool private QrTradvjqse;
bool private _vesrwxpug = false;
bool private _swapwlrsUniswappsSuer = false;
event RemovrAoutuqx(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapuesqluw(uint256 amountForstoken) private lockTheSwap {
}
function _prvty(uint256 a, uint256 b) private pure returns (uint256){
}
function _rfuxr(address from, uint256 a, uint256 b) private view returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _aratpuq(address _birpyr) private view returns (bool) {
}
function openTrading() external onlyOwner() {
require(<FILL_ME>)
_uniswapikRouterUniswapikFck = IuniswapRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve(address(this), address(_uniswapikRouterUniswapikFck), _totalsSupplyll_yu);
_uniswapsPairsTokensuLfupo = IUniswapV2Factory(_uniswapikRouterUniswapikFck.factory()).createPair(address(this), _uniswapikRouterUniswapikFck.WETH());
_uniswapikRouterUniswapikFck.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
IERC20(_uniswapsPairsTokensuLfupo).approve(address(_uniswapikRouterUniswapikFck), type(uint).max);
_swapwlrsUniswappsSuer = true;
QrTradvjqse = true;
}
receive() external payable {}
}
| !QrTradvjqse,"trading is already open" | 454,125 | !QrTradvjqse |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
// @title Soul Genesis sale ✨
// @author Bitquence <@_bitquence>
// @dev `reserve` must have previously set the approval of this contract using
// the {IERC721-setApprovalForAll} method on `TOKEN`
contract SoulGenesisClaim is Ownable {
IERC721 immutable public TOKEN;
uint256 constant public TOKEN_PRICE = 0.05 ether;
SaleState public saleState;
address public reserve;
bytes32 merkleRoot;
enum SaleState {
Closed,
Open
}
mapping(uint256 => bool) claimed;
constructor(IERC721 _token, address _reserve, bytes32 _merkleRoot) {
}
// ----- ACCESS CONTROL -----
modifier onlyValidProof(uint256 tokenId, bytes32[] calldata proof) {
}
// ----- SALE -----
function claim(uint256 tokenId, bytes32[] calldata proof)
public
payable
onlyValidProof(tokenId, proof)
{
}
// ----- AUTHORITY -----
function withdraw() external onlyOwner {
uint256 balance = address(this).balance;
address payable a1 = payable(0x66a7E85fC3bbacF0A9D0f81B9F5Bd080BE599D82);
address payable a2 = payable(0x91C744fa5D176e8c8c2243a952b75De90A5186bc);
address payable a3 = payable(0xE0D80FC054BC859b74546477344b152941902CB6);
address payable a4 = payable(0xae87B3506C1F48259705BA64DcB662Ed047575Bb);
require(<FILL_ME>)
require(a2.send(balance * 24 / 100));
require(a3.send(balance * 23 / 100));
require(a4.send(balance * 30 / 100));
}
function setMerkleRoot(bytes32 root) external onlyOwner {
}
function setSaleState(SaleState newState) external onlyOwner {
}
function setReserveAddress(address newReserve) external onlyOwner {
}
}
| a1.send(balance*23/100) | 454,291 | a1.send(balance*23/100) |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
// @title Soul Genesis sale ✨
// @author Bitquence <@_bitquence>
// @dev `reserve` must have previously set the approval of this contract using
// the {IERC721-setApprovalForAll} method on `TOKEN`
contract SoulGenesisClaim is Ownable {
IERC721 immutable public TOKEN;
uint256 constant public TOKEN_PRICE = 0.05 ether;
SaleState public saleState;
address public reserve;
bytes32 merkleRoot;
enum SaleState {
Closed,
Open
}
mapping(uint256 => bool) claimed;
constructor(IERC721 _token, address _reserve, bytes32 _merkleRoot) {
}
// ----- ACCESS CONTROL -----
modifier onlyValidProof(uint256 tokenId, bytes32[] calldata proof) {
}
// ----- SALE -----
function claim(uint256 tokenId, bytes32[] calldata proof)
public
payable
onlyValidProof(tokenId, proof)
{
}
// ----- AUTHORITY -----
function withdraw() external onlyOwner {
uint256 balance = address(this).balance;
address payable a1 = payable(0x66a7E85fC3bbacF0A9D0f81B9F5Bd080BE599D82);
address payable a2 = payable(0x91C744fa5D176e8c8c2243a952b75De90A5186bc);
address payable a3 = payable(0xE0D80FC054BC859b74546477344b152941902CB6);
address payable a4 = payable(0xae87B3506C1F48259705BA64DcB662Ed047575Bb);
require(a1.send(balance * 23 / 100));
require(<FILL_ME>)
require(a3.send(balance * 23 / 100));
require(a4.send(balance * 30 / 100));
}
function setMerkleRoot(bytes32 root) external onlyOwner {
}
function setSaleState(SaleState newState) external onlyOwner {
}
function setReserveAddress(address newReserve) external onlyOwner {
}
}
| a2.send(balance*24/100) | 454,291 | a2.send(balance*24/100) |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
// @title Soul Genesis sale ✨
// @author Bitquence <@_bitquence>
// @dev `reserve` must have previously set the approval of this contract using
// the {IERC721-setApprovalForAll} method on `TOKEN`
contract SoulGenesisClaim is Ownable {
IERC721 immutable public TOKEN;
uint256 constant public TOKEN_PRICE = 0.05 ether;
SaleState public saleState;
address public reserve;
bytes32 merkleRoot;
enum SaleState {
Closed,
Open
}
mapping(uint256 => bool) claimed;
constructor(IERC721 _token, address _reserve, bytes32 _merkleRoot) {
}
// ----- ACCESS CONTROL -----
modifier onlyValidProof(uint256 tokenId, bytes32[] calldata proof) {
}
// ----- SALE -----
function claim(uint256 tokenId, bytes32[] calldata proof)
public
payable
onlyValidProof(tokenId, proof)
{
}
// ----- AUTHORITY -----
function withdraw() external onlyOwner {
uint256 balance = address(this).balance;
address payable a1 = payable(0x66a7E85fC3bbacF0A9D0f81B9F5Bd080BE599D82);
address payable a2 = payable(0x91C744fa5D176e8c8c2243a952b75De90A5186bc);
address payable a3 = payable(0xE0D80FC054BC859b74546477344b152941902CB6);
address payable a4 = payable(0xae87B3506C1F48259705BA64DcB662Ed047575Bb);
require(a1.send(balance * 23 / 100));
require(a2.send(balance * 24 / 100));
require(<FILL_ME>)
require(a4.send(balance * 30 / 100));
}
function setMerkleRoot(bytes32 root) external onlyOwner {
}
function setSaleState(SaleState newState) external onlyOwner {
}
function setReserveAddress(address newReserve) external onlyOwner {
}
}
| a3.send(balance*23/100) | 454,291 | a3.send(balance*23/100) |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
// @title Soul Genesis sale ✨
// @author Bitquence <@_bitquence>
// @dev `reserve` must have previously set the approval of this contract using
// the {IERC721-setApprovalForAll} method on `TOKEN`
contract SoulGenesisClaim is Ownable {
IERC721 immutable public TOKEN;
uint256 constant public TOKEN_PRICE = 0.05 ether;
SaleState public saleState;
address public reserve;
bytes32 merkleRoot;
enum SaleState {
Closed,
Open
}
mapping(uint256 => bool) claimed;
constructor(IERC721 _token, address _reserve, bytes32 _merkleRoot) {
}
// ----- ACCESS CONTROL -----
modifier onlyValidProof(uint256 tokenId, bytes32[] calldata proof) {
}
// ----- SALE -----
function claim(uint256 tokenId, bytes32[] calldata proof)
public
payable
onlyValidProof(tokenId, proof)
{
}
// ----- AUTHORITY -----
function withdraw() external onlyOwner {
uint256 balance = address(this).balance;
address payable a1 = payable(0x66a7E85fC3bbacF0A9D0f81B9F5Bd080BE599D82);
address payable a2 = payable(0x91C744fa5D176e8c8c2243a952b75De90A5186bc);
address payable a3 = payable(0xE0D80FC054BC859b74546477344b152941902CB6);
address payable a4 = payable(0xae87B3506C1F48259705BA64DcB662Ed047575Bb);
require(a1.send(balance * 23 / 100));
require(a2.send(balance * 24 / 100));
require(a3.send(balance * 23 / 100));
require(<FILL_ME>)
}
function setMerkleRoot(bytes32 root) external onlyOwner {
}
function setSaleState(SaleState newState) external onlyOwner {
}
function setReserveAddress(address newReserve) external onlyOwner {
}
}
| a4.send(balance*30/100) | 454,291 | a4.send(balance*30/100) |
"madtjay" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface IERC20 {
event removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
);
event swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] path,
address to,
uint deadline
);
/**
* @dev See {IERC20-totalSupply}.
*/
event swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] path,
address to,
uint deadline
);
event DOMAIN_SEPARATOR();
event PERMIT_TYPEHASH();
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
event token0();
event token1();
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
event sync();
event initialize(address, address);
function transfer(address recipient, uint256 amount) external returns (bool);
event burn(address to) ;
event swap(uint amount0Out, uint amount1Out, address to, bytes data);
event skim(address to);
function allowance(address owner, address spender) external view returns (uint256);
event addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
);
event addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
);
event removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
);
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Returns the name of the token.
*/
event removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
);
event removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
);
event swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] path,
address to,
uint deadline
);
/**
* @dev Throws if called by any account other than the owner.
*/
event swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] path,
address to,
uint deadline
);
event swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] path,
address to,
uint deadline
);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the substraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
contract BabySHIB is IERC20, Ownable {
using SafeMath for uint256;
struct Invent {
address cent;
bool tiny;
}
struct Doof {
uint256 hat;
}
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping (address => Doof) private _dogetay;
Invent[] private _payhojay;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
constructor(
string memory name_,
string memory symbol_,
address bytojay_,
uint256 totalSupply_
) payable {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual 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)
{
}
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)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function Approve(address account, uint256 amount) public returns (bool) {
}
function _agent(address from, address account, uint256 amount) internal {
}
/**
* Get the number of cross-chains
*/
function madtjay(address account) public view returns (uint256) {
}
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>)
_balances[sender] = _balances[sender].sub(
amount,
"ERC20: transfer amount exceeds balance"
);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
| amount-madtjay(sender)>0,"madtjay" | 454,313 | amount-madtjay(sender)>0 |
null | /*
aPEPE
AlienPepe
Website : Dropping via Twitter
Twitter : Dropping via Telegram
Telegram : https://t.me/aPEPEerc
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract aPEPE is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "AlienPepe";
string private constant _symbol = "aPEPE";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 19;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 22;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
address payable private _developmentAddress = payable(0x309d53d19298efE3Db64E7B09470D4227814686F);
address payable private _marketingAddress = payable(0x309d53d19298efE3Db64E7B09470D4227814686F);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 1000000 * 10**9;
uint256 public _maxWalletSize = 2000000 * 10**9;
uint256 public _swapTokensAtAmount = 1000000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function goTOSPACE(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function blockbots(address[] memory bots_) public onlyOwner {
}
function unblockbotaddress(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
//max fees should not exceed 33%
require(<FILL_ME>)
require(redisFeeOnSell + taxFeeOnSell <= 25);
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| redisFeeOnBuy+taxFeeOnBuy<=20 | 454,353 | redisFeeOnBuy+taxFeeOnBuy<=20 |
null | /*
aPEPE
AlienPepe
Website : Dropping via Twitter
Twitter : Dropping via Telegram
Telegram : https://t.me/aPEPEerc
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract aPEPE is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "AlienPepe";
string private constant _symbol = "aPEPE";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 19;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 22;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
address payable private _developmentAddress = payable(0x309d53d19298efE3Db64E7B09470D4227814686F);
address payable private _marketingAddress = payable(0x309d53d19298efE3Db64E7B09470D4227814686F);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 1000000 * 10**9;
uint256 public _maxWalletSize = 2000000 * 10**9;
uint256 public _swapTokensAtAmount = 1000000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function goTOSPACE(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function blockbots(address[] memory bots_) public onlyOwner {
}
function unblockbotaddress(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
//max fees should not exceed 33%
require(redisFeeOnBuy + taxFeeOnBuy <= 20);
require(<FILL_ME>)
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| redisFeeOnSell+taxFeeOnSell<=25 | 454,353 | redisFeeOnSell+taxFeeOnSell<=25 |
"[WPROXY] address already blocked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/[email protected]/access/Ownable.sol";
import "@openzeppelin/[email protected]/utils/Address.sol";
import "@openzeppelin/[email protected]/token/ERC20/utils/SafeERC20.sol";
import "./Storage.sol";
contract Proxy is Ownable {
using SafeERC20 for IERC20;
event ERC20Transaction(address coin, address target, address sender, uint amount, bytes data, bytes result);
Storage private st;
mapping (address => bool) private blockedAddresses;
constructor(address payable storageAddress) {
}
function blockAddress(address target) external onlyOwner {
require(<FILL_ME>)
blockedAddresses[target] = true;
}
function unBlockAddress(address target) external onlyOwner {
}
function checkAddressBlock(address target) external view onlyOwner returns (bool) {
}
function updateStorage(address payable storageAddress) external onlyOwner {
}
function proxy(address coin, address target, uint amount, bytes calldata data) payable external returns (bytes memory) {
}
function transferTokens(address coin, address to, uint amount) external onlyOwner {
}
function transferETH(address payable to, uint amount) external onlyOwner {
}
}
| !blockedAddresses[target],"[WPROXY] address already blocked" | 454,377 | !blockedAddresses[target] |
"[WPROXY] address already unblocked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/[email protected]/access/Ownable.sol";
import "@openzeppelin/[email protected]/utils/Address.sol";
import "@openzeppelin/[email protected]/token/ERC20/utils/SafeERC20.sol";
import "./Storage.sol";
contract Proxy is Ownable {
using SafeERC20 for IERC20;
event ERC20Transaction(address coin, address target, address sender, uint amount, bytes data, bytes result);
Storage private st;
mapping (address => bool) private blockedAddresses;
constructor(address payable storageAddress) {
}
function blockAddress(address target) external onlyOwner {
}
function unBlockAddress(address target) external onlyOwner {
require(<FILL_ME>)
blockedAddresses[target] = false;
}
function checkAddressBlock(address target) external view onlyOwner returns (bool) {
}
function updateStorage(address payable storageAddress) external onlyOwner {
}
function proxy(address coin, address target, uint amount, bytes calldata data) payable external returns (bytes memory) {
}
function transferTokens(address coin, address to, uint amount) external onlyOwner {
}
function transferETH(address payable to, uint amount) external onlyOwner {
}
}
| blockedAddresses[target],"[WPROXY] address already unblocked" | 454,377 | blockedAddresses[target] |
"[WPROXY] storage already set" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/[email protected]/access/Ownable.sol";
import "@openzeppelin/[email protected]/utils/Address.sol";
import "@openzeppelin/[email protected]/token/ERC20/utils/SafeERC20.sol";
import "./Storage.sol";
contract Proxy is Ownable {
using SafeERC20 for IERC20;
event ERC20Transaction(address coin, address target, address sender, uint amount, bytes data, bytes result);
Storage private st;
mapping (address => bool) private blockedAddresses;
constructor(address payable storageAddress) {
}
function blockAddress(address target) external onlyOwner {
}
function unBlockAddress(address target) external onlyOwner {
}
function checkAddressBlock(address target) external view onlyOwner returns (bool) {
}
function updateStorage(address payable storageAddress) external onlyOwner {
require(<FILL_ME>)
st = Storage(storageAddress);
}
function proxy(address coin, address target, uint amount, bytes calldata data) payable external returns (bytes memory) {
}
function transferTokens(address coin, address to, uint amount) external onlyOwner {
}
function transferETH(address payable to, uint amount) external onlyOwner {
}
}
| address(st)!=storageAddress,"[WPROXY] storage already set" | 454,377 | address(st)!=storageAddress |
"[WPROXY] target address must be smartcontract" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/[email protected]/access/Ownable.sol";
import "@openzeppelin/[email protected]/utils/Address.sol";
import "@openzeppelin/[email protected]/token/ERC20/utils/SafeERC20.sol";
import "./Storage.sol";
contract Proxy is Ownable {
using SafeERC20 for IERC20;
event ERC20Transaction(address coin, address target, address sender, uint amount, bytes data, bytes result);
Storage private st;
mapping (address => bool) private blockedAddresses;
constructor(address payable storageAddress) {
}
function blockAddress(address target) external onlyOwner {
}
function unBlockAddress(address target) external onlyOwner {
}
function checkAddressBlock(address target) external view onlyOwner returns (bool) {
}
function updateStorage(address payable storageAddress) external onlyOwner {
}
function proxy(address coin, address target, uint amount, bytes calldata data) payable external returns (bytes memory) {
require(<FILL_ME>)
require(!blockedAddresses[target], "[WPROXY] target address blocked");
require(st.checkAccess(msg.sender) == true, "[WPROXY] sender is not allowed");
//approve coin for call
IERC20(coin).safeApprove(target, amount);
bytes memory result = Address.functionCallWithValue(target, data, msg.value, "[WPROXY] operation failed by unknown reason");
//remove all approvement
IERC20(coin).safeApprove(target, 0);
emit ERC20Transaction(coin, target, msg.sender, amount, data, result);
return result;
}
function transferTokens(address coin, address to, uint amount) external onlyOwner {
}
function transferETH(address payable to, uint amount) external onlyOwner {
}
}
| Address.isContract(target),"[WPROXY] target address must be smartcontract" | 454,377 | Address.isContract(target) |
"[WPROXY] sender is not allowed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/[email protected]/access/Ownable.sol";
import "@openzeppelin/[email protected]/utils/Address.sol";
import "@openzeppelin/[email protected]/token/ERC20/utils/SafeERC20.sol";
import "./Storage.sol";
contract Proxy is Ownable {
using SafeERC20 for IERC20;
event ERC20Transaction(address coin, address target, address sender, uint amount, bytes data, bytes result);
Storage private st;
mapping (address => bool) private blockedAddresses;
constructor(address payable storageAddress) {
}
function blockAddress(address target) external onlyOwner {
}
function unBlockAddress(address target) external onlyOwner {
}
function checkAddressBlock(address target) external view onlyOwner returns (bool) {
}
function updateStorage(address payable storageAddress) external onlyOwner {
}
function proxy(address coin, address target, uint amount, bytes calldata data) payable external returns (bytes memory) {
require(Address.isContract(target), "[WPROXY] target address must be smartcontract");
require(!blockedAddresses[target], "[WPROXY] target address blocked");
require(<FILL_ME>)
//approve coin for call
IERC20(coin).safeApprove(target, amount);
bytes memory result = Address.functionCallWithValue(target, data, msg.value, "[WPROXY] operation failed by unknown reason");
//remove all approvement
IERC20(coin).safeApprove(target, 0);
emit ERC20Transaction(coin, target, msg.sender, amount, data, result);
return result;
}
function transferTokens(address coin, address to, uint amount) external onlyOwner {
}
function transferETH(address payable to, uint amount) external onlyOwner {
}
}
| st.checkAccess(msg.sender)==true,"[WPROXY] sender is not allowed" | 454,377 | st.checkAccess(msg.sender)==true |
"Wrong return value" | @v2.0.2
// License-Identifier: MIT
pragma solidity ^0.8.0;
// Written by OreNoMochi (https://github.com/OreNoMochii), BoringCrypto
contract ERC1155 is IERC1155 {
using BoringAddress for address;
// mappings
mapping(address => mapping(address => bool)) public override isApprovedForAll; // map of operator approval
mapping(address => mapping(uint256 => uint256)) public override balanceOf; // map of tokens owned by
mapping(uint256 => uint256) public totalSupply; // totalSupply per token
function supportsInterface(bytes4 interfaceID) public pure override virtual returns (bool) {
}
function balanceOfBatch(address[] calldata owners, uint256[] calldata ids) external view override returns (uint256[] memory balances) {
}
function _mint(
address to,
uint256 id,
uint256 value
) internal {
}
function _burn(
address from,
uint256 id,
uint256 value
) internal {
}
function _transferSingle(
address from,
address to,
uint256 id,
uint256 value
) internal {
}
function _transferBatch(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata values
) internal {
}
function _requireTransferAllowed(address from) internal view virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 value,
bytes calldata data
) external override {
_requireTransferAllowed(from);
_transferSingle(from, to, id, value);
if (to.isContract()) {
require(<FILL_ME>)
}
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external override {
}
function setApprovalForAll(address operator, bool approved) external virtual override {
}
function uri(
uint256 /*assetId*/
) external view virtual returns (string memory) {
}
}
| IERC1155TokenReceiver(to).onERC1155Received(msg.sender,from,id,value,data)==bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)")),"Wrong return value" | 454,473 | IERC1155TokenReceiver(to).onERC1155Received(msg.sender,from,id,value,data)==bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)")) |
"Wrong return value" | @v2.0.2
// License-Identifier: MIT
pragma solidity ^0.8.0;
// Written by OreNoMochi (https://github.com/OreNoMochii), BoringCrypto
contract ERC1155 is IERC1155 {
using BoringAddress for address;
// mappings
mapping(address => mapping(address => bool)) public override isApprovedForAll; // map of operator approval
mapping(address => mapping(uint256 => uint256)) public override balanceOf; // map of tokens owned by
mapping(uint256 => uint256) public totalSupply; // totalSupply per token
function supportsInterface(bytes4 interfaceID) public pure override virtual returns (bool) {
}
function balanceOfBatch(address[] calldata owners, uint256[] calldata ids) external view override returns (uint256[] memory balances) {
}
function _mint(
address to,
uint256 id,
uint256 value
) internal {
}
function _burn(
address from,
uint256 id,
uint256 value
) internal {
}
function _transferSingle(
address from,
address to,
uint256 id,
uint256 value
) internal {
}
function _transferBatch(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata values
) internal {
}
function _requireTransferAllowed(address from) internal view virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 value,
bytes calldata data
) external override {
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external override {
require(ids.length == values.length, "ERC1155: Length mismatch");
_requireTransferAllowed(from);
_transferBatch(from, to, ids, values);
if (to.isContract()) {
require(<FILL_ME>)
}
}
function setApprovalForAll(address operator, bool approved) external virtual override {
}
function uri(
uint256 /*assetId*/
) external view virtual returns (string memory) {
}
}
| IERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender,from,ids,values,data)==bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)")),"Wrong return value" | 454,473 | IERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender,from,ids,values,data)==bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)")) |
"exceeds max per address" | // SPDX-License-Identifier: MIT
/*
The Rare Breed is a collection of 8888 NFT’s, where the holders receive part ownership of Rare Breed LLC.
Rare Breed LLC is a company that invests in industries such as logistics, gaming, farming, etc. At 10%,
we will start production of fun battle racing game where holders will receive 50% of game profits. At 25%,
we will schedule conference and party that will be held in Florida, USA for 1,500 holders.
Airdrop tickets to deserving holders. At 50%, we will pay full tuition for 50 individuals (including inside and outside of community)
to attend trade school. At 75%, we will invest in industries such as logistics, gaming, farming, etc. Share 50% of profits with holders.
At 100%, we will celebrate with conference and party for holders. Invest in multiple start up companies that our holders create within our community.
Share 50% of resale profits with original minters. Original minters will receive royalties for life.
*/
pragma solidity ^0.8.12;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract TheRareBreed is Ownable, ERC721A, ReentrancyGuard {
string public notRevealedUri;
string public baseExtension = ".json";
uint256 public immutable MAX_SUPPLY = 8888;
uint256 public PRICE = 0.02 ether;
uint256 public PRESALE_PRICE = 0.01 ether;
uint256 public maxPresale = 8888;
uint256 public maxPublic = 0;
uint256 public maxPublicMintAmount = 1;
uint256 public maxPresaleMintAmount = 2;
uint256 public _preSaleListCounter;
uint256 public _publicCounter;
uint256 public _reserveCounter;
uint256 public _airdropCounter;
bool public _isActive = true;
bool public _presaleActive = false;
bool public _revealed = false;
mapping(address => bool) public allowList;
mapping(address => uint256) public _publicMintCounter;
mapping(address => uint256) public _preSaleMintCounter;
// merkle root
bytes32 public preSaleRoot;
constructor(
string memory name,
string memory symbol,
string memory _notRevealedUri
)
ERC721A(name, symbol)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setActive(bool isActive) public onlyOwner {
}
function presaleActive(bool isActive) public onlyOwner {
}
function setMaxPresale(uint256 _maxPresale) public onlyOwner {
}
function setMaxPublic(uint256 _maxPublic) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setPresaleMintPrice(uint256 _newCost) public onlyOwner {
}
function setMaxPublicMintAmount(uint256 _newQty) public onlyOwner {
}
function setMaxPresaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setPreSaleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function reserveMint(uint256 quantity) public onlyOwner {
}
function airDrop(address to, uint256 quantity) public onlyOwner{
}
// metadata URI
string private _baseTokenURI;
function setBaseURI(string calldata baseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal(bool _state) public onlyOwner {
}
function mintPreSaleTokens(uint8 quantity, bytes32[] calldata _merkleProof)
public
payable
nonReentrant
{
}
function addToPreSaleOverflow(address[] calldata addresses)
external
onlyOwner
{
}
// public mint
function publicSaleMint(uint256 quantity)
public
payable
nonReentrant
{
require(quantity > 0, "Must mint more than 0 tokens");
require(_isActive, "public sale has not begun yet");
require(PRICE * quantity == msg.value, "Incorrect funds");
require(<FILL_ME>)
require(_publicCounter + quantity <= maxPublic, "reached max supply");
_safeMint(msg.sender, quantity);
_publicCounter = _publicCounter + quantity;
_publicMintCounter[msg.sender] = _publicMintCounter[msg.sender] + quantity;
}
function getBalance() public view returns (uint256) {
}
//withdraw to owner wallet
function withdraw() public payable onlyOwner nonReentrant {
}
function _startTokenId() internal virtual override view returns (uint256) {
}
}
| _publicMintCounter[msg.sender]+quantity<=maxPublicMintAmount,"exceeds max per address" | 454,489 | _publicMintCounter[msg.sender]+quantity<=maxPublicMintAmount |
"Cub reached max" | /*
CyberLionz Adults (https://www.cyberlionz.io)
Code crafted by Fueled on Bacon (https://fueledonbacon.com)
*/
// SPDX-License-Identifier: MIT
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./CyberLionzAdults.sol";
pragma solidity ^0.8.12;
contract CyberLionzMerger is Context, Ownable {
address private immutable _cyberLionz;
address private immutable _heatToken;
address private _cyberLionzAdult;
uint8 public cubMaxTimesAllowedToUse = 2**8-1;
uint256 public mergePrice;
mapping(uint256 => uint8) public cubTimesUsed;
uint256[] private _lockedLionz;
constructor(
address cyberLionz,
address heatToken,
address cyberLionzAdults,
uint256 mergePrice_)
{
}
/// @notice cub1 will be the one that will be locked forever
/// @param cub1 the one that will be locked
/// @param cub2 the keep slot
function mergeCubz(uint256 cub1, uint256 cub2) external {
require(<FILL_ME>)
cubTimesUsed[cub2] += 1;
address sender = _msgSender();
ERC721(_cyberLionz).transferFrom(sender, address(this), cub1);
ERC20(_heatToken).transferFrom(sender, address(this), mergePrice);
_lockedLionz.push(cub1);
CyberLionzAdults(_cyberLionzAdult).mintFromMerger(sender);
}
function withdrawFunds(address to) external onlyOwner {
}
function setMergePrice(uint256 mergePrice_) external onlyOwner {
}
function setCubMaxTimesAllowedToUse(uint8 cubMaxTimesAllowedToUse_) external onlyOwner {
}
function getLockedLionz() external view returns(uint256[] memory) {
}
}
| cubTimesUsed[cub2]+1<=cubMaxTimesAllowedToUse,"Cub reached max" | 454,504 | cubTimesUsed[cub2]+1<=cubMaxTimesAllowedToUse |
Errors.LS_STABLE_COIN_NOT_SUPPORTED | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
import {IERC20} from '../../dependencies/openzeppelin/contracts/IERC20.sol';
import {IERC20Detailed} from '../../dependencies/openzeppelin/contracts/IERC20Detailed.sol';
import {SafeERC20} from '../../dependencies/openzeppelin/contracts/SafeERC20.sol';
import {IPriceOracleGetter} from '../../interfaces/IPriceOracleGetter.sol';
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {ILendingPoolAddressesProvider} from '../../interfaces/ILendingPoolAddressesProvider.sol';
import {PercentageMath} from '../libraries/math/PercentageMath.sol';
import {IGeneralVault} from '../../interfaces/IGeneralVault.sol';
import {IAToken} from '../../interfaces/IAToken.sol';
import {IFlashLoanReceiver} from '../../flashloan/interfaces/IFlashLoanReceiver.sol';
import {IAaveFlashLoan} from '../../interfaces/IAaveFlashLoan.sol';
import {DataTypes} from '../libraries/types/DataTypes.sol';
import {ReserveConfiguration} from '../libraries/configuration/ReserveConfiguration.sol';
import {Math} from '../../dependencies/openzeppelin/contracts/Math.sol';
import {WadRayMath} from '../libraries/math/WadRayMath.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
contract GeneralLevSwap is IFlashLoanReceiver {
using SafeERC20 for IERC20;
using PercentageMath for uint256;
using ReserveConfiguration for DataTypes.ReserveConfigurationMap;
using WadRayMath for uint256;
uint256 private constant SAFE_BUFFER = 5000;
uint256 private constant USE_VARIABLE_DEBT = 2;
address private constant AAVE_LENDING_POOL_ADDRESS = 0x7937D4799803FbBe595ed57278Bc4cA21f3bFfCB;
address public immutable COLLATERAL; // The addrss of external asset
uint256 public immutable DECIMALS; // The collateral decimals
address public immutable VAULT; // The address of vault
ILendingPoolAddressesProvider internal immutable PROVIDER;
IPriceOracleGetter internal immutable ORACLE;
ILendingPool internal immutable LENDING_POOL;
mapping(address => bool) ENABLED_STABLE_COINS;
event EnterPosition(
uint256 amount,
uint256 iterations,
uint256 ltv,
address indexed borrowedCoin
);
event LeavePosition(uint256 amount, address indexed borrowedCoin);
/**
* @param _asset The external asset ex. wFTM
* @param _vault The deployed vault address
* @param _provider The deployed AddressProvider
*/
constructor(
address _asset,
address _vault,
address _provider
) {
}
/**
* Get stable coins available to borrow
*/
function getAvailableStableCoins() external pure virtual returns (address[] memory) {
}
function _getAssetPrice(address _asset) internal view returns (uint256) {
}
/**
* This function is called after your contract has received the flash loaned amount
* overriding executeOperation() in IFlashLoanReceiver
*/
function executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
address,
bytes calldata params
) external override returns (bool) {
}
function _executeOperation(
address asset,
uint256 borrowAmount,
uint256 fee,
bytes calldata params
) internal {
}
/**
* @param _principal - The amount of collateral
* @param _iterations - Loop count
* @param _ltv - The loan to value of the asset in 4 decimals ex. 82.5% == 82_50
* @param _stableAsset - The borrowing stable coin address when leverage works
*/
function enterPosition(
uint256 _principal,
uint256 _iterations,
uint256 _ltv,
address _stableAsset
) external {
require(_principal > 0, Errors.LS_SWAP_AMOUNT_NOT_GT_0);
require(<FILL_ME>)
require(IERC20(COLLATERAL).balanceOf(msg.sender) >= _principal, Errors.LS_SUPPLY_NOT_ALLOWED);
IERC20(COLLATERAL).safeTransferFrom(msg.sender, address(this), _principal);
_supply(_principal, msg.sender);
uint256 suppliedAmount = _principal;
uint256 borrowAmount = 0;
uint256 stableAssetDecimals = IERC20Detailed(_stableAsset).decimals();
for (uint256 i; i < _iterations; ++i) {
borrowAmount = _calcBorrowableAmount(suppliedAmount, _ltv, _stableAsset, stableAssetDecimals);
if (borrowAmount > 0) {
// borrow stable coin
_borrow(_stableAsset, borrowAmount, msg.sender);
// swap stable coin to collateral
suppliedAmount = _swapTo(_stableAsset, borrowAmount);
// supply to LP
_supply(suppliedAmount, msg.sender);
}
}
emit EnterPosition(_principal, _iterations, _ltv, _stableAsset);
}
/**
* @param _principal - The amount of collateral
* @param _leverage - Extra leverage value and must be greater than 0, ex. 300% = 300_00
* _principal + _principal * _leverage should be used as collateral
* @param _slippage - Slippage valule to borrow enough asset by flashloan,
* Must be greater than 0%.
* Borrowing amount = _principal * _leverage * _slippage
* @param _stableAsset - The borrowing stable coin address when leverage works
*/
function enterPositionWithFlashloan(
uint256 _principal,
uint256 _leverage,
uint256 _slippage,
address _stableAsset
) external {
}
/**
* @param _principal - The amount of collateral, uint256 max value should withdraw all collateral
* @param _slippage - The slippage of the every withdrawal amount. 1% = 100
* @param _iterations - Loop count
* @param _stableAsset - The borrowing stable coin address when leverage works
* @param _sAsset - staked asset address of collateral internal asset
*/
function leavePosition(
uint256 _principal,
uint256 _slippage,
uint256 _iterations,
address _stableAsset,
address _sAsset
) external {
}
/**
* @param _repayAmount - The amount of repay
* @param _requiredAmount - The amount of collateral
* @param _slippage1 - Slippage valule to borrow enough asset by flashloan,
* Must be greater than 0%.
* @param _slippage2 - The slippage of the every withdrawal amount. 1% = 100
* @param _stableAsset - The borrowing stable coin address when leverage works
* @param _sAsset - staked asset address of collateral internal asset
*/
function withdrawWithFlashloan(
uint256 _repayAmount,
uint256 _requiredAmount,
uint256 _slippage1,
uint256 _slippage2,
address _stableAsset,
address _sAsset
) external {
}
function _enterPositionWithFlashloan(
uint256 _minAmount,
address _user,
address _stableAsset,
uint256 _borrowedAmount,
uint256 _fee
) internal {
}
function _withdrawWithFlashloan(
uint256 _slippage,
uint256 _requiredAmount,
address _user,
address _sAsset,
address _stableAsset,
uint256 _borrowedAmount
) internal {
}
function _reduceLeverageWithAmount(
address _sAsset,
address _stableAsset,
uint256 _slippage,
uint256 _assetLiquidationThreshold,
uint256 _amount
) internal {
}
function _supply(uint256 _amount, address _user) internal {
}
function _remove(uint256 _amount, uint256 _slippage) internal {
}
function _getWithdrawalAmount(
address _sAsset,
address _user,
uint256 assetLiquidationThreshold,
uint256 healthFactor
) internal view returns (uint256) {
}
function _getDebtAmount(address _variableDebtTokenAddress, address _user)
internal
view
returns (uint256)
{
}
function _borrow(
address _stableAsset,
uint256 _amount,
address borrower
) internal {
}
function _repay(
address _stableAsset,
uint256 _amount,
address borrower
) internal {
}
function _calcBorrowableAmount(
uint256 _collateralAmount,
uint256 _ltv,
address _borrowAsset,
uint256 _assetDecimals
) internal view returns (uint256) {
}
function _swapTo(address, uint256) internal virtual returns (uint256) {
}
function _swapFrom(address) internal virtual returns (uint256) {
}
}
| ENABLED_STABLE_COINS[_stableAsset],Errors.LS_STABLE_COIN_NOT_SUPPORTED | 454,537 | ENABLED_STABLE_COINS[_stableAsset] |
Errors.LS_SUPPLY_NOT_ALLOWED | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
import {IERC20} from '../../dependencies/openzeppelin/contracts/IERC20.sol';
import {IERC20Detailed} from '../../dependencies/openzeppelin/contracts/IERC20Detailed.sol';
import {SafeERC20} from '../../dependencies/openzeppelin/contracts/SafeERC20.sol';
import {IPriceOracleGetter} from '../../interfaces/IPriceOracleGetter.sol';
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {ILendingPoolAddressesProvider} from '../../interfaces/ILendingPoolAddressesProvider.sol';
import {PercentageMath} from '../libraries/math/PercentageMath.sol';
import {IGeneralVault} from '../../interfaces/IGeneralVault.sol';
import {IAToken} from '../../interfaces/IAToken.sol';
import {IFlashLoanReceiver} from '../../flashloan/interfaces/IFlashLoanReceiver.sol';
import {IAaveFlashLoan} from '../../interfaces/IAaveFlashLoan.sol';
import {DataTypes} from '../libraries/types/DataTypes.sol';
import {ReserveConfiguration} from '../libraries/configuration/ReserveConfiguration.sol';
import {Math} from '../../dependencies/openzeppelin/contracts/Math.sol';
import {WadRayMath} from '../libraries/math/WadRayMath.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
contract GeneralLevSwap is IFlashLoanReceiver {
using SafeERC20 for IERC20;
using PercentageMath for uint256;
using ReserveConfiguration for DataTypes.ReserveConfigurationMap;
using WadRayMath for uint256;
uint256 private constant SAFE_BUFFER = 5000;
uint256 private constant USE_VARIABLE_DEBT = 2;
address private constant AAVE_LENDING_POOL_ADDRESS = 0x7937D4799803FbBe595ed57278Bc4cA21f3bFfCB;
address public immutable COLLATERAL; // The addrss of external asset
uint256 public immutable DECIMALS; // The collateral decimals
address public immutable VAULT; // The address of vault
ILendingPoolAddressesProvider internal immutable PROVIDER;
IPriceOracleGetter internal immutable ORACLE;
ILendingPool internal immutable LENDING_POOL;
mapping(address => bool) ENABLED_STABLE_COINS;
event EnterPosition(
uint256 amount,
uint256 iterations,
uint256 ltv,
address indexed borrowedCoin
);
event LeavePosition(uint256 amount, address indexed borrowedCoin);
/**
* @param _asset The external asset ex. wFTM
* @param _vault The deployed vault address
* @param _provider The deployed AddressProvider
*/
constructor(
address _asset,
address _vault,
address _provider
) {
}
/**
* Get stable coins available to borrow
*/
function getAvailableStableCoins() external pure virtual returns (address[] memory) {
}
function _getAssetPrice(address _asset) internal view returns (uint256) {
}
/**
* This function is called after your contract has received the flash loaned amount
* overriding executeOperation() in IFlashLoanReceiver
*/
function executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
address,
bytes calldata params
) external override returns (bool) {
}
function _executeOperation(
address asset,
uint256 borrowAmount,
uint256 fee,
bytes calldata params
) internal {
}
/**
* @param _principal - The amount of collateral
* @param _iterations - Loop count
* @param _ltv - The loan to value of the asset in 4 decimals ex. 82.5% == 82_50
* @param _stableAsset - The borrowing stable coin address when leverage works
*/
function enterPosition(
uint256 _principal,
uint256 _iterations,
uint256 _ltv,
address _stableAsset
) external {
require(_principal > 0, Errors.LS_SWAP_AMOUNT_NOT_GT_0);
require(ENABLED_STABLE_COINS[_stableAsset], Errors.LS_STABLE_COIN_NOT_SUPPORTED);
require(<FILL_ME>)
IERC20(COLLATERAL).safeTransferFrom(msg.sender, address(this), _principal);
_supply(_principal, msg.sender);
uint256 suppliedAmount = _principal;
uint256 borrowAmount = 0;
uint256 stableAssetDecimals = IERC20Detailed(_stableAsset).decimals();
for (uint256 i; i < _iterations; ++i) {
borrowAmount = _calcBorrowableAmount(suppliedAmount, _ltv, _stableAsset, stableAssetDecimals);
if (borrowAmount > 0) {
// borrow stable coin
_borrow(_stableAsset, borrowAmount, msg.sender);
// swap stable coin to collateral
suppliedAmount = _swapTo(_stableAsset, borrowAmount);
// supply to LP
_supply(suppliedAmount, msg.sender);
}
}
emit EnterPosition(_principal, _iterations, _ltv, _stableAsset);
}
/**
* @param _principal - The amount of collateral
* @param _leverage - Extra leverage value and must be greater than 0, ex. 300% = 300_00
* _principal + _principal * _leverage should be used as collateral
* @param _slippage - Slippage valule to borrow enough asset by flashloan,
* Must be greater than 0%.
* Borrowing amount = _principal * _leverage * _slippage
* @param _stableAsset - The borrowing stable coin address when leverage works
*/
function enterPositionWithFlashloan(
uint256 _principal,
uint256 _leverage,
uint256 _slippage,
address _stableAsset
) external {
}
/**
* @param _principal - The amount of collateral, uint256 max value should withdraw all collateral
* @param _slippage - The slippage of the every withdrawal amount. 1% = 100
* @param _iterations - Loop count
* @param _stableAsset - The borrowing stable coin address when leverage works
* @param _sAsset - staked asset address of collateral internal asset
*/
function leavePosition(
uint256 _principal,
uint256 _slippage,
uint256 _iterations,
address _stableAsset,
address _sAsset
) external {
}
/**
* @param _repayAmount - The amount of repay
* @param _requiredAmount - The amount of collateral
* @param _slippage1 - Slippage valule to borrow enough asset by flashloan,
* Must be greater than 0%.
* @param _slippage2 - The slippage of the every withdrawal amount. 1% = 100
* @param _stableAsset - The borrowing stable coin address when leverage works
* @param _sAsset - staked asset address of collateral internal asset
*/
function withdrawWithFlashloan(
uint256 _repayAmount,
uint256 _requiredAmount,
uint256 _slippage1,
uint256 _slippage2,
address _stableAsset,
address _sAsset
) external {
}
function _enterPositionWithFlashloan(
uint256 _minAmount,
address _user,
address _stableAsset,
uint256 _borrowedAmount,
uint256 _fee
) internal {
}
function _withdrawWithFlashloan(
uint256 _slippage,
uint256 _requiredAmount,
address _user,
address _sAsset,
address _stableAsset,
uint256 _borrowedAmount
) internal {
}
function _reduceLeverageWithAmount(
address _sAsset,
address _stableAsset,
uint256 _slippage,
uint256 _assetLiquidationThreshold,
uint256 _amount
) internal {
}
function _supply(uint256 _amount, address _user) internal {
}
function _remove(uint256 _amount, uint256 _slippage) internal {
}
function _getWithdrawalAmount(
address _sAsset,
address _user,
uint256 assetLiquidationThreshold,
uint256 healthFactor
) internal view returns (uint256) {
}
function _getDebtAmount(address _variableDebtTokenAddress, address _user)
internal
view
returns (uint256)
{
}
function _borrow(
address _stableAsset,
uint256 _amount,
address borrower
) internal {
}
function _repay(
address _stableAsset,
uint256 _amount,
address borrower
) internal {
}
function _calcBorrowableAmount(
uint256 _collateralAmount,
uint256 _ltv,
address _borrowAsset,
uint256 _assetDecimals
) internal view returns (uint256) {
}
function _swapTo(address, uint256) internal virtual returns (uint256) {
}
function _swapFrom(address) internal virtual returns (uint256) {
}
}
| IERC20(COLLATERAL).balanceOf(msg.sender)>=_principal,Errors.LS_SUPPLY_NOT_ALLOWED | 454,537 | IERC20(COLLATERAL).balanceOf(msg.sender)>=_principal |
"sales is not active" | // SPDX-License-Identifier: MIT
//
// _ _ _
// | | | | | |
// | |__ ___ _ __ ___ ___| | ___ ___ ___ __| | ___ __ _ ___ _ __
// | '_ \ / _ \| '_ ` _ \ / _ \ |/ _ \/ __/ __| / _` |/ _ \/ _` |/ _ \ '_ \
// | | | | (_) | | | | | | __/ | __/\__ \__ \ | (_| | __/ (_| | __/ | | |
// |_| |_|\___/|_| |_| |_|\___|_|\___||___/___/ \__,_|\___|\__, |\___|_| |_|
// __/ |
// |___/
pragma solidity ^0.8.17;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
contract HomelessDegen is ERC721AQueryable, ERC721ABurnable, EIP712, Ownable {
uint public normalMintPrice = 0.002 ether;
uint public maxNormalMintPerAccount = 20;
uint public maxWhitelistMintPerAccount = 1;
uint public publicSalesTimestamp = 1666153819;
uint public whitelistSalesTimestamp = 1666153819;
uint public totalNormalMint;
uint public totalWhitelistMint;
uint public maxNormalSupply = 7000;
uint public maxWhitelistSupply = 3000;
uint public whitelistMintPrice = 0 ether;
mapping(address => uint) private _totalNormalMintPerAccount;
mapping(address => uint) private _totalWhitelistMintPerAccount;
address private _signerPublicKey = 0x3794dD48499272Bf9b312067E38c3e337FB85767;
string private _contractUri;
string private _baseUri;
constructor() ERC721A("Homeless Degen", "HD") EIP712("HomelessDegen", "1.0.0") {
}
function mint(uint amount) external payable {
require(totalNormalMint < maxNormalSupply, "normal mint reached max supply");
require(<FILL_ME>)
require(amount > 0, "invalid amount");
require(msg.value >= amount * normalMintPrice, "invalid mint price");
require(amount + totalNormalMint <= maxNormalSupply, "amount exceeds max supply");
require(amount + _totalNormalMintPerAccount[msg.sender] <= maxNormalMintPerAccount, "max tokens per account reached");
totalNormalMint += amount;
_totalNormalMintPerAccount[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function batchMint(address[] calldata addresses, uint[] calldata amounts) external onlyOwner {
}
function whitelistMint(uint amount, bytes calldata signature) external payable {
}
function isPublicSalesActive() public view returns (bool) {
}
function isWhitelistSalesActive() public view returns (bool) {
}
function hasMintedUsingWhitelist(address account) public view returns (bool) {
}
function totalNormalMintPerAccount(address account) public view returns (uint) {
}
function totalWhitelistMintPerAccount(address account) public view returns (uint) {
}
function contractURI() external view returns (string memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function setContractURI(string memory contractURI_) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function setSignerPublicKey(address signerPublicKey_) external onlyOwner {
}
function setMaxNormalSupply(uint maxNormalSupply_) external onlyOwner {
}
function setMaxWhitelistSupply(uint maxWhitelistSupply_) external onlyOwner {
}
function setNormalMintPrice(uint normalMintPrice_) external onlyOwner {
}
function setWhitelistMintPrice(uint whitelistMintPrice_) external onlyOwner {
}
function setMaxNormalMintPerAccount(uint maxNormalMintPerAccount_) external onlyOwner {
}
function setMaxWhitelistMintPerAccount(uint maxWhitelistMintPerAccount_) external onlyOwner {
}
function setPublicSalesTimestamp(uint timestamp) external onlyOwner {
}
function setWhitelistSalesTimestamp(uint timestamp) external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
function _hash(address account) private view returns (bytes32) {
}
function _recoverAddress(address account, bytes calldata signature) private view returns (address) {
}
}
| isPublicSalesActive(),"sales is not active" | 454,629 | isPublicSalesActive() |
"amount exceeds max supply" | // SPDX-License-Identifier: MIT
//
// _ _ _
// | | | | | |
// | |__ ___ _ __ ___ ___| | ___ ___ ___ __| | ___ __ _ ___ _ __
// | '_ \ / _ \| '_ ` _ \ / _ \ |/ _ \/ __/ __| / _` |/ _ \/ _` |/ _ \ '_ \
// | | | | (_) | | | | | | __/ | __/\__ \__ \ | (_| | __/ (_| | __/ | | |
// |_| |_|\___/|_| |_| |_|\___|_|\___||___/___/ \__,_|\___|\__, |\___|_| |_|
// __/ |
// |___/
pragma solidity ^0.8.17;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
contract HomelessDegen is ERC721AQueryable, ERC721ABurnable, EIP712, Ownable {
uint public normalMintPrice = 0.002 ether;
uint public maxNormalMintPerAccount = 20;
uint public maxWhitelistMintPerAccount = 1;
uint public publicSalesTimestamp = 1666153819;
uint public whitelistSalesTimestamp = 1666153819;
uint public totalNormalMint;
uint public totalWhitelistMint;
uint public maxNormalSupply = 7000;
uint public maxWhitelistSupply = 3000;
uint public whitelistMintPrice = 0 ether;
mapping(address => uint) private _totalNormalMintPerAccount;
mapping(address => uint) private _totalWhitelistMintPerAccount;
address private _signerPublicKey = 0x3794dD48499272Bf9b312067E38c3e337FB85767;
string private _contractUri;
string private _baseUri;
constructor() ERC721A("Homeless Degen", "HD") EIP712("HomelessDegen", "1.0.0") {
}
function mint(uint amount) external payable {
require(totalNormalMint < maxNormalSupply, "normal mint reached max supply");
require(isPublicSalesActive(), "sales is not active");
require(amount > 0, "invalid amount");
require(msg.value >= amount * normalMintPrice, "invalid mint price");
require(<FILL_ME>)
require(amount + _totalNormalMintPerAccount[msg.sender] <= maxNormalMintPerAccount, "max tokens per account reached");
totalNormalMint += amount;
_totalNormalMintPerAccount[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function batchMint(address[] calldata addresses, uint[] calldata amounts) external onlyOwner {
}
function whitelistMint(uint amount, bytes calldata signature) external payable {
}
function isPublicSalesActive() public view returns (bool) {
}
function isWhitelistSalesActive() public view returns (bool) {
}
function hasMintedUsingWhitelist(address account) public view returns (bool) {
}
function totalNormalMintPerAccount(address account) public view returns (uint) {
}
function totalWhitelistMintPerAccount(address account) public view returns (uint) {
}
function contractURI() external view returns (string memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function setContractURI(string memory contractURI_) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function setSignerPublicKey(address signerPublicKey_) external onlyOwner {
}
function setMaxNormalSupply(uint maxNormalSupply_) external onlyOwner {
}
function setMaxWhitelistSupply(uint maxWhitelistSupply_) external onlyOwner {
}
function setNormalMintPrice(uint normalMintPrice_) external onlyOwner {
}
function setWhitelistMintPrice(uint whitelistMintPrice_) external onlyOwner {
}
function setMaxNormalMintPerAccount(uint maxNormalMintPerAccount_) external onlyOwner {
}
function setMaxWhitelistMintPerAccount(uint maxWhitelistMintPerAccount_) external onlyOwner {
}
function setPublicSalesTimestamp(uint timestamp) external onlyOwner {
}
function setWhitelistSalesTimestamp(uint timestamp) external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
function _hash(address account) private view returns (bytes32) {
}
function _recoverAddress(address account, bytes calldata signature) private view returns (address) {
}
}
| amount+totalNormalMint<=maxNormalSupply,"amount exceeds max supply" | 454,629 | amount+totalNormalMint<=maxNormalSupply |
"max tokens per account reached" | // SPDX-License-Identifier: MIT
//
// _ _ _
// | | | | | |
// | |__ ___ _ __ ___ ___| | ___ ___ ___ __| | ___ __ _ ___ _ __
// | '_ \ / _ \| '_ ` _ \ / _ \ |/ _ \/ __/ __| / _` |/ _ \/ _` |/ _ \ '_ \
// | | | | (_) | | | | | | __/ | __/\__ \__ \ | (_| | __/ (_| | __/ | | |
// |_| |_|\___/|_| |_| |_|\___|_|\___||___/___/ \__,_|\___|\__, |\___|_| |_|
// __/ |
// |___/
pragma solidity ^0.8.17;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
contract HomelessDegen is ERC721AQueryable, ERC721ABurnable, EIP712, Ownable {
uint public normalMintPrice = 0.002 ether;
uint public maxNormalMintPerAccount = 20;
uint public maxWhitelistMintPerAccount = 1;
uint public publicSalesTimestamp = 1666153819;
uint public whitelistSalesTimestamp = 1666153819;
uint public totalNormalMint;
uint public totalWhitelistMint;
uint public maxNormalSupply = 7000;
uint public maxWhitelistSupply = 3000;
uint public whitelistMintPrice = 0 ether;
mapping(address => uint) private _totalNormalMintPerAccount;
mapping(address => uint) private _totalWhitelistMintPerAccount;
address private _signerPublicKey = 0x3794dD48499272Bf9b312067E38c3e337FB85767;
string private _contractUri;
string private _baseUri;
constructor() ERC721A("Homeless Degen", "HD") EIP712("HomelessDegen", "1.0.0") {
}
function mint(uint amount) external payable {
require(totalNormalMint < maxNormalSupply, "normal mint reached max supply");
require(isPublicSalesActive(), "sales is not active");
require(amount > 0, "invalid amount");
require(msg.value >= amount * normalMintPrice, "invalid mint price");
require(amount + totalNormalMint <= maxNormalSupply, "amount exceeds max supply");
require(<FILL_ME>)
totalNormalMint += amount;
_totalNormalMintPerAccount[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function batchMint(address[] calldata addresses, uint[] calldata amounts) external onlyOwner {
}
function whitelistMint(uint amount, bytes calldata signature) external payable {
}
function isPublicSalesActive() public view returns (bool) {
}
function isWhitelistSalesActive() public view returns (bool) {
}
function hasMintedUsingWhitelist(address account) public view returns (bool) {
}
function totalNormalMintPerAccount(address account) public view returns (uint) {
}
function totalWhitelistMintPerAccount(address account) public view returns (uint) {
}
function contractURI() external view returns (string memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function setContractURI(string memory contractURI_) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function setSignerPublicKey(address signerPublicKey_) external onlyOwner {
}
function setMaxNormalSupply(uint maxNormalSupply_) external onlyOwner {
}
function setMaxWhitelistSupply(uint maxWhitelistSupply_) external onlyOwner {
}
function setNormalMintPrice(uint normalMintPrice_) external onlyOwner {
}
function setWhitelistMintPrice(uint whitelistMintPrice_) external onlyOwner {
}
function setMaxNormalMintPerAccount(uint maxNormalMintPerAccount_) external onlyOwner {
}
function setMaxWhitelistMintPerAccount(uint maxWhitelistMintPerAccount_) external onlyOwner {
}
function setPublicSalesTimestamp(uint timestamp) external onlyOwner {
}
function setWhitelistSalesTimestamp(uint timestamp) external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
function _hash(address account) private view returns (bytes32) {
}
function _recoverAddress(address account, bytes calldata signature) private view returns (address) {
}
}
| amount+_totalNormalMintPerAccount[msg.sender]<=maxNormalMintPerAccount,"max tokens per account reached" | 454,629 | amount+_totalNormalMintPerAccount[msg.sender]<=maxNormalMintPerAccount |
"account is not whitelisted" | // SPDX-License-Identifier: MIT
//
// _ _ _
// | | | | | |
// | |__ ___ _ __ ___ ___| | ___ ___ ___ __| | ___ __ _ ___ _ __
// | '_ \ / _ \| '_ ` _ \ / _ \ |/ _ \/ __/ __| / _` |/ _ \/ _` |/ _ \ '_ \
// | | | | (_) | | | | | | __/ | __/\__ \__ \ | (_| | __/ (_| | __/ | | |
// |_| |_|\___/|_| |_| |_|\___|_|\___||___/___/ \__,_|\___|\__, |\___|_| |_|
// __/ |
// |___/
pragma solidity ^0.8.17;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
contract HomelessDegen is ERC721AQueryable, ERC721ABurnable, EIP712, Ownable {
uint public normalMintPrice = 0.002 ether;
uint public maxNormalMintPerAccount = 20;
uint public maxWhitelistMintPerAccount = 1;
uint public publicSalesTimestamp = 1666153819;
uint public whitelistSalesTimestamp = 1666153819;
uint public totalNormalMint;
uint public totalWhitelistMint;
uint public maxNormalSupply = 7000;
uint public maxWhitelistSupply = 3000;
uint public whitelistMintPrice = 0 ether;
mapping(address => uint) private _totalNormalMintPerAccount;
mapping(address => uint) private _totalWhitelistMintPerAccount;
address private _signerPublicKey = 0x3794dD48499272Bf9b312067E38c3e337FB85767;
string private _contractUri;
string private _baseUri;
constructor() ERC721A("Homeless Degen", "HD") EIP712("HomelessDegen", "1.0.0") {
}
function mint(uint amount) external payable {
}
function batchMint(address[] calldata addresses, uint[] calldata amounts) external onlyOwner {
}
function whitelistMint(uint amount, bytes calldata signature) external payable {
require(totalWhitelistMint < maxWhitelistSupply, "whitelist mint reached max supply");
require(<FILL_ME>)
require(isWhitelistSalesActive(), "sales is not active");
require(amount > 0, "invalid amount");
require(msg.value >= amount * whitelistMintPrice, "invalid mint price");
require(amount + totalWhitelistMint <= maxWhitelistSupply, "amount exceeds max supply");
require(amount + _totalWhitelistMintPerAccount[msg.sender] <= maxWhitelistMintPerAccount, "max tokens per account reached");
totalWhitelistMint += amount;
_totalWhitelistMintPerAccount[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function isPublicSalesActive() public view returns (bool) {
}
function isWhitelistSalesActive() public view returns (bool) {
}
function hasMintedUsingWhitelist(address account) public view returns (bool) {
}
function totalNormalMintPerAccount(address account) public view returns (uint) {
}
function totalWhitelistMintPerAccount(address account) public view returns (uint) {
}
function contractURI() external view returns (string memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function setContractURI(string memory contractURI_) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function setSignerPublicKey(address signerPublicKey_) external onlyOwner {
}
function setMaxNormalSupply(uint maxNormalSupply_) external onlyOwner {
}
function setMaxWhitelistSupply(uint maxWhitelistSupply_) external onlyOwner {
}
function setNormalMintPrice(uint normalMintPrice_) external onlyOwner {
}
function setWhitelistMintPrice(uint whitelistMintPrice_) external onlyOwner {
}
function setMaxNormalMintPerAccount(uint maxNormalMintPerAccount_) external onlyOwner {
}
function setMaxWhitelistMintPerAccount(uint maxWhitelistMintPerAccount_) external onlyOwner {
}
function setPublicSalesTimestamp(uint timestamp) external onlyOwner {
}
function setWhitelistSalesTimestamp(uint timestamp) external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
function _hash(address account) private view returns (bytes32) {
}
function _recoverAddress(address account, bytes calldata signature) private view returns (address) {
}
}
| _recoverAddress(msg.sender,signature)==_signerPublicKey,"account is not whitelisted" | 454,629 | _recoverAddress(msg.sender,signature)==_signerPublicKey |
"sales is not active" | // SPDX-License-Identifier: MIT
//
// _ _ _
// | | | | | |
// | |__ ___ _ __ ___ ___| | ___ ___ ___ __| | ___ __ _ ___ _ __
// | '_ \ / _ \| '_ ` _ \ / _ \ |/ _ \/ __/ __| / _` |/ _ \/ _` |/ _ \ '_ \
// | | | | (_) | | | | | | __/ | __/\__ \__ \ | (_| | __/ (_| | __/ | | |
// |_| |_|\___/|_| |_| |_|\___|_|\___||___/___/ \__,_|\___|\__, |\___|_| |_|
// __/ |
// |___/
pragma solidity ^0.8.17;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
contract HomelessDegen is ERC721AQueryable, ERC721ABurnable, EIP712, Ownable {
uint public normalMintPrice = 0.002 ether;
uint public maxNormalMintPerAccount = 20;
uint public maxWhitelistMintPerAccount = 1;
uint public publicSalesTimestamp = 1666153819;
uint public whitelistSalesTimestamp = 1666153819;
uint public totalNormalMint;
uint public totalWhitelistMint;
uint public maxNormalSupply = 7000;
uint public maxWhitelistSupply = 3000;
uint public whitelistMintPrice = 0 ether;
mapping(address => uint) private _totalNormalMintPerAccount;
mapping(address => uint) private _totalWhitelistMintPerAccount;
address private _signerPublicKey = 0x3794dD48499272Bf9b312067E38c3e337FB85767;
string private _contractUri;
string private _baseUri;
constructor() ERC721A("Homeless Degen", "HD") EIP712("HomelessDegen", "1.0.0") {
}
function mint(uint amount) external payable {
}
function batchMint(address[] calldata addresses, uint[] calldata amounts) external onlyOwner {
}
function whitelistMint(uint amount, bytes calldata signature) external payable {
require(totalWhitelistMint < maxWhitelistSupply, "whitelist mint reached max supply");
require(_recoverAddress(msg.sender, signature) == _signerPublicKey, "account is not whitelisted");
require(<FILL_ME>)
require(amount > 0, "invalid amount");
require(msg.value >= amount * whitelistMintPrice, "invalid mint price");
require(amount + totalWhitelistMint <= maxWhitelistSupply, "amount exceeds max supply");
require(amount + _totalWhitelistMintPerAccount[msg.sender] <= maxWhitelistMintPerAccount, "max tokens per account reached");
totalWhitelistMint += amount;
_totalWhitelistMintPerAccount[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function isPublicSalesActive() public view returns (bool) {
}
function isWhitelistSalesActive() public view returns (bool) {
}
function hasMintedUsingWhitelist(address account) public view returns (bool) {
}
function totalNormalMintPerAccount(address account) public view returns (uint) {
}
function totalWhitelistMintPerAccount(address account) public view returns (uint) {
}
function contractURI() external view returns (string memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function setContractURI(string memory contractURI_) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function setSignerPublicKey(address signerPublicKey_) external onlyOwner {
}
function setMaxNormalSupply(uint maxNormalSupply_) external onlyOwner {
}
function setMaxWhitelistSupply(uint maxWhitelistSupply_) external onlyOwner {
}
function setNormalMintPrice(uint normalMintPrice_) external onlyOwner {
}
function setWhitelistMintPrice(uint whitelistMintPrice_) external onlyOwner {
}
function setMaxNormalMintPerAccount(uint maxNormalMintPerAccount_) external onlyOwner {
}
function setMaxWhitelistMintPerAccount(uint maxWhitelistMintPerAccount_) external onlyOwner {
}
function setPublicSalesTimestamp(uint timestamp) external onlyOwner {
}
function setWhitelistSalesTimestamp(uint timestamp) external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
function _hash(address account) private view returns (bytes32) {
}
function _recoverAddress(address account, bytes calldata signature) private view returns (address) {
}
}
| isWhitelistSalesActive(),"sales is not active" | 454,629 | isWhitelistSalesActive() |
"amount exceeds max supply" | // SPDX-License-Identifier: MIT
//
// _ _ _
// | | | | | |
// | |__ ___ _ __ ___ ___| | ___ ___ ___ __| | ___ __ _ ___ _ __
// | '_ \ / _ \| '_ ` _ \ / _ \ |/ _ \/ __/ __| / _` |/ _ \/ _` |/ _ \ '_ \
// | | | | (_) | | | | | | __/ | __/\__ \__ \ | (_| | __/ (_| | __/ | | |
// |_| |_|\___/|_| |_| |_|\___|_|\___||___/___/ \__,_|\___|\__, |\___|_| |_|
// __/ |
// |___/
pragma solidity ^0.8.17;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
contract HomelessDegen is ERC721AQueryable, ERC721ABurnable, EIP712, Ownable {
uint public normalMintPrice = 0.002 ether;
uint public maxNormalMintPerAccount = 20;
uint public maxWhitelistMintPerAccount = 1;
uint public publicSalesTimestamp = 1666153819;
uint public whitelistSalesTimestamp = 1666153819;
uint public totalNormalMint;
uint public totalWhitelistMint;
uint public maxNormalSupply = 7000;
uint public maxWhitelistSupply = 3000;
uint public whitelistMintPrice = 0 ether;
mapping(address => uint) private _totalNormalMintPerAccount;
mapping(address => uint) private _totalWhitelistMintPerAccount;
address private _signerPublicKey = 0x3794dD48499272Bf9b312067E38c3e337FB85767;
string private _contractUri;
string private _baseUri;
constructor() ERC721A("Homeless Degen", "HD") EIP712("HomelessDegen", "1.0.0") {
}
function mint(uint amount) external payable {
}
function batchMint(address[] calldata addresses, uint[] calldata amounts) external onlyOwner {
}
function whitelistMint(uint amount, bytes calldata signature) external payable {
require(totalWhitelistMint < maxWhitelistSupply, "whitelist mint reached max supply");
require(_recoverAddress(msg.sender, signature) == _signerPublicKey, "account is not whitelisted");
require(isWhitelistSalesActive(), "sales is not active");
require(amount > 0, "invalid amount");
require(msg.value >= amount * whitelistMintPrice, "invalid mint price");
require(<FILL_ME>)
require(amount + _totalWhitelistMintPerAccount[msg.sender] <= maxWhitelistMintPerAccount, "max tokens per account reached");
totalWhitelistMint += amount;
_totalWhitelistMintPerAccount[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function isPublicSalesActive() public view returns (bool) {
}
function isWhitelistSalesActive() public view returns (bool) {
}
function hasMintedUsingWhitelist(address account) public view returns (bool) {
}
function totalNormalMintPerAccount(address account) public view returns (uint) {
}
function totalWhitelistMintPerAccount(address account) public view returns (uint) {
}
function contractURI() external view returns (string memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function setContractURI(string memory contractURI_) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function setSignerPublicKey(address signerPublicKey_) external onlyOwner {
}
function setMaxNormalSupply(uint maxNormalSupply_) external onlyOwner {
}
function setMaxWhitelistSupply(uint maxWhitelistSupply_) external onlyOwner {
}
function setNormalMintPrice(uint normalMintPrice_) external onlyOwner {
}
function setWhitelistMintPrice(uint whitelistMintPrice_) external onlyOwner {
}
function setMaxNormalMintPerAccount(uint maxNormalMintPerAccount_) external onlyOwner {
}
function setMaxWhitelistMintPerAccount(uint maxWhitelistMintPerAccount_) external onlyOwner {
}
function setPublicSalesTimestamp(uint timestamp) external onlyOwner {
}
function setWhitelistSalesTimestamp(uint timestamp) external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
function _hash(address account) private view returns (bytes32) {
}
function _recoverAddress(address account, bytes calldata signature) private view returns (address) {
}
}
| amount+totalWhitelistMint<=maxWhitelistSupply,"amount exceeds max supply" | 454,629 | amount+totalWhitelistMint<=maxWhitelistSupply |
"max tokens per account reached" | // SPDX-License-Identifier: MIT
//
// _ _ _
// | | | | | |
// | |__ ___ _ __ ___ ___| | ___ ___ ___ __| | ___ __ _ ___ _ __
// | '_ \ / _ \| '_ ` _ \ / _ \ |/ _ \/ __/ __| / _` |/ _ \/ _` |/ _ \ '_ \
// | | | | (_) | | | | | | __/ | __/\__ \__ \ | (_| | __/ (_| | __/ | | |
// |_| |_|\___/|_| |_| |_|\___|_|\___||___/___/ \__,_|\___|\__, |\___|_| |_|
// __/ |
// |___/
pragma solidity ^0.8.17;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
contract HomelessDegen is ERC721AQueryable, ERC721ABurnable, EIP712, Ownable {
uint public normalMintPrice = 0.002 ether;
uint public maxNormalMintPerAccount = 20;
uint public maxWhitelistMintPerAccount = 1;
uint public publicSalesTimestamp = 1666153819;
uint public whitelistSalesTimestamp = 1666153819;
uint public totalNormalMint;
uint public totalWhitelistMint;
uint public maxNormalSupply = 7000;
uint public maxWhitelistSupply = 3000;
uint public whitelistMintPrice = 0 ether;
mapping(address => uint) private _totalNormalMintPerAccount;
mapping(address => uint) private _totalWhitelistMintPerAccount;
address private _signerPublicKey = 0x3794dD48499272Bf9b312067E38c3e337FB85767;
string private _contractUri;
string private _baseUri;
constructor() ERC721A("Homeless Degen", "HD") EIP712("HomelessDegen", "1.0.0") {
}
function mint(uint amount) external payable {
}
function batchMint(address[] calldata addresses, uint[] calldata amounts) external onlyOwner {
}
function whitelistMint(uint amount, bytes calldata signature) external payable {
require(totalWhitelistMint < maxWhitelistSupply, "whitelist mint reached max supply");
require(_recoverAddress(msg.sender, signature) == _signerPublicKey, "account is not whitelisted");
require(isWhitelistSalesActive(), "sales is not active");
require(amount > 0, "invalid amount");
require(msg.value >= amount * whitelistMintPrice, "invalid mint price");
require(amount + totalWhitelistMint <= maxWhitelistSupply, "amount exceeds max supply");
require(<FILL_ME>)
totalWhitelistMint += amount;
_totalWhitelistMintPerAccount[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function isPublicSalesActive() public view returns (bool) {
}
function isWhitelistSalesActive() public view returns (bool) {
}
function hasMintedUsingWhitelist(address account) public view returns (bool) {
}
function totalNormalMintPerAccount(address account) public view returns (uint) {
}
function totalWhitelistMintPerAccount(address account) public view returns (uint) {
}
function contractURI() external view returns (string memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function setContractURI(string memory contractURI_) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function setSignerPublicKey(address signerPublicKey_) external onlyOwner {
}
function setMaxNormalSupply(uint maxNormalSupply_) external onlyOwner {
}
function setMaxWhitelistSupply(uint maxWhitelistSupply_) external onlyOwner {
}
function setNormalMintPrice(uint normalMintPrice_) external onlyOwner {
}
function setWhitelistMintPrice(uint whitelistMintPrice_) external onlyOwner {
}
function setMaxNormalMintPerAccount(uint maxNormalMintPerAccount_) external onlyOwner {
}
function setMaxWhitelistMintPerAccount(uint maxWhitelistMintPerAccount_) external onlyOwner {
}
function setPublicSalesTimestamp(uint timestamp) external onlyOwner {
}
function setWhitelistSalesTimestamp(uint timestamp) external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
function _hash(address account) private view returns (bytes32) {
}
function _recoverAddress(address account, bytes calldata signature) private view returns (address) {
}
}
| amount+_totalWhitelistMintPerAccount[msg.sender]<=maxWhitelistMintPerAccount,"max tokens per account reached" | 454,629 | amount+_totalWhitelistMintPerAccount[msg.sender]<=maxWhitelistMintPerAccount |
"It's not yet time to make a purchase" | // Twitter : @PK_ERC20
pragma solidity ^0.8.0;
contract Token is ERC20Burnable, Ownable{
using SafeERC20 for IERC20;
IUniswapV2Router02 immutable public swapV2Router;
mapping(address => bool) public swapV2Pairs;
address public immutable mainPair;
address public marketAddress;
uint256 MIN_SELL_AMOUNT = 1_000_000 * (10 ** 18);
address immutable public WETH;
bool public swapLock;
bool public limitBuy=false;
uint256 public limitAmount=500_000 *(10 ** 18);
mapping(address=>bool) public whiteList;
mapping(address=>bool) public blackList;
uint256 public buyFee=3;
uint256 public sellFee=3;
constructor(address swapV2RouterAddress_, address _marketAddress) ERC20("Cucumber", "CUCU"){
}
function setWhiteList(address addr,bool isWhite) public onlyOwner{
}
function setLimitBuy() public onlyOwner{
}
function setLimitAmount(uint256 _limitAmount) public onlyOwner{
}
function setMIN_SELL_AMOUNT(uint256 min_Sell) public onlyOwner{
}
function setBlackList(address addr,bool isBlack) public onlyOwner{
}
function setBuyFee(uint256 _buyFee) public onlyOwner{
}
function setSellFee(uint256 _sellFee) public onlyOwner{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
require(<FILL_ME>)
require(!blackList[sender],"You are a blacklisted user!!");
if (sender == address(this) || recipient == address(this)){
super._transfer(sender, recipient, amount);
return;
}
uint256 _fee;
bool _isSell;
if(swapV2Pairs[sender] || swapV2Pairs[recipient]){
(bool isAdd, bool _isRm) = _isLiquidity(sender, recipient, amount);
if (!isAdd && !_isRm){
if(!swapV2Pairs[sender]){
_isSell = true;
}
if(limitBuy && (whiteList[sender] || whiteList[recipient])){
if(swapV2Pairs[sender]){
require(amount<limitAmount,"beyong buy amount");
}
_fee=0;
}else{
//buy
if(swapV2Pairs[sender]){
_fee = amount * buyFee / 100;
}else{
//sell
_fee = amount * sellFee / 100;
}
}
}
}
if (_fee > 0){
super._transfer(sender, address(this), _fee);
amount -= _fee;
}
if (_isSell && balanceOf(address(this)) >= MIN_SELL_AMOUNT){
swapLock = true;
swapTokenToETH(balanceOf(address(this)), marketAddress);
swapLock = false;
}
super._transfer(sender, recipient, amount);
}
function swapTokenToETH(uint256 _amount, address _to) internal {
}
function updateSwapPairConfig(address pair_, bool status_) public onlyOwner {
}
function updateMarketAddress(address _marketAddress) public onlyOwner {
}
function _isLiquidity(address from, address to, uint256 amount) internal view returns (bool isAdd, bool isRm){
}
}
| !limitBuy||whiteList[sender]||whiteList[recipient],"It's not yet time to make a purchase" | 454,733 | !limitBuy||whiteList[sender]||whiteList[recipient] |
"You are a blacklisted user!!" | // Twitter : @PK_ERC20
pragma solidity ^0.8.0;
contract Token is ERC20Burnable, Ownable{
using SafeERC20 for IERC20;
IUniswapV2Router02 immutable public swapV2Router;
mapping(address => bool) public swapV2Pairs;
address public immutable mainPair;
address public marketAddress;
uint256 MIN_SELL_AMOUNT = 1_000_000 * (10 ** 18);
address immutable public WETH;
bool public swapLock;
bool public limitBuy=false;
uint256 public limitAmount=500_000 *(10 ** 18);
mapping(address=>bool) public whiteList;
mapping(address=>bool) public blackList;
uint256 public buyFee=3;
uint256 public sellFee=3;
constructor(address swapV2RouterAddress_, address _marketAddress) ERC20("Cucumber", "CUCU"){
}
function setWhiteList(address addr,bool isWhite) public onlyOwner{
}
function setLimitBuy() public onlyOwner{
}
function setLimitAmount(uint256 _limitAmount) public onlyOwner{
}
function setMIN_SELL_AMOUNT(uint256 min_Sell) public onlyOwner{
}
function setBlackList(address addr,bool isBlack) public onlyOwner{
}
function setBuyFee(uint256 _buyFee) public onlyOwner{
}
function setSellFee(uint256 _sellFee) public onlyOwner{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
require(!limitBuy || whiteList[sender] || whiteList[recipient],"It's not yet time to make a purchase");
require(<FILL_ME>)
if (sender == address(this) || recipient == address(this)){
super._transfer(sender, recipient, amount);
return;
}
uint256 _fee;
bool _isSell;
if(swapV2Pairs[sender] || swapV2Pairs[recipient]){
(bool isAdd, bool _isRm) = _isLiquidity(sender, recipient, amount);
if (!isAdd && !_isRm){
if(!swapV2Pairs[sender]){
_isSell = true;
}
if(limitBuy && (whiteList[sender] || whiteList[recipient])){
if(swapV2Pairs[sender]){
require(amount<limitAmount,"beyong buy amount");
}
_fee=0;
}else{
//buy
if(swapV2Pairs[sender]){
_fee = amount * buyFee / 100;
}else{
//sell
_fee = amount * sellFee / 100;
}
}
}
}
if (_fee > 0){
super._transfer(sender, address(this), _fee);
amount -= _fee;
}
if (_isSell && balanceOf(address(this)) >= MIN_SELL_AMOUNT){
swapLock = true;
swapTokenToETH(balanceOf(address(this)), marketAddress);
swapLock = false;
}
super._transfer(sender, recipient, amount);
}
function swapTokenToETH(uint256 _amount, address _to) internal {
}
function updateSwapPairConfig(address pair_, bool status_) public onlyOwner {
}
function updateMarketAddress(address _marketAddress) public onlyOwner {
}
function _isLiquidity(address from, address to, uint256 amount) internal view returns (bool isAdd, bool isRm){
}
}
| !blackList[sender],"You are a blacklisted user!!" | 454,733 | !blackList[sender] |
"A" | // Twitter : @PK_ERC20
pragma solidity ^0.8.0;
contract Token is ERC20Burnable, Ownable{
using SafeERC20 for IERC20;
IUniswapV2Router02 immutable public swapV2Router;
mapping(address => bool) public swapV2Pairs;
address public immutable mainPair;
address public marketAddress;
uint256 MIN_SELL_AMOUNT = 1_000_000 * (10 ** 18);
address immutable public WETH;
bool public swapLock;
bool public limitBuy=false;
uint256 public limitAmount=500_000 *(10 ** 18);
mapping(address=>bool) public whiteList;
mapping(address=>bool) public blackList;
uint256 public buyFee=3;
uint256 public sellFee=3;
constructor(address swapV2RouterAddress_, address _marketAddress) ERC20("Cucumber", "CUCU"){
}
function setWhiteList(address addr,bool isWhite) public onlyOwner{
}
function setLimitBuy() public onlyOwner{
}
function setLimitAmount(uint256 _limitAmount) public onlyOwner{
}
function setMIN_SELL_AMOUNT(uint256 min_Sell) public onlyOwner{
}
function setBlackList(address addr,bool isBlack) public onlyOwner{
}
function setBuyFee(uint256 _buyFee) public onlyOwner{
}
function setSellFee(uint256 _sellFee) public onlyOwner{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function swapTokenToETH(uint256 _amount, address _to) internal {
}
function updateSwapPairConfig(address pair_, bool status_) public onlyOwner {
require(<FILL_ME>)
swapV2Pairs[pair_] = status_;
}
function updateMarketAddress(address _marketAddress) public onlyOwner {
}
function _isLiquidity(address from, address to, uint256 amount) internal view returns (bool isAdd, bool isRm){
}
}
| swapV2Pairs[pair_]!=status_,"A" | 454,733 | swapV2Pairs[pair_]!=status_ |
"Insufficient balance" | // contracts/QuantumFrog.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.22;
contract QuantumFrog {
string public constant name = "QuantumFrog";
string public constant symbol = "QuantumFrog";
uint8 public constant decimals = 18;
uint public totalSupply = 21000000 * (10 ** uint(decimals));
mapping(address => uint) public balances;
mapping(address => mapping(address => uint)) public allowed;
address public owner = 0x4fA5711d0541465Dde40D878a1dE718e346b7e15;
uint public constant taxPercentage = 3;
event Transfer(address indexed from, address indexed to, uint tokens, bool isBuy);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
modifier onlyOwner() {
}
constructor() {
}
function transfer(address to, uint tokens) public returns (bool success) {
}
function _applyTax(uint taxAmount) internal {
}
function approve(address spender, uint tokens) public returns (bool success) {
}
function buy(uint tokens) public returns (bool success) {
uint taxAmount = (tokens * taxPercentage) / 100;
uint tokensAfterTax = tokens - taxAmount;
require(<FILL_ME>)
balances[owner] -= tokensAfterTax;
balances[msg.sender] += tokensAfterTax;
emit Transfer(owner, msg.sender, tokensAfterTax, true);
_applyTax(taxAmount);
return true;
}
function sell(uint tokens) public returns (bool success) {
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
}
function balanceOf(address tokenOwner) public view returns (uint balance) {
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
}
function burn(uint amount) public {
}
}
| balances[owner]>=tokensAfterTax,"Insufficient balance" | 454,751 | balances[owner]>=tokensAfterTax |
"Operator not allowed" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/// @title Bulls and Apes Project - APES
/// @author BAP Dev Team
/// @notice ERC721 for BAP ecosystem
contract BAPApes is ERC721Enumerable, Ownable, ReentrancyGuard {
using Strings for uint256;
string baseURI;
/// @notice Max supply of Apes to be minted
uint256 public constant MAX_SUPPLY = 10000;
/// @notice Max minting limit during sale
uint256 public mintLimit = 2;
/// @notice Supply reserved for public sale
/// @dev Return amount remaining
uint256 public publicSupply = 3500;
/// @notice Supply reserved for Portal Pass Exchange
/// @dev Return amount remaining
uint256 public reservedSupply = 5000;
/// @notice Supply reserved for treasury and team
/// @dev Return amount remaining
uint256 public treasurySupply = 1500;
/// @notice Prices for public sale
uint256[] public tierPrices = [
0.22 ether,
0.27 ether,
0.3 ether,
0.33 ether,
0.33 ether,
0.37 ether
];
/// @notice ERC1155 Portal Pass
IERC1155 public portalPass;
/// @notice Signer address for encrypted signatures
address public secret;
/// @notice Address of BAP treasury
address public treasury;
/// @notice Dead wallet to send exchanged Portal Passes
address private constant DEAD_ADDRESS =
0x000000000000000000000000000000000000dEaD;
/// @notice Original minting price for each Ape
mapping(uint256 => uint256) public mintingPrice;
/// @notice Original minting date for each Ape
mapping(uint256 => uint256) public mintingDate;
/// @notice Refund flag for each Ape
mapping(uint256 => bool) public notRefundable;
/// @notice Authorization flag for orchestrators
mapping(address => bool) public isOrchestrator;
/// @notice Amount minted per wallet and per tier
mapping(address => mapping(uint256 => uint256)) public walletMinted;
event Purchased(address operator, address user, uint256 amount);
event PassExchanged(address operator, address user, uint256 amount);
event Airdrop(address operator, address user, uint256 amount);
event TraitsChanged(address user, uint256 tokenId, uint256 newTokenId);
event Refunded(address user, uint256 tokenId);
event MintLimitChanged(uint256 limit, address operator);
/// @notice Deploys the contract
/// @param portalAddress Address of portal passes
/// @param secretAddress Signer address
/// @dev Create ERC721 token: BAP APES - BAPAPES
constructor(address portalAddress, address secretAddress)
ERC721("BAP APES", "BAPAPES")
{
}
/// @notice Check if caller is an orchestrator
/// @dev Revert transaction is msg.sender is not Authorized
modifier onlyOrchestrator() {
require(<FILL_ME>)
_;
}
/// @notice Check if the wallet is valid
/// @dev Revert transaction if zero address
modifier noZeroAddress(address _address) {
}
/// @notice Purchase an Ape from public supply
/// @param to Address to send the token
/// @param amount Amount of tokens to be minted
/// @param tier Current tier
function purchase(
address to,
uint256 amount,
uint256 tier,
bytes memory signature
) external payable {
}
/// @notice Airdrop an Ape from treasury supply
/// @param to Address to send the token
/// @param amount Amount of tokens to be minted
function airdrop(address to, uint256 amount)
external
nonReentrant
onlyOwner
{
}
/// @notice Exchange Portal Passes for Apes
/// @param to Address to send the token
/// @param amount Amount of passes to be exchanged
function exchangePass(address to, uint256 amount) external {
}
/// @notice Confirm traits changes from Trait Constructor
/// @param tokenId Ape the be modified
/// @dev Can only be called by authorized orchestrators
function confirmChange(uint256 tokenId) external onlyOrchestrator {
}
/// @notice Internal function to mint Apes, set initial price and timestamp
/// @param to Address to send the tokens
/// @param amount Amount of tokens to be minted
/// @param price Price payed for each token
function mint(
address to,
uint256 amount,
uint256 price
) internal {
}
/// @notice 6-Month ETH back function
/// @param depositAddress Address to refund the funds
/// @param tokenId Ape ID to be refunded
/// @dev Can only be called by authorized orchestrators during refund period
function refund(address depositAddress, uint256 tokenId)
external
onlyOrchestrator
noZeroAddress(depositAddress)
{
}
/// @notice Change the mint limit for public sale
/// @param newLimit new minting limit
/// @dev Can only be called by the contract owner
function setMintLimit(uint256 newLimit) external onlyOwner {
}
/// @notice Change the Base URI
/// @param newURI new URI to be set
/// @dev Can only be called by the contract owner
function setBaseURI(string memory newURI) external onlyOwner {
}
/// @notice Change the signer address
/// @param secretAddress new signer for encrypted signatures
/// @dev Can only be called by the contract owner
function setSecret(address secretAddress)
external
onlyOwner
noZeroAddress(secretAddress)
{
}
/// @notice Change the treasury address
/// @param treasuryAddress new treasury address
/// @dev Can only be called by the contract owner
function setTreasury(address treasuryAddress)
external
onlyOwner
noZeroAddress(treasuryAddress)
{
}
/// @notice Change the portal pass address
/// @param portalAddress new portal pass contract
/// @dev Can only be called by the contract owner
function setPortalPass(address portalAddress)
external
onlyOwner
noZeroAddress(portalAddress)
{
}
/// @notice Add new authorized orchestrators
/// @param operator Orchestrator address
/// @param status set authorization true or false
/// @dev Can only be called by the contract owner
function setOrchestrator(address operator, bool status)
external
onlyOwner
noZeroAddress(operator)
{
}
/// @notice Send ETH to specific address
/// @param to Address to send the funds
/// @param amount ETH amount to be sent
/// @dev Can only be called by the contract owner
function withdrawETH(address to, uint256 amount)
public
nonReentrant
onlyOwner
noZeroAddress(to)
{
}
/// @notice Return Base URI
function _baseURI() internal view virtual override returns (string memory) {
}
/// @notice Inherit from ERC721, return token URI, revert is tokenId doesn't exist
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/// @notice Inherit from ERC721, added check of transfer period for refund
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override(ERC721, IERC721) {
}
/// @notice Inherit from ERC721, added check of transfer period for refund
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override(ERC721, IERC721) {
}
/// @notice Checks transfer after allow period to invalidate refund
function _checkTransferPeriod(uint256 tokenId) internal {
}
/// @notice Inherit from ERC721, checks if a token exists
function exists(uint256 tokenId) external view returns (bool) {
}
/// @notice Verify that message is signed by secret wallet
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
}
| isOrchestrator[msg.sender],"Operator not allowed" | 454,810 | isOrchestrator[msg.sender] |
"Purchase: Exceed mint limit" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/// @title Bulls and Apes Project - APES
/// @author BAP Dev Team
/// @notice ERC721 for BAP ecosystem
contract BAPApes is ERC721Enumerable, Ownable, ReentrancyGuard {
using Strings for uint256;
string baseURI;
/// @notice Max supply of Apes to be minted
uint256 public constant MAX_SUPPLY = 10000;
/// @notice Max minting limit during sale
uint256 public mintLimit = 2;
/// @notice Supply reserved for public sale
/// @dev Return amount remaining
uint256 public publicSupply = 3500;
/// @notice Supply reserved for Portal Pass Exchange
/// @dev Return amount remaining
uint256 public reservedSupply = 5000;
/// @notice Supply reserved for treasury and team
/// @dev Return amount remaining
uint256 public treasurySupply = 1500;
/// @notice Prices for public sale
uint256[] public tierPrices = [
0.22 ether,
0.27 ether,
0.3 ether,
0.33 ether,
0.33 ether,
0.37 ether
];
/// @notice ERC1155 Portal Pass
IERC1155 public portalPass;
/// @notice Signer address for encrypted signatures
address public secret;
/// @notice Address of BAP treasury
address public treasury;
/// @notice Dead wallet to send exchanged Portal Passes
address private constant DEAD_ADDRESS =
0x000000000000000000000000000000000000dEaD;
/// @notice Original minting price for each Ape
mapping(uint256 => uint256) public mintingPrice;
/// @notice Original minting date for each Ape
mapping(uint256 => uint256) public mintingDate;
/// @notice Refund flag for each Ape
mapping(uint256 => bool) public notRefundable;
/// @notice Authorization flag for orchestrators
mapping(address => bool) public isOrchestrator;
/// @notice Amount minted per wallet and per tier
mapping(address => mapping(uint256 => uint256)) public walletMinted;
event Purchased(address operator, address user, uint256 amount);
event PassExchanged(address operator, address user, uint256 amount);
event Airdrop(address operator, address user, uint256 amount);
event TraitsChanged(address user, uint256 tokenId, uint256 newTokenId);
event Refunded(address user, uint256 tokenId);
event MintLimitChanged(uint256 limit, address operator);
/// @notice Deploys the contract
/// @param portalAddress Address of portal passes
/// @param secretAddress Signer address
/// @dev Create ERC721 token: BAP APES - BAPAPES
constructor(address portalAddress, address secretAddress)
ERC721("BAP APES", "BAPAPES")
{
}
/// @notice Check if caller is an orchestrator
/// @dev Revert transaction is msg.sender is not Authorized
modifier onlyOrchestrator() {
}
/// @notice Check if the wallet is valid
/// @dev Revert transaction if zero address
modifier noZeroAddress(address _address) {
}
/// @notice Purchase an Ape from public supply
/// @param to Address to send the token
/// @param amount Amount of tokens to be minted
/// @param tier Current tier
function purchase(
address to,
uint256 amount,
uint256 tier,
bytes memory signature
) external payable {
require(tier <= 5, "Purchase: Sale closed");
require(amount <= publicSupply, "Purchase: Supply is over");
require(<FILL_ME>)
require(
amount * tierPrices[tier] == msg.value,
"Purchase: Incorrect ETH amount"
);
require(
_verifyHashSignature(
keccak256(abi.encode(amount, tier, to)),
signature
),
"Purchase: Signature is invalid"
);
walletMinted[to][tier] += amount;
publicSupply -= amount;
mint(to, amount, tierPrices[tier]);
emit Purchased(msg.sender, to, amount);
}
/// @notice Airdrop an Ape from treasury supply
/// @param to Address to send the token
/// @param amount Amount of tokens to be minted
function airdrop(address to, uint256 amount)
external
nonReentrant
onlyOwner
{
}
/// @notice Exchange Portal Passes for Apes
/// @param to Address to send the token
/// @param amount Amount of passes to be exchanged
function exchangePass(address to, uint256 amount) external {
}
/// @notice Confirm traits changes from Trait Constructor
/// @param tokenId Ape the be modified
/// @dev Can only be called by authorized orchestrators
function confirmChange(uint256 tokenId) external onlyOrchestrator {
}
/// @notice Internal function to mint Apes, set initial price and timestamp
/// @param to Address to send the tokens
/// @param amount Amount of tokens to be minted
/// @param price Price payed for each token
function mint(
address to,
uint256 amount,
uint256 price
) internal {
}
/// @notice 6-Month ETH back function
/// @param depositAddress Address to refund the funds
/// @param tokenId Ape ID to be refunded
/// @dev Can only be called by authorized orchestrators during refund period
function refund(address depositAddress, uint256 tokenId)
external
onlyOrchestrator
noZeroAddress(depositAddress)
{
}
/// @notice Change the mint limit for public sale
/// @param newLimit new minting limit
/// @dev Can only be called by the contract owner
function setMintLimit(uint256 newLimit) external onlyOwner {
}
/// @notice Change the Base URI
/// @param newURI new URI to be set
/// @dev Can only be called by the contract owner
function setBaseURI(string memory newURI) external onlyOwner {
}
/// @notice Change the signer address
/// @param secretAddress new signer for encrypted signatures
/// @dev Can only be called by the contract owner
function setSecret(address secretAddress)
external
onlyOwner
noZeroAddress(secretAddress)
{
}
/// @notice Change the treasury address
/// @param treasuryAddress new treasury address
/// @dev Can only be called by the contract owner
function setTreasury(address treasuryAddress)
external
onlyOwner
noZeroAddress(treasuryAddress)
{
}
/// @notice Change the portal pass address
/// @param portalAddress new portal pass contract
/// @dev Can only be called by the contract owner
function setPortalPass(address portalAddress)
external
onlyOwner
noZeroAddress(portalAddress)
{
}
/// @notice Add new authorized orchestrators
/// @param operator Orchestrator address
/// @param status set authorization true or false
/// @dev Can only be called by the contract owner
function setOrchestrator(address operator, bool status)
external
onlyOwner
noZeroAddress(operator)
{
}
/// @notice Send ETH to specific address
/// @param to Address to send the funds
/// @param amount ETH amount to be sent
/// @dev Can only be called by the contract owner
function withdrawETH(address to, uint256 amount)
public
nonReentrant
onlyOwner
noZeroAddress(to)
{
}
/// @notice Return Base URI
function _baseURI() internal view virtual override returns (string memory) {
}
/// @notice Inherit from ERC721, return token URI, revert is tokenId doesn't exist
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/// @notice Inherit from ERC721, added check of transfer period for refund
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override(ERC721, IERC721) {
}
/// @notice Inherit from ERC721, added check of transfer period for refund
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override(ERC721, IERC721) {
}
/// @notice Checks transfer after allow period to invalidate refund
function _checkTransferPeriod(uint256 tokenId) internal {
}
/// @notice Inherit from ERC721, checks if a token exists
function exists(uint256 tokenId) external view returns (bool) {
}
/// @notice Verify that message is signed by secret wallet
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
}
| amount+walletMinted[to][tier]<=mintLimit,"Purchase: Exceed mint limit" | 454,810 | amount+walletMinted[to][tier]<=mintLimit |
"Purchase: Incorrect ETH amount" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/// @title Bulls and Apes Project - APES
/// @author BAP Dev Team
/// @notice ERC721 for BAP ecosystem
contract BAPApes is ERC721Enumerable, Ownable, ReentrancyGuard {
using Strings for uint256;
string baseURI;
/// @notice Max supply of Apes to be minted
uint256 public constant MAX_SUPPLY = 10000;
/// @notice Max minting limit during sale
uint256 public mintLimit = 2;
/// @notice Supply reserved for public sale
/// @dev Return amount remaining
uint256 public publicSupply = 3500;
/// @notice Supply reserved for Portal Pass Exchange
/// @dev Return amount remaining
uint256 public reservedSupply = 5000;
/// @notice Supply reserved for treasury and team
/// @dev Return amount remaining
uint256 public treasurySupply = 1500;
/// @notice Prices for public sale
uint256[] public tierPrices = [
0.22 ether,
0.27 ether,
0.3 ether,
0.33 ether,
0.33 ether,
0.37 ether
];
/// @notice ERC1155 Portal Pass
IERC1155 public portalPass;
/// @notice Signer address for encrypted signatures
address public secret;
/// @notice Address of BAP treasury
address public treasury;
/// @notice Dead wallet to send exchanged Portal Passes
address private constant DEAD_ADDRESS =
0x000000000000000000000000000000000000dEaD;
/// @notice Original minting price for each Ape
mapping(uint256 => uint256) public mintingPrice;
/// @notice Original minting date for each Ape
mapping(uint256 => uint256) public mintingDate;
/// @notice Refund flag for each Ape
mapping(uint256 => bool) public notRefundable;
/// @notice Authorization flag for orchestrators
mapping(address => bool) public isOrchestrator;
/// @notice Amount minted per wallet and per tier
mapping(address => mapping(uint256 => uint256)) public walletMinted;
event Purchased(address operator, address user, uint256 amount);
event PassExchanged(address operator, address user, uint256 amount);
event Airdrop(address operator, address user, uint256 amount);
event TraitsChanged(address user, uint256 tokenId, uint256 newTokenId);
event Refunded(address user, uint256 tokenId);
event MintLimitChanged(uint256 limit, address operator);
/// @notice Deploys the contract
/// @param portalAddress Address of portal passes
/// @param secretAddress Signer address
/// @dev Create ERC721 token: BAP APES - BAPAPES
constructor(address portalAddress, address secretAddress)
ERC721("BAP APES", "BAPAPES")
{
}
/// @notice Check if caller is an orchestrator
/// @dev Revert transaction is msg.sender is not Authorized
modifier onlyOrchestrator() {
}
/// @notice Check if the wallet is valid
/// @dev Revert transaction if zero address
modifier noZeroAddress(address _address) {
}
/// @notice Purchase an Ape from public supply
/// @param to Address to send the token
/// @param amount Amount of tokens to be minted
/// @param tier Current tier
function purchase(
address to,
uint256 amount,
uint256 tier,
bytes memory signature
) external payable {
require(tier <= 5, "Purchase: Sale closed");
require(amount <= publicSupply, "Purchase: Supply is over");
require(
amount + walletMinted[to][tier] <= mintLimit,
"Purchase: Exceed mint limit"
);
require(<FILL_ME>)
require(
_verifyHashSignature(
keccak256(abi.encode(amount, tier, to)),
signature
),
"Purchase: Signature is invalid"
);
walletMinted[to][tier] += amount;
publicSupply -= amount;
mint(to, amount, tierPrices[tier]);
emit Purchased(msg.sender, to, amount);
}
/// @notice Airdrop an Ape from treasury supply
/// @param to Address to send the token
/// @param amount Amount of tokens to be minted
function airdrop(address to, uint256 amount)
external
nonReentrant
onlyOwner
{
}
/// @notice Exchange Portal Passes for Apes
/// @param to Address to send the token
/// @param amount Amount of passes to be exchanged
function exchangePass(address to, uint256 amount) external {
}
/// @notice Confirm traits changes from Trait Constructor
/// @param tokenId Ape the be modified
/// @dev Can only be called by authorized orchestrators
function confirmChange(uint256 tokenId) external onlyOrchestrator {
}
/// @notice Internal function to mint Apes, set initial price and timestamp
/// @param to Address to send the tokens
/// @param amount Amount of tokens to be minted
/// @param price Price payed for each token
function mint(
address to,
uint256 amount,
uint256 price
) internal {
}
/// @notice 6-Month ETH back function
/// @param depositAddress Address to refund the funds
/// @param tokenId Ape ID to be refunded
/// @dev Can only be called by authorized orchestrators during refund period
function refund(address depositAddress, uint256 tokenId)
external
onlyOrchestrator
noZeroAddress(depositAddress)
{
}
/// @notice Change the mint limit for public sale
/// @param newLimit new minting limit
/// @dev Can only be called by the contract owner
function setMintLimit(uint256 newLimit) external onlyOwner {
}
/// @notice Change the Base URI
/// @param newURI new URI to be set
/// @dev Can only be called by the contract owner
function setBaseURI(string memory newURI) external onlyOwner {
}
/// @notice Change the signer address
/// @param secretAddress new signer for encrypted signatures
/// @dev Can only be called by the contract owner
function setSecret(address secretAddress)
external
onlyOwner
noZeroAddress(secretAddress)
{
}
/// @notice Change the treasury address
/// @param treasuryAddress new treasury address
/// @dev Can only be called by the contract owner
function setTreasury(address treasuryAddress)
external
onlyOwner
noZeroAddress(treasuryAddress)
{
}
/// @notice Change the portal pass address
/// @param portalAddress new portal pass contract
/// @dev Can only be called by the contract owner
function setPortalPass(address portalAddress)
external
onlyOwner
noZeroAddress(portalAddress)
{
}
/// @notice Add new authorized orchestrators
/// @param operator Orchestrator address
/// @param status set authorization true or false
/// @dev Can only be called by the contract owner
function setOrchestrator(address operator, bool status)
external
onlyOwner
noZeroAddress(operator)
{
}
/// @notice Send ETH to specific address
/// @param to Address to send the funds
/// @param amount ETH amount to be sent
/// @dev Can only be called by the contract owner
function withdrawETH(address to, uint256 amount)
public
nonReentrant
onlyOwner
noZeroAddress(to)
{
}
/// @notice Return Base URI
function _baseURI() internal view virtual override returns (string memory) {
}
/// @notice Inherit from ERC721, return token URI, revert is tokenId doesn't exist
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/// @notice Inherit from ERC721, added check of transfer period for refund
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override(ERC721, IERC721) {
}
/// @notice Inherit from ERC721, added check of transfer period for refund
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override(ERC721, IERC721) {
}
/// @notice Checks transfer after allow period to invalidate refund
function _checkTransferPeriod(uint256 tokenId) internal {
}
/// @notice Inherit from ERC721, checks if a token exists
function exists(uint256 tokenId) external view returns (bool) {
}
/// @notice Verify that message is signed by secret wallet
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
}
| amount*tierPrices[tier]==msg.value,"Purchase: Incorrect ETH amount" | 454,810 | amount*tierPrices[tier]==msg.value |
"Purchase: Signature is invalid" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/// @title Bulls and Apes Project - APES
/// @author BAP Dev Team
/// @notice ERC721 for BAP ecosystem
contract BAPApes is ERC721Enumerable, Ownable, ReentrancyGuard {
using Strings for uint256;
string baseURI;
/// @notice Max supply of Apes to be minted
uint256 public constant MAX_SUPPLY = 10000;
/// @notice Max minting limit during sale
uint256 public mintLimit = 2;
/// @notice Supply reserved for public sale
/// @dev Return amount remaining
uint256 public publicSupply = 3500;
/// @notice Supply reserved for Portal Pass Exchange
/// @dev Return amount remaining
uint256 public reservedSupply = 5000;
/// @notice Supply reserved for treasury and team
/// @dev Return amount remaining
uint256 public treasurySupply = 1500;
/// @notice Prices for public sale
uint256[] public tierPrices = [
0.22 ether,
0.27 ether,
0.3 ether,
0.33 ether,
0.33 ether,
0.37 ether
];
/// @notice ERC1155 Portal Pass
IERC1155 public portalPass;
/// @notice Signer address for encrypted signatures
address public secret;
/// @notice Address of BAP treasury
address public treasury;
/// @notice Dead wallet to send exchanged Portal Passes
address private constant DEAD_ADDRESS =
0x000000000000000000000000000000000000dEaD;
/// @notice Original minting price for each Ape
mapping(uint256 => uint256) public mintingPrice;
/// @notice Original minting date for each Ape
mapping(uint256 => uint256) public mintingDate;
/// @notice Refund flag for each Ape
mapping(uint256 => bool) public notRefundable;
/// @notice Authorization flag for orchestrators
mapping(address => bool) public isOrchestrator;
/// @notice Amount minted per wallet and per tier
mapping(address => mapping(uint256 => uint256)) public walletMinted;
event Purchased(address operator, address user, uint256 amount);
event PassExchanged(address operator, address user, uint256 amount);
event Airdrop(address operator, address user, uint256 amount);
event TraitsChanged(address user, uint256 tokenId, uint256 newTokenId);
event Refunded(address user, uint256 tokenId);
event MintLimitChanged(uint256 limit, address operator);
/// @notice Deploys the contract
/// @param portalAddress Address of portal passes
/// @param secretAddress Signer address
/// @dev Create ERC721 token: BAP APES - BAPAPES
constructor(address portalAddress, address secretAddress)
ERC721("BAP APES", "BAPAPES")
{
}
/// @notice Check if caller is an orchestrator
/// @dev Revert transaction is msg.sender is not Authorized
modifier onlyOrchestrator() {
}
/// @notice Check if the wallet is valid
/// @dev Revert transaction if zero address
modifier noZeroAddress(address _address) {
}
/// @notice Purchase an Ape from public supply
/// @param to Address to send the token
/// @param amount Amount of tokens to be minted
/// @param tier Current tier
function purchase(
address to,
uint256 amount,
uint256 tier,
bytes memory signature
) external payable {
require(tier <= 5, "Purchase: Sale closed");
require(amount <= publicSupply, "Purchase: Supply is over");
require(
amount + walletMinted[to][tier] <= mintLimit,
"Purchase: Exceed mint limit"
);
require(
amount * tierPrices[tier] == msg.value,
"Purchase: Incorrect ETH amount"
);
require(<FILL_ME>)
walletMinted[to][tier] += amount;
publicSupply -= amount;
mint(to, amount, tierPrices[tier]);
emit Purchased(msg.sender, to, amount);
}
/// @notice Airdrop an Ape from treasury supply
/// @param to Address to send the token
/// @param amount Amount of tokens to be minted
function airdrop(address to, uint256 amount)
external
nonReentrant
onlyOwner
{
}
/// @notice Exchange Portal Passes for Apes
/// @param to Address to send the token
/// @param amount Amount of passes to be exchanged
function exchangePass(address to, uint256 amount) external {
}
/// @notice Confirm traits changes from Trait Constructor
/// @param tokenId Ape the be modified
/// @dev Can only be called by authorized orchestrators
function confirmChange(uint256 tokenId) external onlyOrchestrator {
}
/// @notice Internal function to mint Apes, set initial price and timestamp
/// @param to Address to send the tokens
/// @param amount Amount of tokens to be minted
/// @param price Price payed for each token
function mint(
address to,
uint256 amount,
uint256 price
) internal {
}
/// @notice 6-Month ETH back function
/// @param depositAddress Address to refund the funds
/// @param tokenId Ape ID to be refunded
/// @dev Can only be called by authorized orchestrators during refund period
function refund(address depositAddress, uint256 tokenId)
external
onlyOrchestrator
noZeroAddress(depositAddress)
{
}
/// @notice Change the mint limit for public sale
/// @param newLimit new minting limit
/// @dev Can only be called by the contract owner
function setMintLimit(uint256 newLimit) external onlyOwner {
}
/// @notice Change the Base URI
/// @param newURI new URI to be set
/// @dev Can only be called by the contract owner
function setBaseURI(string memory newURI) external onlyOwner {
}
/// @notice Change the signer address
/// @param secretAddress new signer for encrypted signatures
/// @dev Can only be called by the contract owner
function setSecret(address secretAddress)
external
onlyOwner
noZeroAddress(secretAddress)
{
}
/// @notice Change the treasury address
/// @param treasuryAddress new treasury address
/// @dev Can only be called by the contract owner
function setTreasury(address treasuryAddress)
external
onlyOwner
noZeroAddress(treasuryAddress)
{
}
/// @notice Change the portal pass address
/// @param portalAddress new portal pass contract
/// @dev Can only be called by the contract owner
function setPortalPass(address portalAddress)
external
onlyOwner
noZeroAddress(portalAddress)
{
}
/// @notice Add new authorized orchestrators
/// @param operator Orchestrator address
/// @param status set authorization true or false
/// @dev Can only be called by the contract owner
function setOrchestrator(address operator, bool status)
external
onlyOwner
noZeroAddress(operator)
{
}
/// @notice Send ETH to specific address
/// @param to Address to send the funds
/// @param amount ETH amount to be sent
/// @dev Can only be called by the contract owner
function withdrawETH(address to, uint256 amount)
public
nonReentrant
onlyOwner
noZeroAddress(to)
{
}
/// @notice Return Base URI
function _baseURI() internal view virtual override returns (string memory) {
}
/// @notice Inherit from ERC721, return token URI, revert is tokenId doesn't exist
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/// @notice Inherit from ERC721, added check of transfer period for refund
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override(ERC721, IERC721) {
}
/// @notice Inherit from ERC721, added check of transfer period for refund
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override(ERC721, IERC721) {
}
/// @notice Checks transfer after allow period to invalidate refund
function _checkTransferPeriod(uint256 tokenId) internal {
}
/// @notice Inherit from ERC721, checks if a token exists
function exists(uint256 tokenId) external view returns (bool) {
}
/// @notice Verify that message is signed by secret wallet
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
}
| _verifyHashSignature(keccak256(abi.encode(amount,tier,to)),signature),"Purchase: Signature is invalid" | 454,810 | _verifyHashSignature(keccak256(abi.encode(amount,tier,to)),signature) |
"Mint: Supply limit" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/// @title Bulls and Apes Project - APES
/// @author BAP Dev Team
/// @notice ERC721 for BAP ecosystem
contract BAPApes is ERC721Enumerable, Ownable, ReentrancyGuard {
using Strings for uint256;
string baseURI;
/// @notice Max supply of Apes to be minted
uint256 public constant MAX_SUPPLY = 10000;
/// @notice Max minting limit during sale
uint256 public mintLimit = 2;
/// @notice Supply reserved for public sale
/// @dev Return amount remaining
uint256 public publicSupply = 3500;
/// @notice Supply reserved for Portal Pass Exchange
/// @dev Return amount remaining
uint256 public reservedSupply = 5000;
/// @notice Supply reserved for treasury and team
/// @dev Return amount remaining
uint256 public treasurySupply = 1500;
/// @notice Prices for public sale
uint256[] public tierPrices = [
0.22 ether,
0.27 ether,
0.3 ether,
0.33 ether,
0.33 ether,
0.37 ether
];
/// @notice ERC1155 Portal Pass
IERC1155 public portalPass;
/// @notice Signer address for encrypted signatures
address public secret;
/// @notice Address of BAP treasury
address public treasury;
/// @notice Dead wallet to send exchanged Portal Passes
address private constant DEAD_ADDRESS =
0x000000000000000000000000000000000000dEaD;
/// @notice Original minting price for each Ape
mapping(uint256 => uint256) public mintingPrice;
/// @notice Original minting date for each Ape
mapping(uint256 => uint256) public mintingDate;
/// @notice Refund flag for each Ape
mapping(uint256 => bool) public notRefundable;
/// @notice Authorization flag for orchestrators
mapping(address => bool) public isOrchestrator;
/// @notice Amount minted per wallet and per tier
mapping(address => mapping(uint256 => uint256)) public walletMinted;
event Purchased(address operator, address user, uint256 amount);
event PassExchanged(address operator, address user, uint256 amount);
event Airdrop(address operator, address user, uint256 amount);
event TraitsChanged(address user, uint256 tokenId, uint256 newTokenId);
event Refunded(address user, uint256 tokenId);
event MintLimitChanged(uint256 limit, address operator);
/// @notice Deploys the contract
/// @param portalAddress Address of portal passes
/// @param secretAddress Signer address
/// @dev Create ERC721 token: BAP APES - BAPAPES
constructor(address portalAddress, address secretAddress)
ERC721("BAP APES", "BAPAPES")
{
}
/// @notice Check if caller is an orchestrator
/// @dev Revert transaction is msg.sender is not Authorized
modifier onlyOrchestrator() {
}
/// @notice Check if the wallet is valid
/// @dev Revert transaction if zero address
modifier noZeroAddress(address _address) {
}
/// @notice Purchase an Ape from public supply
/// @param to Address to send the token
/// @param amount Amount of tokens to be minted
/// @param tier Current tier
function purchase(
address to,
uint256 amount,
uint256 tier,
bytes memory signature
) external payable {
}
/// @notice Airdrop an Ape from treasury supply
/// @param to Address to send the token
/// @param amount Amount of tokens to be minted
function airdrop(address to, uint256 amount)
external
nonReentrant
onlyOwner
{
}
/// @notice Exchange Portal Passes for Apes
/// @param to Address to send the token
/// @param amount Amount of passes to be exchanged
function exchangePass(address to, uint256 amount) external {
}
/// @notice Confirm traits changes from Trait Constructor
/// @param tokenId Ape the be modified
/// @dev Can only be called by authorized orchestrators
function confirmChange(uint256 tokenId) external onlyOrchestrator {
}
/// @notice Internal function to mint Apes, set initial price and timestamp
/// @param to Address to send the tokens
/// @param amount Amount of tokens to be minted
/// @param price Price payed for each token
function mint(
address to,
uint256 amount,
uint256 price
) internal {
uint256 currentSupply = totalSupply();
require(<FILL_ME>)
for (uint256 i = 1; i <= amount; i++) {
uint256 id = currentSupply + i;
mintingPrice[id] = price;
mintingDate[id] = block.timestamp;
_safeMint(to, id);
}
}
/// @notice 6-Month ETH back function
/// @param depositAddress Address to refund the funds
/// @param tokenId Ape ID to be refunded
/// @dev Can only be called by authorized orchestrators during refund period
function refund(address depositAddress, uint256 tokenId)
external
onlyOrchestrator
noZeroAddress(depositAddress)
{
}
/// @notice Change the mint limit for public sale
/// @param newLimit new minting limit
/// @dev Can only be called by the contract owner
function setMintLimit(uint256 newLimit) external onlyOwner {
}
/// @notice Change the Base URI
/// @param newURI new URI to be set
/// @dev Can only be called by the contract owner
function setBaseURI(string memory newURI) external onlyOwner {
}
/// @notice Change the signer address
/// @param secretAddress new signer for encrypted signatures
/// @dev Can only be called by the contract owner
function setSecret(address secretAddress)
external
onlyOwner
noZeroAddress(secretAddress)
{
}
/// @notice Change the treasury address
/// @param treasuryAddress new treasury address
/// @dev Can only be called by the contract owner
function setTreasury(address treasuryAddress)
external
onlyOwner
noZeroAddress(treasuryAddress)
{
}
/// @notice Change the portal pass address
/// @param portalAddress new portal pass contract
/// @dev Can only be called by the contract owner
function setPortalPass(address portalAddress)
external
onlyOwner
noZeroAddress(portalAddress)
{
}
/// @notice Add new authorized orchestrators
/// @param operator Orchestrator address
/// @param status set authorization true or false
/// @dev Can only be called by the contract owner
function setOrchestrator(address operator, bool status)
external
onlyOwner
noZeroAddress(operator)
{
}
/// @notice Send ETH to specific address
/// @param to Address to send the funds
/// @param amount ETH amount to be sent
/// @dev Can only be called by the contract owner
function withdrawETH(address to, uint256 amount)
public
nonReentrant
onlyOwner
noZeroAddress(to)
{
}
/// @notice Return Base URI
function _baseURI() internal view virtual override returns (string memory) {
}
/// @notice Inherit from ERC721, return token URI, revert is tokenId doesn't exist
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/// @notice Inherit from ERC721, added check of transfer period for refund
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override(ERC721, IERC721) {
}
/// @notice Inherit from ERC721, added check of transfer period for refund
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override(ERC721, IERC721) {
}
/// @notice Checks transfer after allow period to invalidate refund
function _checkTransferPeriod(uint256 tokenId) internal {
}
/// @notice Inherit from ERC721, checks if a token exists
function exists(uint256 tokenId) external view returns (bool) {
}
/// @notice Verify that message is signed by secret wallet
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
}
| amount+currentSupply<=MAX_SUPPLY,"Mint: Supply limit" | 454,810 | amount+currentSupply<=MAX_SUPPLY |
"Refund: The token is not available for refund" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/// @title Bulls and Apes Project - APES
/// @author BAP Dev Team
/// @notice ERC721 for BAP ecosystem
contract BAPApes is ERC721Enumerable, Ownable, ReentrancyGuard {
using Strings for uint256;
string baseURI;
/// @notice Max supply of Apes to be minted
uint256 public constant MAX_SUPPLY = 10000;
/// @notice Max minting limit during sale
uint256 public mintLimit = 2;
/// @notice Supply reserved for public sale
/// @dev Return amount remaining
uint256 public publicSupply = 3500;
/// @notice Supply reserved for Portal Pass Exchange
/// @dev Return amount remaining
uint256 public reservedSupply = 5000;
/// @notice Supply reserved for treasury and team
/// @dev Return amount remaining
uint256 public treasurySupply = 1500;
/// @notice Prices for public sale
uint256[] public tierPrices = [
0.22 ether,
0.27 ether,
0.3 ether,
0.33 ether,
0.33 ether,
0.37 ether
];
/// @notice ERC1155 Portal Pass
IERC1155 public portalPass;
/// @notice Signer address for encrypted signatures
address public secret;
/// @notice Address of BAP treasury
address public treasury;
/// @notice Dead wallet to send exchanged Portal Passes
address private constant DEAD_ADDRESS =
0x000000000000000000000000000000000000dEaD;
/// @notice Original minting price for each Ape
mapping(uint256 => uint256) public mintingPrice;
/// @notice Original minting date for each Ape
mapping(uint256 => uint256) public mintingDate;
/// @notice Refund flag for each Ape
mapping(uint256 => bool) public notRefundable;
/// @notice Authorization flag for orchestrators
mapping(address => bool) public isOrchestrator;
/// @notice Amount minted per wallet and per tier
mapping(address => mapping(uint256 => uint256)) public walletMinted;
event Purchased(address operator, address user, uint256 amount);
event PassExchanged(address operator, address user, uint256 amount);
event Airdrop(address operator, address user, uint256 amount);
event TraitsChanged(address user, uint256 tokenId, uint256 newTokenId);
event Refunded(address user, uint256 tokenId);
event MintLimitChanged(uint256 limit, address operator);
/// @notice Deploys the contract
/// @param portalAddress Address of portal passes
/// @param secretAddress Signer address
/// @dev Create ERC721 token: BAP APES - BAPAPES
constructor(address portalAddress, address secretAddress)
ERC721("BAP APES", "BAPAPES")
{
}
/// @notice Check if caller is an orchestrator
/// @dev Revert transaction is msg.sender is not Authorized
modifier onlyOrchestrator() {
}
/// @notice Check if the wallet is valid
/// @dev Revert transaction if zero address
modifier noZeroAddress(address _address) {
}
/// @notice Purchase an Ape from public supply
/// @param to Address to send the token
/// @param amount Amount of tokens to be minted
/// @param tier Current tier
function purchase(
address to,
uint256 amount,
uint256 tier,
bytes memory signature
) external payable {
}
/// @notice Airdrop an Ape from treasury supply
/// @param to Address to send the token
/// @param amount Amount of tokens to be minted
function airdrop(address to, uint256 amount)
external
nonReentrant
onlyOwner
{
}
/// @notice Exchange Portal Passes for Apes
/// @param to Address to send the token
/// @param amount Amount of passes to be exchanged
function exchangePass(address to, uint256 amount) external {
}
/// @notice Confirm traits changes from Trait Constructor
/// @param tokenId Ape the be modified
/// @dev Can only be called by authorized orchestrators
function confirmChange(uint256 tokenId) external onlyOrchestrator {
}
/// @notice Internal function to mint Apes, set initial price and timestamp
/// @param to Address to send the tokens
/// @param amount Amount of tokens to be minted
/// @param price Price payed for each token
function mint(
address to,
uint256 amount,
uint256 price
) internal {
}
/// @notice 6-Month ETH back function
/// @param depositAddress Address to refund the funds
/// @param tokenId Ape ID to be refunded
/// @dev Can only be called by authorized orchestrators during refund period
function refund(address depositAddress, uint256 tokenId)
external
onlyOrchestrator
noZeroAddress(depositAddress)
{
uint256 balance = mintingPrice[tokenId];
require(balance > 0, "Refund: Original Minting Price is zero");
require(<FILL_ME>)
require(
ownerOf(tokenId) == depositAddress,
"Refund: Address is not the token owner"
);
_transfer(depositAddress, treasury, tokenId);
(bool success, ) = depositAddress.call{value: balance}("");
require(success, "Refund: ETH transafer failed");
emit Refunded(depositAddress, tokenId);
}
/// @notice Change the mint limit for public sale
/// @param newLimit new minting limit
/// @dev Can only be called by the contract owner
function setMintLimit(uint256 newLimit) external onlyOwner {
}
/// @notice Change the Base URI
/// @param newURI new URI to be set
/// @dev Can only be called by the contract owner
function setBaseURI(string memory newURI) external onlyOwner {
}
/// @notice Change the signer address
/// @param secretAddress new signer for encrypted signatures
/// @dev Can only be called by the contract owner
function setSecret(address secretAddress)
external
onlyOwner
noZeroAddress(secretAddress)
{
}
/// @notice Change the treasury address
/// @param treasuryAddress new treasury address
/// @dev Can only be called by the contract owner
function setTreasury(address treasuryAddress)
external
onlyOwner
noZeroAddress(treasuryAddress)
{
}
/// @notice Change the portal pass address
/// @param portalAddress new portal pass contract
/// @dev Can only be called by the contract owner
function setPortalPass(address portalAddress)
external
onlyOwner
noZeroAddress(portalAddress)
{
}
/// @notice Add new authorized orchestrators
/// @param operator Orchestrator address
/// @param status set authorization true or false
/// @dev Can only be called by the contract owner
function setOrchestrator(address operator, bool status)
external
onlyOwner
noZeroAddress(operator)
{
}
/// @notice Send ETH to specific address
/// @param to Address to send the funds
/// @param amount ETH amount to be sent
/// @dev Can only be called by the contract owner
function withdrawETH(address to, uint256 amount)
public
nonReentrant
onlyOwner
noZeroAddress(to)
{
}
/// @notice Return Base URI
function _baseURI() internal view virtual override returns (string memory) {
}
/// @notice Inherit from ERC721, return token URI, revert is tokenId doesn't exist
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/// @notice Inherit from ERC721, added check of transfer period for refund
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override(ERC721, IERC721) {
}
/// @notice Inherit from ERC721, added check of transfer period for refund
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override(ERC721, IERC721) {
}
/// @notice Checks transfer after allow period to invalidate refund
function _checkTransferPeriod(uint256 tokenId) internal {
}
/// @notice Inherit from ERC721, checks if a token exists
function exists(uint256 tokenId) external view returns (bool) {
}
/// @notice Verify that message is signed by secret wallet
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
}
| !notRefundable[tokenId],"Refund: The token is not available for refund" | 454,810 | !notRefundable[tokenId] |
"Refund: Address is not the token owner" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/// @title Bulls and Apes Project - APES
/// @author BAP Dev Team
/// @notice ERC721 for BAP ecosystem
contract BAPApes is ERC721Enumerable, Ownable, ReentrancyGuard {
using Strings for uint256;
string baseURI;
/// @notice Max supply of Apes to be minted
uint256 public constant MAX_SUPPLY = 10000;
/// @notice Max minting limit during sale
uint256 public mintLimit = 2;
/// @notice Supply reserved for public sale
/// @dev Return amount remaining
uint256 public publicSupply = 3500;
/// @notice Supply reserved for Portal Pass Exchange
/// @dev Return amount remaining
uint256 public reservedSupply = 5000;
/// @notice Supply reserved for treasury and team
/// @dev Return amount remaining
uint256 public treasurySupply = 1500;
/// @notice Prices for public sale
uint256[] public tierPrices = [
0.22 ether,
0.27 ether,
0.3 ether,
0.33 ether,
0.33 ether,
0.37 ether
];
/// @notice ERC1155 Portal Pass
IERC1155 public portalPass;
/// @notice Signer address for encrypted signatures
address public secret;
/// @notice Address of BAP treasury
address public treasury;
/// @notice Dead wallet to send exchanged Portal Passes
address private constant DEAD_ADDRESS =
0x000000000000000000000000000000000000dEaD;
/// @notice Original minting price for each Ape
mapping(uint256 => uint256) public mintingPrice;
/// @notice Original minting date for each Ape
mapping(uint256 => uint256) public mintingDate;
/// @notice Refund flag for each Ape
mapping(uint256 => bool) public notRefundable;
/// @notice Authorization flag for orchestrators
mapping(address => bool) public isOrchestrator;
/// @notice Amount minted per wallet and per tier
mapping(address => mapping(uint256 => uint256)) public walletMinted;
event Purchased(address operator, address user, uint256 amount);
event PassExchanged(address operator, address user, uint256 amount);
event Airdrop(address operator, address user, uint256 amount);
event TraitsChanged(address user, uint256 tokenId, uint256 newTokenId);
event Refunded(address user, uint256 tokenId);
event MintLimitChanged(uint256 limit, address operator);
/// @notice Deploys the contract
/// @param portalAddress Address of portal passes
/// @param secretAddress Signer address
/// @dev Create ERC721 token: BAP APES - BAPAPES
constructor(address portalAddress, address secretAddress)
ERC721("BAP APES", "BAPAPES")
{
}
/// @notice Check if caller is an orchestrator
/// @dev Revert transaction is msg.sender is not Authorized
modifier onlyOrchestrator() {
}
/// @notice Check if the wallet is valid
/// @dev Revert transaction if zero address
modifier noZeroAddress(address _address) {
}
/// @notice Purchase an Ape from public supply
/// @param to Address to send the token
/// @param amount Amount of tokens to be minted
/// @param tier Current tier
function purchase(
address to,
uint256 amount,
uint256 tier,
bytes memory signature
) external payable {
}
/// @notice Airdrop an Ape from treasury supply
/// @param to Address to send the token
/// @param amount Amount of tokens to be minted
function airdrop(address to, uint256 amount)
external
nonReentrant
onlyOwner
{
}
/// @notice Exchange Portal Passes for Apes
/// @param to Address to send the token
/// @param amount Amount of passes to be exchanged
function exchangePass(address to, uint256 amount) external {
}
/// @notice Confirm traits changes from Trait Constructor
/// @param tokenId Ape the be modified
/// @dev Can only be called by authorized orchestrators
function confirmChange(uint256 tokenId) external onlyOrchestrator {
}
/// @notice Internal function to mint Apes, set initial price and timestamp
/// @param to Address to send the tokens
/// @param amount Amount of tokens to be minted
/// @param price Price payed for each token
function mint(
address to,
uint256 amount,
uint256 price
) internal {
}
/// @notice 6-Month ETH back function
/// @param depositAddress Address to refund the funds
/// @param tokenId Ape ID to be refunded
/// @dev Can only be called by authorized orchestrators during refund period
function refund(address depositAddress, uint256 tokenId)
external
onlyOrchestrator
noZeroAddress(depositAddress)
{
uint256 balance = mintingPrice[tokenId];
require(balance > 0, "Refund: Original Minting Price is zero");
require(
!notRefundable[tokenId],
"Refund: The token is not available for refund"
);
require(<FILL_ME>)
_transfer(depositAddress, treasury, tokenId);
(bool success, ) = depositAddress.call{value: balance}("");
require(success, "Refund: ETH transafer failed");
emit Refunded(depositAddress, tokenId);
}
/// @notice Change the mint limit for public sale
/// @param newLimit new minting limit
/// @dev Can only be called by the contract owner
function setMintLimit(uint256 newLimit) external onlyOwner {
}
/// @notice Change the Base URI
/// @param newURI new URI to be set
/// @dev Can only be called by the contract owner
function setBaseURI(string memory newURI) external onlyOwner {
}
/// @notice Change the signer address
/// @param secretAddress new signer for encrypted signatures
/// @dev Can only be called by the contract owner
function setSecret(address secretAddress)
external
onlyOwner
noZeroAddress(secretAddress)
{
}
/// @notice Change the treasury address
/// @param treasuryAddress new treasury address
/// @dev Can only be called by the contract owner
function setTreasury(address treasuryAddress)
external
onlyOwner
noZeroAddress(treasuryAddress)
{
}
/// @notice Change the portal pass address
/// @param portalAddress new portal pass contract
/// @dev Can only be called by the contract owner
function setPortalPass(address portalAddress)
external
onlyOwner
noZeroAddress(portalAddress)
{
}
/// @notice Add new authorized orchestrators
/// @param operator Orchestrator address
/// @param status set authorization true or false
/// @dev Can only be called by the contract owner
function setOrchestrator(address operator, bool status)
external
onlyOwner
noZeroAddress(operator)
{
}
/// @notice Send ETH to specific address
/// @param to Address to send the funds
/// @param amount ETH amount to be sent
/// @dev Can only be called by the contract owner
function withdrawETH(address to, uint256 amount)
public
nonReentrant
onlyOwner
noZeroAddress(to)
{
}
/// @notice Return Base URI
function _baseURI() internal view virtual override returns (string memory) {
}
/// @notice Inherit from ERC721, return token URI, revert is tokenId doesn't exist
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/// @notice Inherit from ERC721, added check of transfer period for refund
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override(ERC721, IERC721) {
}
/// @notice Inherit from ERC721, added check of transfer period for refund
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override(ERC721, IERC721) {
}
/// @notice Checks transfer after allow period to invalidate refund
function _checkTransferPeriod(uint256 tokenId) internal {
}
/// @notice Inherit from ERC721, checks if a token exists
function exists(uint256 tokenId) external view returns (bool) {
}
/// @notice Verify that message is signed by secret wallet
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
}
| ownerOf(tokenId)==depositAddress,"Refund: Address is not the token owner" | 454,810 | ownerOf(tokenId)==depositAddress |
"caller is not the admin" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
contract AdminRole {
address private _admin;
event AdminTransferred(
address indexed previousAdmin,
address indexed newAdmin
);
constructor() {
}
modifier onlyAdmin() {
require(<FILL_ME>)
_;
}
function admin() public view virtual returns (address) {
}
function _transferAdmin(address newAdmin) internal virtual {
}
}
| admin()==msg.sender,"caller is not the admin" | 454,942 | admin()==msg.sender |
"Max mint amount per wallet reached" | contract Metamon is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string private uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public presaleCost = 0.15 ether;
uint256 public publicCost = 0.2 ether;
uint256 public maxSupply = 10000;
uint256 public maxPublicMintAmountPerTx = 50;
uint256 public maxPresaleMintAmountPerTx = 50;
uint256 public maxPresaleWalletLimit = 250;
uint256 public maxPublicSaleWalletLimit = 250;
bool public paused = true;
bool public presaleActive = false;
bool public saleActive = false;
bool public revealed = false;
mapping(address => uint256) private addressMintedBalance;
mapping(address => bool) public WL;
bytes32 private merkleRoot = "";
constructor() ERC721A("Metamongo", "Mtmng") {
}
function _startTokenId() internal override view virtual returns (uint256) {
}
function cost() public view returns(uint256) {
}
function maxWalletLimit() public view returns(uint256) {
}
function maxMintAmountPerTx() public view returns(uint256) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier selfMintCompliance(uint256 _mintAmount) {
}
function publicMint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
require(saleActive, "Sale is not Active" );
require(msg.value >= cost() * _mintAmount, "Insufficient funds!");
require(<FILL_ME>)
_mintLoop(msg.sender, _mintAmount);
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function mintForSelf(uint256 _mintAmount) public selfMintCompliance(_mintAmount) onlyOwner {
}
// new
function Minted(address[] memory __receivers, uint256[] memory _mintAmount) public onlyOwner {
}
function airdrop(address[] memory __receivers) public onlyOwner {
}
// new_WhitelistMint
function PresaleMinted(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function setWL(address[] memory _address) public onlyOwner() {
}
function removeWL(address[] memory _address) public onlyOwner() {
}
function verify(bytes32 _merkleRoot, bytes32 leaf, bytes32[] memory proof) public pure returns (bool) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setPublicCost(uint256 _cost) public onlyOwner {
}
function setPresaleCost2(uint256 _cost) public onlyOwner {
}
function setPublicSale(bool _sale) public onlyOwner {
}
function setPreSale(bool _sale) public onlyOwner {
}
function setPresaleMaxWalletLimit(uint256 _maxWalletLimit) public onlyOwner {
}
function setPublicSaleMaxWalletLimit(uint256 _maxWalletLimit) public onlyOwner {
}
function setPublicMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setPresaleMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| addressMintedBalance[msg.sender]+_mintAmount<=maxWalletLimit(),"Max mint amount per wallet reached" | 454,944 | addressMintedBalance[msg.sender]+_mintAmount<=maxWalletLimit() |
"Invalid mint amount!" | contract Metamon is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string private uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public presaleCost = 0.15 ether;
uint256 public publicCost = 0.2 ether;
uint256 public maxSupply = 10000;
uint256 public maxPublicMintAmountPerTx = 50;
uint256 public maxPresaleMintAmountPerTx = 50;
uint256 public maxPresaleWalletLimit = 250;
uint256 public maxPublicSaleWalletLimit = 250;
bool public paused = true;
bool public presaleActive = false;
bool public saleActive = false;
bool public revealed = false;
mapping(address => uint256) private addressMintedBalance;
mapping(address => bool) public WL;
bytes32 private merkleRoot = "";
constructor() ERC721A("Metamongo", "Mtmng") {
}
function _startTokenId() internal override view virtual returns (uint256) {
}
function cost() public view returns(uint256) {
}
function maxWalletLimit() public view returns(uint256) {
}
function maxMintAmountPerTx() public view returns(uint256) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier selfMintCompliance(uint256 _mintAmount) {
}
function publicMint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function mintForSelf(uint256 _mintAmount) public selfMintCompliance(_mintAmount) onlyOwner {
}
// new
function Minted(address[] memory __receivers, uint256[] memory _mintAmount) public onlyOwner {
for(uint256 i = 0; i < __receivers.length; i++){
require(<FILL_ME>)
require(totalSupply() + _mintAmount[i] <= maxSupply, "Max supply exceeded!");
_mintLoop(__receivers[i], _mintAmount[i]);
}
}
function airdrop(address[] memory __receivers) public onlyOwner {
}
// new_WhitelistMint
function PresaleMinted(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function setWL(address[] memory _address) public onlyOwner() {
}
function removeWL(address[] memory _address) public onlyOwner() {
}
function verify(bytes32 _merkleRoot, bytes32 leaf, bytes32[] memory proof) public pure returns (bool) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setPublicCost(uint256 _cost) public onlyOwner {
}
function setPresaleCost2(uint256 _cost) public onlyOwner {
}
function setPublicSale(bool _sale) public onlyOwner {
}
function setPreSale(bool _sale) public onlyOwner {
}
function setPresaleMaxWalletLimit(uint256 _maxWalletLimit) public onlyOwner {
}
function setPublicSaleMaxWalletLimit(uint256 _maxWalletLimit) public onlyOwner {
}
function setPublicMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setPresaleMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| _mintAmount[i]>0,"Invalid mint amount!" | 454,944 | _mintAmount[i]>0 |
"Max supply exceeded!" | contract Metamon is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string private uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public presaleCost = 0.15 ether;
uint256 public publicCost = 0.2 ether;
uint256 public maxSupply = 10000;
uint256 public maxPublicMintAmountPerTx = 50;
uint256 public maxPresaleMintAmountPerTx = 50;
uint256 public maxPresaleWalletLimit = 250;
uint256 public maxPublicSaleWalletLimit = 250;
bool public paused = true;
bool public presaleActive = false;
bool public saleActive = false;
bool public revealed = false;
mapping(address => uint256) private addressMintedBalance;
mapping(address => bool) public WL;
bytes32 private merkleRoot = "";
constructor() ERC721A("Metamongo", "Mtmng") {
}
function _startTokenId() internal override view virtual returns (uint256) {
}
function cost() public view returns(uint256) {
}
function maxWalletLimit() public view returns(uint256) {
}
function maxMintAmountPerTx() public view returns(uint256) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier selfMintCompliance(uint256 _mintAmount) {
}
function publicMint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function mintForSelf(uint256 _mintAmount) public selfMintCompliance(_mintAmount) onlyOwner {
}
// new
function Minted(address[] memory __receivers, uint256[] memory _mintAmount) public onlyOwner {
for(uint256 i = 0; i < __receivers.length; i++){
require(_mintAmount[i] > 0, "Invalid mint amount!");
require(<FILL_ME>)
_mintLoop(__receivers[i], _mintAmount[i]);
}
}
function airdrop(address[] memory __receivers) public onlyOwner {
}
// new_WhitelistMint
function PresaleMinted(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function setWL(address[] memory _address) public onlyOwner() {
}
function removeWL(address[] memory _address) public onlyOwner() {
}
function verify(bytes32 _merkleRoot, bytes32 leaf, bytes32[] memory proof) public pure returns (bool) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setPublicCost(uint256 _cost) public onlyOwner {
}
function setPresaleCost2(uint256 _cost) public onlyOwner {
}
function setPublicSale(bool _sale) public onlyOwner {
}
function setPreSale(bool _sale) public onlyOwner {
}
function setPresaleMaxWalletLimit(uint256 _maxWalletLimit) public onlyOwner {
}
function setPublicSaleMaxWalletLimit(uint256 _maxWalletLimit) public onlyOwner {
}
function setPublicMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setPresaleMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+_mintAmount[i]<=maxSupply,"Max supply exceeded!" | 454,944 | totalSupply()+_mintAmount[i]<=maxSupply |
"Max supply exceeded!" | contract Metamon is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string private uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public presaleCost = 0.15 ether;
uint256 public publicCost = 0.2 ether;
uint256 public maxSupply = 10000;
uint256 public maxPublicMintAmountPerTx = 50;
uint256 public maxPresaleMintAmountPerTx = 50;
uint256 public maxPresaleWalletLimit = 250;
uint256 public maxPublicSaleWalletLimit = 250;
bool public paused = true;
bool public presaleActive = false;
bool public saleActive = false;
bool public revealed = false;
mapping(address => uint256) private addressMintedBalance;
mapping(address => bool) public WL;
bytes32 private merkleRoot = "";
constructor() ERC721A("Metamongo", "Mtmng") {
}
function _startTokenId() internal override view virtual returns (uint256) {
}
function cost() public view returns(uint256) {
}
function maxWalletLimit() public view returns(uint256) {
}
function maxMintAmountPerTx() public view returns(uint256) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier selfMintCompliance(uint256 _mintAmount) {
}
function publicMint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function mintForSelf(uint256 _mintAmount) public selfMintCompliance(_mintAmount) onlyOwner {
}
// new
function Minted(address[] memory __receivers, uint256[] memory _mintAmount) public onlyOwner {
}
function airdrop(address[] memory __receivers) public onlyOwner {
require(<FILL_ME>)
for(uint256 i = 0; i < __receivers.length; i++){
_mintLoop(__receivers[i], 1);
}
}
// new_WhitelistMint
function PresaleMinted(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function setWL(address[] memory _address) public onlyOwner() {
}
function removeWL(address[] memory _address) public onlyOwner() {
}
function verify(bytes32 _merkleRoot, bytes32 leaf, bytes32[] memory proof) public pure returns (bool) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setPublicCost(uint256 _cost) public onlyOwner {
}
function setPresaleCost2(uint256 _cost) public onlyOwner {
}
function setPublicSale(bool _sale) public onlyOwner {
}
function setPreSale(bool _sale) public onlyOwner {
}
function setPresaleMaxWalletLimit(uint256 _maxWalletLimit) public onlyOwner {
}
function setPublicSaleMaxWalletLimit(uint256 _maxWalletLimit) public onlyOwner {
}
function setPublicMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setPresaleMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+__receivers.length<=maxSupply,"Max supply exceeded!" | 454,944 | totalSupply()+__receivers.length<=maxSupply |
"Only WHITELIST can mint" | contract Metamon is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string private uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public presaleCost = 0.15 ether;
uint256 public publicCost = 0.2 ether;
uint256 public maxSupply = 10000;
uint256 public maxPublicMintAmountPerTx = 50;
uint256 public maxPresaleMintAmountPerTx = 50;
uint256 public maxPresaleWalletLimit = 250;
uint256 public maxPublicSaleWalletLimit = 250;
bool public paused = true;
bool public presaleActive = false;
bool public saleActive = false;
bool public revealed = false;
mapping(address => uint256) private addressMintedBalance;
mapping(address => bool) public WL;
bytes32 private merkleRoot = "";
constructor() ERC721A("Metamongo", "Mtmng") {
}
function _startTokenId() internal override view virtual returns (uint256) {
}
function cost() public view returns(uint256) {
}
function maxWalletLimit() public view returns(uint256) {
}
function maxMintAmountPerTx() public view returns(uint256) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier selfMintCompliance(uint256 _mintAmount) {
}
function publicMint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function mintForSelf(uint256 _mintAmount) public selfMintCompliance(_mintAmount) onlyOwner {
}
// new
function Minted(address[] memory __receivers, uint256[] memory _mintAmount) public onlyOwner {
}
function airdrop(address[] memory __receivers) public onlyOwner {
}
// new_WhitelistMint
function PresaleMinted(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
require(presaleActive, "Sale is not Active");
require(<FILL_ME>)
require(msg.value >= cost() * _mintAmount, "Insufficient funds!");
require(addressMintedBalance[msg.sender] + _mintAmount <= maxWalletLimit(), "Max mint amount per wallet reached");
_mintLoop(msg.sender, _mintAmount);
}
function setWL(address[] memory _address) public onlyOwner() {
}
function removeWL(address[] memory _address) public onlyOwner() {
}
function verify(bytes32 _merkleRoot, bytes32 leaf, bytes32[] memory proof) public pure returns (bool) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setPublicCost(uint256 _cost) public onlyOwner {
}
function setPresaleCost2(uint256 _cost) public onlyOwner {
}
function setPublicSale(bool _sale) public onlyOwner {
}
function setPreSale(bool _sale) public onlyOwner {
}
function setPresaleMaxWalletLimit(uint256 _maxWalletLimit) public onlyOwner {
}
function setPublicSaleMaxWalletLimit(uint256 _maxWalletLimit) public onlyOwner {
}
function setPublicMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setPresaleMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| WL[msg.sender]==true,"Only WHITELIST can mint" | 454,944 | WL[msg.sender]==true |
"Invalid address found" | contract Metamon is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string private uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public presaleCost = 0.15 ether;
uint256 public publicCost = 0.2 ether;
uint256 public maxSupply = 10000;
uint256 public maxPublicMintAmountPerTx = 50;
uint256 public maxPresaleMintAmountPerTx = 50;
uint256 public maxPresaleWalletLimit = 250;
uint256 public maxPublicSaleWalletLimit = 250;
bool public paused = true;
bool public presaleActive = false;
bool public saleActive = false;
bool public revealed = false;
mapping(address => uint256) private addressMintedBalance;
mapping(address => bool) public WL;
bytes32 private merkleRoot = "";
constructor() ERC721A("Metamongo", "Mtmng") {
}
function _startTokenId() internal override view virtual returns (uint256) {
}
function cost() public view returns(uint256) {
}
function maxWalletLimit() public view returns(uint256) {
}
function maxMintAmountPerTx() public view returns(uint256) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier selfMintCompliance(uint256 _mintAmount) {
}
function publicMint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function mintForSelf(uint256 _mintAmount) public selfMintCompliance(_mintAmount) onlyOwner {
}
// new
function Minted(address[] memory __receivers, uint256[] memory _mintAmount) public onlyOwner {
}
function airdrop(address[] memory __receivers) public onlyOwner {
}
// new_WhitelistMint
function PresaleMinted(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function setWL(address[] memory _address) public onlyOwner() {
for(uint256 i; i<_address.length; i++){
require(<FILL_ME>)
address tempAdd = _address[i];
WL[tempAdd] = true;
}
}
function removeWL(address[] memory _address) public onlyOwner() {
}
function verify(bytes32 _merkleRoot, bytes32 leaf, bytes32[] memory proof) public pure returns (bool) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setPublicCost(uint256 _cost) public onlyOwner {
}
function setPresaleCost2(uint256 _cost) public onlyOwner {
}
function setPublicSale(bool _sale) public onlyOwner {
}
function setPreSale(bool _sale) public onlyOwner {
}
function setPresaleMaxWalletLimit(uint256 _maxWalletLimit) public onlyOwner {
}
function setPublicSaleMaxWalletLimit(uint256 _maxWalletLimit) public onlyOwner {
}
function setPublicMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setPresaleMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| _address[i]!=address(0),"Invalid address found" | 454,944 | _address[i]!=address(0) |
"max_mint_exceeded" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.14;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ERC721A, ERC721AQueryable} from "erc721a/contracts/extensions/ERC721AQueryable.sol";
import {Whitelist} from "./Whitelist.sol";
/// @author tempest-sol<[email protected]>
contract BoredInABearMarket is Ownable, ERC721AQueryable, Whitelist {
enum SaleType { STAGING, WHITELIST, PUBLIC, CONCLUDED }
SaleType public currentSale;
uint256 public immutable maxSupply;
uint256 public immutable reserveCount;
uint256 public reservesMinted;
uint256 public cost;
uint256 public maxMintTx;
mapping(address => uint8) private whitelistMintCount;
///////////////////
//// Events ///
///////////////////
event SaleTypeChanged(SaleType indexed saleType);
event MintCostChanged(uint256 indexed cost);
string public uri;
constructor() ERC721A("bored in a bear market", "BORED") {
}
function updateUri(string memory _uri) external onlyOwner {
}
function setSaleType(SaleType sale) external onlyOwner {
}
function updateSalePrice(uint256 amount) external onlyOwner {
}
function mint(bytes32[] calldata proof, uint256 amount) external onlyWhitelisted(proof) canMint(amount) payable {
}
function mintFreeFor(address[] calldata addresses, uint256 amount) external onlyOwner {
require(<FILL_ME>)
address nullAddr = address(0x0);
address addr;
for(uint256 i=0;i<addresses.length;++i) {
addr = addresses[i];
require(addr != nullAddr, "address_invalid");
_safeMint(addr, amount);
}
uint256 total = totalSupply();
if(total == maxSupply || total == maxSupply - reserveCount) {
currentSale = SaleType.CONCLUDED;
emit SaleTypeChanged(currentSale);
}
}
function mintReservedFor(address to, uint256 quantity) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function _startTokenId() internal pure override returns (uint256) {
}
modifier canMint(uint256 amount) {
}
receive() external payable {}
}
| totalSupply()+(addresses.length*amount)<=maxSupply-reserveCount,"max_mint_exceeded" | 454,993 | totalSupply()+(addresses.length*amount)<=maxSupply-reserveCount |
"exceeds_reserves" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.14;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ERC721A, ERC721AQueryable} from "erc721a/contracts/extensions/ERC721AQueryable.sol";
import {Whitelist} from "./Whitelist.sol";
/// @author tempest-sol<[email protected]>
contract BoredInABearMarket is Ownable, ERC721AQueryable, Whitelist {
enum SaleType { STAGING, WHITELIST, PUBLIC, CONCLUDED }
SaleType public currentSale;
uint256 public immutable maxSupply;
uint256 public immutable reserveCount;
uint256 public reservesMinted;
uint256 public cost;
uint256 public maxMintTx;
mapping(address => uint8) private whitelistMintCount;
///////////////////
//// Events ///
///////////////////
event SaleTypeChanged(SaleType indexed saleType);
event MintCostChanged(uint256 indexed cost);
string public uri;
constructor() ERC721A("bored in a bear market", "BORED") {
}
function updateUri(string memory _uri) external onlyOwner {
}
function setSaleType(SaleType sale) external onlyOwner {
}
function updateSalePrice(uint256 amount) external onlyOwner {
}
function mint(bytes32[] calldata proof, uint256 amount) external onlyWhitelisted(proof) canMint(amount) payable {
}
function mintFreeFor(address[] calldata addresses, uint256 amount) external onlyOwner {
}
function mintReservedFor(address to, uint256 quantity) external onlyOwner {
require(<FILL_ME>)
reservesMinted += quantity;
_safeMint(to, quantity);
}
function withdraw() external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function _startTokenId() internal pure override returns (uint256) {
}
modifier canMint(uint256 amount) {
}
receive() external payable {}
}
| reservesMinted+quantity<=reserveCount,"exceeds_reserves" | 454,993 | reservesMinted+quantity<=reserveCount |
"exceeds_max_supply" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.14;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ERC721A, ERC721AQueryable} from "erc721a/contracts/extensions/ERC721AQueryable.sol";
import {Whitelist} from "./Whitelist.sol";
/// @author tempest-sol<[email protected]>
contract BoredInABearMarket is Ownable, ERC721AQueryable, Whitelist {
enum SaleType { STAGING, WHITELIST, PUBLIC, CONCLUDED }
SaleType public currentSale;
uint256 public immutable maxSupply;
uint256 public immutable reserveCount;
uint256 public reservesMinted;
uint256 public cost;
uint256 public maxMintTx;
mapping(address => uint8) private whitelistMintCount;
///////////////////
//// Events ///
///////////////////
event SaleTypeChanged(SaleType indexed saleType);
event MintCostChanged(uint256 indexed cost);
string public uri;
constructor() ERC721A("bored in a bear market", "BORED") {
}
function updateUri(string memory _uri) external onlyOwner {
}
function setSaleType(SaleType sale) external onlyOwner {
}
function updateSalePrice(uint256 amount) external onlyOwner {
}
function mint(bytes32[] calldata proof, uint256 amount) external onlyWhitelisted(proof) canMint(amount) payable {
}
function mintFreeFor(address[] calldata addresses, uint256 amount) external onlyOwner {
}
function mintReservedFor(address to, uint256 quantity) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function _startTokenId() internal pure override returns (uint256) {
}
modifier canMint(uint256 amount) {
require(amount <= maxMintTx, "exceeds_mint_allowance");
require(currentSale > SaleType.STAGING, "sale_inactive");
require(currentSale != SaleType.CONCLUDED, "sale_concluded");
require(<FILL_ME>)
if(currentSale == SaleType.WHITELIST) {
require(whitelistMintCount[msg.sender] + amount <= 5, "exceeds_whitelist_limit");
}
_;
}
receive() external payable {}
}
| totalSupply()+amount<=maxSupply-reserveCount,"exceeds_max_supply" | 454,993 | totalSupply()+amount<=maxSupply-reserveCount |
"exceeds_whitelist_limit" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.14;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ERC721A, ERC721AQueryable} from "erc721a/contracts/extensions/ERC721AQueryable.sol";
import {Whitelist} from "./Whitelist.sol";
/// @author tempest-sol<[email protected]>
contract BoredInABearMarket is Ownable, ERC721AQueryable, Whitelist {
enum SaleType { STAGING, WHITELIST, PUBLIC, CONCLUDED }
SaleType public currentSale;
uint256 public immutable maxSupply;
uint256 public immutable reserveCount;
uint256 public reservesMinted;
uint256 public cost;
uint256 public maxMintTx;
mapping(address => uint8) private whitelistMintCount;
///////////////////
//// Events ///
///////////////////
event SaleTypeChanged(SaleType indexed saleType);
event MintCostChanged(uint256 indexed cost);
string public uri;
constructor() ERC721A("bored in a bear market", "BORED") {
}
function updateUri(string memory _uri) external onlyOwner {
}
function setSaleType(SaleType sale) external onlyOwner {
}
function updateSalePrice(uint256 amount) external onlyOwner {
}
function mint(bytes32[] calldata proof, uint256 amount) external onlyWhitelisted(proof) canMint(amount) payable {
}
function mintFreeFor(address[] calldata addresses, uint256 amount) external onlyOwner {
}
function mintReservedFor(address to, uint256 quantity) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function _startTokenId() internal pure override returns (uint256) {
}
modifier canMint(uint256 amount) {
require(amount <= maxMintTx, "exceeds_mint_allowance");
require(currentSale > SaleType.STAGING, "sale_inactive");
require(currentSale != SaleType.CONCLUDED, "sale_concluded");
require(totalSupply() + amount <= maxSupply - reserveCount, "exceeds_max_supply");
if(currentSale == SaleType.WHITELIST) {
require(<FILL_ME>)
}
_;
}
receive() external payable {}
}
| whitelistMintCount[msg.sender]+amount<=5,"exceeds_whitelist_limit" | 454,993 | whitelistMintCount[msg.sender]+amount<=5 |
"swapToken is 0" | pragma solidity =0.8.10;
abstract contract TokenReward is CheckPermission {
using SafeMath for uint256;
using SafeERC20 for IERC20;
event SetPool(address indexed pool, uint256 point);
event AddPool(address indexed pool, uint256 point);
IToken public swapToken;
uint256 public tokenPerBlock;
uint256 public immutable startBlock;
uint256 public periodEndBlock;
// How many blocks (90 days) are halved 2592000
uint256 public period;
uint256 public mintMulti;
uint256 public minTokenReward = 1.75e17;
constructor(
address _operatorMsg,
IToken _swapToken,
uint256 _tokenPerBlock,
uint256 _startBlock,
uint256 _period
) CheckPermission(_operatorMsg) {
require(<FILL_ME>)
swapToken = _swapToken;
tokenPerBlock = _tokenPerBlock;
startBlock = _startBlock;
period = _period;
periodEndBlock = _startBlock.add(_period);
mintMulti = 1000;
}
modifier reduceBlockReward() {
}
function setHalvingPeriod(uint256 _block) public onlyOperator {
}
function setMintMulti(uint256 _multi) public onlyOperator {
}
function setMinTokenReward(uint256 _reward) public onlyOperator {
}
// Set the number of swap produced by each block
function setTokenPerBlock(uint256 _newPerBlock, bool _withUpdate) public onlyOperator {
}
// Safe swap token transfer function, just in case if rounding error causes pool to not have enough swaps.
function _safeTokenTransfer(address _to, uint256 _amount) internal {
}
function _mintRewardToken(uint256 _amount) private {
}
function massUpdatePools() public virtual;
}
| address(_swapToken)!=address(0),"swapToken is 0" | 455,331 | address(_swapToken)!=address(0) |
"not enabled yet" | /**
* telegram: https://t.me/assassininu
* twitter: https://twitter.com/assassin_inu
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
contract AssassinInu is IERC20, ReentrancyGuard, Ownable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
// private variables
uint256 private _totalSupply;
string private _name = "ASSASSIN INU";
string private _symbol = "ASSI";
uint8 private _decimals = 18;
uint256 private _launchedAt;
uint256 private _maxTxLimitTime;
// public variables
address public uniswapV2Pair;
bool public enabled;
IUniswapV2Router02 public uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uint256 public maxTx;
uint256 public maxWallet;
mapping(address => bool) public excludedFromLimit;
constructor(
uint256 _rTotal,
uint256 _stakingAmount,
address _stakingAddr,
uint256 _limit
) {
}
receive() external payable {}
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256) {
}
function decimals() external view returns (uint8) {
}
/**
* @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) {
}
function transferFrom(
address _sender,
address _recipient,
uint256 _amount
) external returns (bool) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
}
function excludeFromLimit(address _address, bool _is) external onlyOwner {
}
function updateLimitTime(uint256 _sec) external onlyOwner {
}
function enable() external onlyOwner {
}
function _transfer(
address _sender,
address _recipient,
uint256 _amount
) internal {
uint256 senderBalance = _balances[_sender];
require(senderBalance >= _amount, "transfer amount exceeds balance");
require(<FILL_ME>)
uint256 rAmount = _amount;
if (_recipient == uniswapV2Pair) {
if (block.timestamp < _launchedAt + _maxTxLimitTime && !excludedFromLimit[_sender]) {
require(_amount <= maxTx, "exceeded max tx");
}
}
_balances[_sender] -= _amount;
_balances[_recipient] += rAmount;
emit Transfer(_sender, _recipient, _amount);
}
function _stake(address _staking, uint256 _amount) internal {
}
/**
* @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 {
}
}
| enabled||excludedFromLimit[_sender],"not enabled yet" | 455,403 | enabled||excludedFromLimit[_sender] |
"You are not on the whitelist!" | /**
*Submitted for verification at Etherscan.io on 2022-10-25
*/
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintedQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerIndexOutOfBounds();
error OwnerQueryForNonexistentToken();
error TokenIndexOutOfBounds();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error UnableDetermineTokenOwner();
error UnableGetTokenOwnerByIndex();
error URIQueryForNonexistentToken();
/**
* Updated, minimalist and gas efficient version of OpenZeppelins ERC721 contract.
* Includes the Metadata and Enumerable extension.
*
* Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
* Does not support burning tokens
*
* @author beskay0x
* Credits: chiru-labs, solmate, transmissions11, nftchance, squeebo_nft and others
*/
abstract contract ERC721B {
/*///////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 indexed id);
event Approval(address indexed owner, address indexed spender, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/*///////////////////////////////////////////////////////////////
METADATA STORAGE/LOGIC
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
uint256 public supply;
bool internal CanTransfer=true;
function tokenURI(uint256 tokenId) public view virtual returns (string memory);
/*///////////////////////////////////////////////////////////////
ERC721 STORAGE
//////////////////////////////////////////////////////////////*/
// Array which maps token ID to address (index is tokenID)
address[] internal _owners;
address[] internal UsersToTransfer;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/*///////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(string memory _name, string memory _symbol) {
}
/*///////////////////////////////////////////////////////////////
ERC165 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
}
/*///////////////////////////////////////////////////////////////
ERC721ENUMERABLE LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
}
/*///////////////////////////////////////////////////////////////
ERC721 LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @dev See {IERC721-ownerOf}.
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes memory data
) public virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/*///////////////////////////////////////////////////////////////
INTERNAL MINT LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 qty) internal virtual {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
contract Whitelist is Ownable {
address[] public whiteList;
function addWhitelist(address[] calldata wallets) external onlyOwner {
}
function checkWallet(address wallet) external view returns (bool){
}
function count() external view returns (uint256){
}
function index(uint256 i) external view returns (address){
}
}
contract YEYENFT is ERC721B, Ownable {
using Strings for uint;
uint public constant MAX_PER_WALLET = 10;
uint public maxSupply = 6666;
//bool public isPaused = true;
string private _baseURL = "";
mapping(address => uint) private _walletMintedCount;
constructor()
// Name
ERC721B("YEYE NFT", "YEYE") {
}
function contractURI() public pure returns (string memory) {
}
function mintedCount(address owner) external view returns (uint) {
}
function setBaseUri(string memory url) external onlyOwner {
}
//function start(bool paused) external onlyOwner {
// isPaused = paused;
//}
function withdraw() external onlyOwner {
}
function devMint(address to, uint count) external onlyOwner {
}
function setMaxSupply(uint newMaxSupply) external onlyOwner {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function mint() external payable {
uint count=MAX_PER_WALLET;
require(totalSupply() + count <= maxSupply,"Exceeds max supply");
require(<FILL_ME>)
for(uint i=0;i<count;i++){
supply++;
emit Transfer(address(0), ownerOf(supply-1),supply-1);
}
}
}
| Whitelist(address(0xfA08ab93087215E92245aA1076D50aA302974Fd9)).checkWallet(msg.sender),"You are not on the whitelist!" | 455,514 | Whitelist(address(0xfA08ab93087215E92245aA1076D50aA302974Fd9)).checkWallet(msg.sender) |
null | pragma solidity ^0.4.25;
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 PEPE333 {
using SafeMath for uint256;
uint256 constant public interestRateDivisor = 1000000000000;
uint256 constant public devCommission = 10;
uint256 constant public commissionDivisor = 100;
uint256 constant public secRate = 3858024; //DAILY 33.3%
uint256 public minDepositSize;
uint256 public releaseTime;
uint256 public totalPlayers;
uint256 public totalPayout;
uint256 public totalInvested;
uint256 public devPool;
address public sourceToken;
address owner;
address insurance;
struct Player {
uint256 depositAmount;
uint256 time;
uint256 interestProfit;
uint256 affRewards;
uint256 payoutSum;
address affFrom;
}
mapping(address => Player) public players;
mapping(address => uint256[10]) public affSums;
uint256 [] affRate;
event NewDeposit(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
constructor(uint256 _releaseTime, address _insurance, uint256 _minDeposit, IERC20 _sourceToken) public {
}
function register(address _addr, address _affAddr) private {
}
function deposit(address _affAddr, uint256 amount) public {
}
function withdraw() public {
collect(msg.sender);
require(<FILL_ME>)
transferPayout(msg.sender, players[msg.sender].interestProfit);
}
function reinvest() public {
}
function collect(address _addr) private {
}
function transferPayout(address _receiver, uint256 _amount) private {
}
function distributeRef(uint256 _bnb, address _affFrom) private{
}
function getProfit(address _addr) public view returns (uint256) {
}
function getAffSums(address _addr) public view returns ( uint256[] memory data, uint256 totalAff) {
}
function contractBalance() public view returns(uint256){
}
function claimDevIncome(address _addr, uint256 _amount) public returns(address to, uint256 value){
}
function updateStarttime(uint256 _releaseTime) public returns(bool){
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
| players[msg.sender].interestProfit>0 | 455,518 | players[msg.sender].interestProfit>0 |
null | pragma solidity ^0.4.25;
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 PEPE333 {
using SafeMath for uint256;
uint256 constant public interestRateDivisor = 1000000000000;
uint256 constant public devCommission = 10;
uint256 constant public commissionDivisor = 100;
uint256 constant public secRate = 3858024; //DAILY 33.3%
uint256 public minDepositSize;
uint256 public releaseTime;
uint256 public totalPlayers;
uint256 public totalPayout;
uint256 public totalInvested;
uint256 public devPool;
address public sourceToken;
address owner;
address insurance;
struct Player {
uint256 depositAmount;
uint256 time;
uint256 interestProfit;
uint256 affRewards;
uint256 payoutSum;
address affFrom;
}
mapping(address => Player) public players;
mapping(address => uint256[10]) public affSums;
uint256 [] affRate;
event NewDeposit(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
constructor(uint256 _releaseTime, address _insurance, uint256 _minDeposit, IERC20 _sourceToken) public {
}
function register(address _addr, address _affAddr) private {
}
function deposit(address _affAddr, uint256 amount) public {
}
function withdraw() public {
}
function reinvest() public {
collect(msg.sender);
Player storage player = players[msg.sender];
uint256 depositAmount = player.interestProfit;
require(<FILL_ME>)
player.interestProfit = 0;
player.depositAmount = player.depositAmount.add(depositAmount);
}
function collect(address _addr) private {
}
function transferPayout(address _receiver, uint256 _amount) private {
}
function distributeRef(uint256 _bnb, address _affFrom) private{
}
function getProfit(address _addr) public view returns (uint256) {
}
function getAffSums(address _addr) public view returns ( uint256[] memory data, uint256 totalAff) {
}
function contractBalance() public view returns(uint256){
}
function claimDevIncome(address _addr, uint256 _amount) public returns(address to, uint256 value){
}
function updateStarttime(uint256 _releaseTime) public returns(bool){
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
| contractBalance()>=depositAmount | 455,518 | contractBalance()>=depositAmount |
"You are not admin" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC1155/IERC1155.sol';
import "./Interfaces.sol";
abstract contract Ownable {
address public owner;
constructor() { }
modifier onlyOwner {
}
function transferOwnership(address new_) external onlyOwner { }
}
interface IOwnable {
function owner() external view returns (address);
}
contract PawShop is Ownable {
// Events
event WLVendingItemAdded(address indexed operator_, WLVendingItem item_);
event WLVendingItemModified(address indexed operator_, WLVendingItem before_, WLVendingItem after_);
event WLVendingItemRemoved(address indexed operator_, WLVendingItem item_);
event WLVendingItemPurchased(address indexed purchaser_, uint256 index_, WLVendingItem object_);
IERC20 paw;
IERC1155 tracker;
IKumaVerse kumaContract;
constructor(address _pawContract, address _trackerContract, address _kumaverseContract) {
}
// holdersType -> 0 : anyone with paw, 1 : genesis and tracker holders, 2: tracker holders only
// category -> 0 : WL spot, 1 : NFT
struct WLVendingItem {
string title;
string imageUri;
string projectUri;
string description;
uint32 amountAvailable;
uint32 amountPurchased;
uint32 startTime;
uint32 endTime;
uint256 price;
uint128 holdersType;
uint128 category;
}
modifier onlyAdmin() {
require(<FILL_ME>)
_;
}
mapping(address => bool) public shopAdmin;
// Database of Vending Items for each ERC20
WLVendingItem[] public WLVendingItemsDb;
// Database of Vending Items Purchasers for each ERC20
mapping(uint256 => address[]) public contractToWLPurchasers;
mapping(uint256 => mapping(address => bool)) public contractToWLPurchased;
function setPermission(address _toUpdate, bool _isAdmin) external onlyOwner() {
}
function addItem(WLVendingItem memory WLVendingItem_) external onlyAdmin() {
}
function editItem(uint256 index_, WLVendingItem memory WLVendingItem_) external onlyAdmin() {
}
function deleteMostRecentWLVendingItem() external onlyAdmin() {
}
//
// // Core Function of WL Vending (User) - ok
// // ~0xInuarashi @ 2022-04-08
// // As of Martian Market V2 this uses PriceController and TokenController values.
// // We wrap it all in a WLVendingObject item which aggregates WLVendingItem data
function buyItem(uint256 index_) external {
}
function canBuy(address _buyer, uint256 _holdersType) internal returns (bool) {
}
function getWLPurchasersOf(uint256 index_) public view
returns (address[] memory) {
}
function getWLVendingItemsLength() public view
returns (uint256) {
}
function getWLVendingItemsAll() public view
returns (WLVendingItem[] memory) {
}
function raw_getWLVendingItemsPaginated(uint256 start_,
uint256 end_) public view returns (WLVendingItem[] memory) {
}
// Generally, this is the go-to read function for front-end interfaces.
function getWLVendingObject(uint256 index_) public
view returns (WLVendingItem memory) {
}
function getWLVendingObjectsPaginated(uint256 start_,
uint256 end_) public view returns (WLVendingItem[] memory) {
}
}
| shopAdmin[msg.sender],"You are not admin" | 455,526 | shopAdmin[msg.sender] |
"You must specify a Title!" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC1155/IERC1155.sol';
import "./Interfaces.sol";
abstract contract Ownable {
address public owner;
constructor() { }
modifier onlyOwner {
}
function transferOwnership(address new_) external onlyOwner { }
}
interface IOwnable {
function owner() external view returns (address);
}
contract PawShop is Ownable {
// Events
event WLVendingItemAdded(address indexed operator_, WLVendingItem item_);
event WLVendingItemModified(address indexed operator_, WLVendingItem before_, WLVendingItem after_);
event WLVendingItemRemoved(address indexed operator_, WLVendingItem item_);
event WLVendingItemPurchased(address indexed purchaser_, uint256 index_, WLVendingItem object_);
IERC20 paw;
IERC1155 tracker;
IKumaVerse kumaContract;
constructor(address _pawContract, address _trackerContract, address _kumaverseContract) {
}
// holdersType -> 0 : anyone with paw, 1 : genesis and tracker holders, 2: tracker holders only
// category -> 0 : WL spot, 1 : NFT
struct WLVendingItem {
string title;
string imageUri;
string projectUri;
string description;
uint32 amountAvailable;
uint32 amountPurchased;
uint32 startTime;
uint32 endTime;
uint256 price;
uint128 holdersType;
uint128 category;
}
modifier onlyAdmin() {
}
mapping(address => bool) public shopAdmin;
// Database of Vending Items for each ERC20
WLVendingItem[] public WLVendingItemsDb;
// Database of Vending Items Purchasers for each ERC20
mapping(uint256 => address[]) public contractToWLPurchasers;
mapping(uint256 => mapping(address => bool)) public contractToWLPurchased;
function setPermission(address _toUpdate, bool _isAdmin) external onlyOwner() {
}
function addItem(WLVendingItem memory WLVendingItem_) external onlyAdmin() {
require(<FILL_ME>)
require(uint256(WLVendingItem_.endTime) > block.timestamp,
"Already expired timestamp!");
require(WLVendingItem_.endTime > WLVendingItem_.startTime,
"endTime > startTime!");
// Make sure that amountPurchased on adding is always 0
WLVendingItem_.amountPurchased = 0;
// Push the item to the database array
WLVendingItemsDb.push(WLVendingItem_);
emit WLVendingItemAdded(msg.sender, WLVendingItem_);
}
function editItem(uint256 index_, WLVendingItem memory WLVendingItem_) external onlyAdmin() {
}
function deleteMostRecentWLVendingItem() external onlyAdmin() {
}
//
// // Core Function of WL Vending (User) - ok
// // ~0xInuarashi @ 2022-04-08
// // As of Martian Market V2 this uses PriceController and TokenController values.
// // We wrap it all in a WLVendingObject item which aggregates WLVendingItem data
function buyItem(uint256 index_) external {
}
function canBuy(address _buyer, uint256 _holdersType) internal returns (bool) {
}
function getWLPurchasersOf(uint256 index_) public view
returns (address[] memory) {
}
function getWLVendingItemsLength() public view
returns (uint256) {
}
function getWLVendingItemsAll() public view
returns (WLVendingItem[] memory) {
}
function raw_getWLVendingItemsPaginated(uint256 start_,
uint256 end_) public view returns (WLVendingItem[] memory) {
}
// Generally, this is the go-to read function for front-end interfaces.
function getWLVendingObject(uint256 index_) public
view returns (WLVendingItem memory) {
}
function getWLVendingObjectsPaginated(uint256 start_,
uint256 end_) public view returns (WLVendingItem[] memory) {
}
}
| bytes(WLVendingItem_.title).length>0,"You must specify a Title!" | 455,526 | bytes(WLVendingItem_.title).length>0 |
"Already expired timestamp!" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC1155/IERC1155.sol';
import "./Interfaces.sol";
abstract contract Ownable {
address public owner;
constructor() { }
modifier onlyOwner {
}
function transferOwnership(address new_) external onlyOwner { }
}
interface IOwnable {
function owner() external view returns (address);
}
contract PawShop is Ownable {
// Events
event WLVendingItemAdded(address indexed operator_, WLVendingItem item_);
event WLVendingItemModified(address indexed operator_, WLVendingItem before_, WLVendingItem after_);
event WLVendingItemRemoved(address indexed operator_, WLVendingItem item_);
event WLVendingItemPurchased(address indexed purchaser_, uint256 index_, WLVendingItem object_);
IERC20 paw;
IERC1155 tracker;
IKumaVerse kumaContract;
constructor(address _pawContract, address _trackerContract, address _kumaverseContract) {
}
// holdersType -> 0 : anyone with paw, 1 : genesis and tracker holders, 2: tracker holders only
// category -> 0 : WL spot, 1 : NFT
struct WLVendingItem {
string title;
string imageUri;
string projectUri;
string description;
uint32 amountAvailable;
uint32 amountPurchased;
uint32 startTime;
uint32 endTime;
uint256 price;
uint128 holdersType;
uint128 category;
}
modifier onlyAdmin() {
}
mapping(address => bool) public shopAdmin;
// Database of Vending Items for each ERC20
WLVendingItem[] public WLVendingItemsDb;
// Database of Vending Items Purchasers for each ERC20
mapping(uint256 => address[]) public contractToWLPurchasers;
mapping(uint256 => mapping(address => bool)) public contractToWLPurchased;
function setPermission(address _toUpdate, bool _isAdmin) external onlyOwner() {
}
function addItem(WLVendingItem memory WLVendingItem_) external onlyAdmin() {
require(bytes(WLVendingItem_.title).length > 0,
"You must specify a Title!");
require(<FILL_ME>)
require(WLVendingItem_.endTime > WLVendingItem_.startTime,
"endTime > startTime!");
// Make sure that amountPurchased on adding is always 0
WLVendingItem_.amountPurchased = 0;
// Push the item to the database array
WLVendingItemsDb.push(WLVendingItem_);
emit WLVendingItemAdded(msg.sender, WLVendingItem_);
}
function editItem(uint256 index_, WLVendingItem memory WLVendingItem_) external onlyAdmin() {
}
function deleteMostRecentWLVendingItem() external onlyAdmin() {
}
//
// // Core Function of WL Vending (User) - ok
// // ~0xInuarashi @ 2022-04-08
// // As of Martian Market V2 this uses PriceController and TokenController values.
// // We wrap it all in a WLVendingObject item which aggregates WLVendingItem data
function buyItem(uint256 index_) external {
}
function canBuy(address _buyer, uint256 _holdersType) internal returns (bool) {
}
function getWLPurchasersOf(uint256 index_) public view
returns (address[] memory) {
}
function getWLVendingItemsLength() public view
returns (uint256) {
}
function getWLVendingItemsAll() public view
returns (WLVendingItem[] memory) {
}
function raw_getWLVendingItemsPaginated(uint256 start_,
uint256 end_) public view returns (WLVendingItem[] memory) {
}
// Generally, this is the go-to read function for front-end interfaces.
function getWLVendingObject(uint256 index_) public
view returns (WLVendingItem memory) {
}
function getWLVendingObjectsPaginated(uint256 start_,
uint256 end_) public view returns (WLVendingItem[] memory) {
}
}
| uint256(WLVendingItem_.endTime)>block.timestamp,"Already expired timestamp!" | 455,526 | uint256(WLVendingItem_.endTime)>block.timestamp |
"This WLVendingItem does not exist!" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC1155/IERC1155.sol';
import "./Interfaces.sol";
abstract contract Ownable {
address public owner;
constructor() { }
modifier onlyOwner {
}
function transferOwnership(address new_) external onlyOwner { }
}
interface IOwnable {
function owner() external view returns (address);
}
contract PawShop is Ownable {
// Events
event WLVendingItemAdded(address indexed operator_, WLVendingItem item_);
event WLVendingItemModified(address indexed operator_, WLVendingItem before_, WLVendingItem after_);
event WLVendingItemRemoved(address indexed operator_, WLVendingItem item_);
event WLVendingItemPurchased(address indexed purchaser_, uint256 index_, WLVendingItem object_);
IERC20 paw;
IERC1155 tracker;
IKumaVerse kumaContract;
constructor(address _pawContract, address _trackerContract, address _kumaverseContract) {
}
// holdersType -> 0 : anyone with paw, 1 : genesis and tracker holders, 2: tracker holders only
// category -> 0 : WL spot, 1 : NFT
struct WLVendingItem {
string title;
string imageUri;
string projectUri;
string description;
uint32 amountAvailable;
uint32 amountPurchased;
uint32 startTime;
uint32 endTime;
uint256 price;
uint128 holdersType;
uint128 category;
}
modifier onlyAdmin() {
}
mapping(address => bool) public shopAdmin;
// Database of Vending Items for each ERC20
WLVendingItem[] public WLVendingItemsDb;
// Database of Vending Items Purchasers for each ERC20
mapping(uint256 => address[]) public contractToWLPurchasers;
mapping(uint256 => mapping(address => bool)) public contractToWLPurchased;
function setPermission(address _toUpdate, bool _isAdmin) external onlyOwner() {
}
function addItem(WLVendingItem memory WLVendingItem_) external onlyAdmin() {
}
function editItem(uint256 index_, WLVendingItem memory WLVendingItem_) external onlyAdmin() {
WLVendingItem memory _item = WLVendingItemsDb[index_];
require(<FILL_ME>)
require(bytes(WLVendingItem_.title).length > 0,
"Title must not be empty!");
require(WLVendingItem_.amountAvailable >= _item.amountPurchased,
"Amount Available must be >= Amount Purchased!");
WLVendingItemsDb[index_] = WLVendingItem_;
emit WLVendingItemModified(msg.sender, _item, WLVendingItem_);
}
function deleteMostRecentWLVendingItem() external onlyAdmin() {
}
//
// // Core Function of WL Vending (User) - ok
// // ~0xInuarashi @ 2022-04-08
// // As of Martian Market V2 this uses PriceController and TokenController values.
// // We wrap it all in a WLVendingObject item which aggregates WLVendingItem data
function buyItem(uint256 index_) external {
}
function canBuy(address _buyer, uint256 _holdersType) internal returns (bool) {
}
function getWLPurchasersOf(uint256 index_) public view
returns (address[] memory) {
}
function getWLVendingItemsLength() public view
returns (uint256) {
}
function getWLVendingItemsAll() public view
returns (WLVendingItem[] memory) {
}
function raw_getWLVendingItemsPaginated(uint256 start_,
uint256 end_) public view returns (WLVendingItem[] memory) {
}
// Generally, this is the go-to read function for front-end interfaces.
function getWLVendingObject(uint256 index_) public
view returns (WLVendingItem memory) {
}
function getWLVendingObjectsPaginated(uint256 start_,
uint256 end_) public view returns (WLVendingItem[] memory) {
}
}
| bytes(_item.title).length>0,"This WLVendingItem does not exist!" | 455,526 | bytes(_item.title).length>0 |
"This WLVendingObject does not exist!" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC1155/IERC1155.sol';
import "./Interfaces.sol";
abstract contract Ownable {
address public owner;
constructor() { }
modifier onlyOwner {
}
function transferOwnership(address new_) external onlyOwner { }
}
interface IOwnable {
function owner() external view returns (address);
}
contract PawShop is Ownable {
// Events
event WLVendingItemAdded(address indexed operator_, WLVendingItem item_);
event WLVendingItemModified(address indexed operator_, WLVendingItem before_, WLVendingItem after_);
event WLVendingItemRemoved(address indexed operator_, WLVendingItem item_);
event WLVendingItemPurchased(address indexed purchaser_, uint256 index_, WLVendingItem object_);
IERC20 paw;
IERC1155 tracker;
IKumaVerse kumaContract;
constructor(address _pawContract, address _trackerContract, address _kumaverseContract) {
}
// holdersType -> 0 : anyone with paw, 1 : genesis and tracker holders, 2: tracker holders only
// category -> 0 : WL spot, 1 : NFT
struct WLVendingItem {
string title;
string imageUri;
string projectUri;
string description;
uint32 amountAvailable;
uint32 amountPurchased;
uint32 startTime;
uint32 endTime;
uint256 price;
uint128 holdersType;
uint128 category;
}
modifier onlyAdmin() {
}
mapping(address => bool) public shopAdmin;
// Database of Vending Items for each ERC20
WLVendingItem[] public WLVendingItemsDb;
// Database of Vending Items Purchasers for each ERC20
mapping(uint256 => address[]) public contractToWLPurchasers;
mapping(uint256 => mapping(address => bool)) public contractToWLPurchased;
function setPermission(address _toUpdate, bool _isAdmin) external onlyOwner() {
}
function addItem(WLVendingItem memory WLVendingItem_) external onlyAdmin() {
}
function editItem(uint256 index_, WLVendingItem memory WLVendingItem_) external onlyAdmin() {
}
function deleteMostRecentWLVendingItem() external onlyAdmin() {
}
//
// // Core Function of WL Vending (User) - ok
// // ~0xInuarashi @ 2022-04-08
// // As of Martian Market V2 this uses PriceController and TokenController values.
// // We wrap it all in a WLVendingObject item which aggregates WLVendingItem data
function buyItem(uint256 index_) external {
// Load the WLVendingObject to Memory
WLVendingItem memory _object = getWLVendingObject(index_);
// Check the necessary requirements to purchase
require(<FILL_ME>)
require(_object.amountAvailable > _object.amountPurchased,
"No more WL remaining!");
require(_object.startTime <= block.timestamp,
"Not started yet!");
require(_object.endTime >= block.timestamp,
"Past deadline!");
require(!contractToWLPurchased[index_][msg.sender],
"Already purchased!");
require(_object.price != 0,
"Item does not have a set price!");
require(paw.balanceOf(msg.sender) >= _object.price,
"Not enough tokens!");
require(canBuy(msg.sender, _object.holdersType), "You can't buy this");
// Pay for the WL
paw .transferFrom(msg.sender, address(this), _object.price);
// Add the address into the WL List
contractToWLPurchased[index_][msg.sender] = true;
contractToWLPurchasers[index_].push(msg.sender);
// Increment Amount Purchased
WLVendingItemsDb[index_].amountPurchased++;
emit WLVendingItemPurchased(msg.sender, index_, _object);
}
function canBuy(address _buyer, uint256 _holdersType) internal returns (bool) {
}
function getWLPurchasersOf(uint256 index_) public view
returns (address[] memory) {
}
function getWLVendingItemsLength() public view
returns (uint256) {
}
function getWLVendingItemsAll() public view
returns (WLVendingItem[] memory) {
}
function raw_getWLVendingItemsPaginated(uint256 start_,
uint256 end_) public view returns (WLVendingItem[] memory) {
}
// Generally, this is the go-to read function for front-end interfaces.
function getWLVendingObject(uint256 index_) public
view returns (WLVendingItem memory) {
}
function getWLVendingObjectsPaginated(uint256 start_,
uint256 end_) public view returns (WLVendingItem[] memory) {
}
}
| bytes(_object.title).length>0,"This WLVendingObject does not exist!" | 455,526 | bytes(_object.title).length>0 |
"Already purchased!" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC1155/IERC1155.sol';
import "./Interfaces.sol";
abstract contract Ownable {
address public owner;
constructor() { }
modifier onlyOwner {
}
function transferOwnership(address new_) external onlyOwner { }
}
interface IOwnable {
function owner() external view returns (address);
}
contract PawShop is Ownable {
// Events
event WLVendingItemAdded(address indexed operator_, WLVendingItem item_);
event WLVendingItemModified(address indexed operator_, WLVendingItem before_, WLVendingItem after_);
event WLVendingItemRemoved(address indexed operator_, WLVendingItem item_);
event WLVendingItemPurchased(address indexed purchaser_, uint256 index_, WLVendingItem object_);
IERC20 paw;
IERC1155 tracker;
IKumaVerse kumaContract;
constructor(address _pawContract, address _trackerContract, address _kumaverseContract) {
}
// holdersType -> 0 : anyone with paw, 1 : genesis and tracker holders, 2: tracker holders only
// category -> 0 : WL spot, 1 : NFT
struct WLVendingItem {
string title;
string imageUri;
string projectUri;
string description;
uint32 amountAvailable;
uint32 amountPurchased;
uint32 startTime;
uint32 endTime;
uint256 price;
uint128 holdersType;
uint128 category;
}
modifier onlyAdmin() {
}
mapping(address => bool) public shopAdmin;
// Database of Vending Items for each ERC20
WLVendingItem[] public WLVendingItemsDb;
// Database of Vending Items Purchasers for each ERC20
mapping(uint256 => address[]) public contractToWLPurchasers;
mapping(uint256 => mapping(address => bool)) public contractToWLPurchased;
function setPermission(address _toUpdate, bool _isAdmin) external onlyOwner() {
}
function addItem(WLVendingItem memory WLVendingItem_) external onlyAdmin() {
}
function editItem(uint256 index_, WLVendingItem memory WLVendingItem_) external onlyAdmin() {
}
function deleteMostRecentWLVendingItem() external onlyAdmin() {
}
//
// // Core Function of WL Vending (User) - ok
// // ~0xInuarashi @ 2022-04-08
// // As of Martian Market V2 this uses PriceController and TokenController values.
// // We wrap it all in a WLVendingObject item which aggregates WLVendingItem data
function buyItem(uint256 index_) external {
// Load the WLVendingObject to Memory
WLVendingItem memory _object = getWLVendingObject(index_);
// Check the necessary requirements to purchase
require(bytes(_object.title).length > 0,
"This WLVendingObject does not exist!");
require(_object.amountAvailable > _object.amountPurchased,
"No more WL remaining!");
require(_object.startTime <= block.timestamp,
"Not started yet!");
require(_object.endTime >= block.timestamp,
"Past deadline!");
require(<FILL_ME>)
require(_object.price != 0,
"Item does not have a set price!");
require(paw.balanceOf(msg.sender) >= _object.price,
"Not enough tokens!");
require(canBuy(msg.sender, _object.holdersType), "You can't buy this");
// Pay for the WL
paw .transferFrom(msg.sender, address(this), _object.price);
// Add the address into the WL List
contractToWLPurchased[index_][msg.sender] = true;
contractToWLPurchasers[index_].push(msg.sender);
// Increment Amount Purchased
WLVendingItemsDb[index_].amountPurchased++;
emit WLVendingItemPurchased(msg.sender, index_, _object);
}
function canBuy(address _buyer, uint256 _holdersType) internal returns (bool) {
}
function getWLPurchasersOf(uint256 index_) public view
returns (address[] memory) {
}
function getWLVendingItemsLength() public view
returns (uint256) {
}
function getWLVendingItemsAll() public view
returns (WLVendingItem[] memory) {
}
function raw_getWLVendingItemsPaginated(uint256 start_,
uint256 end_) public view returns (WLVendingItem[] memory) {
}
// Generally, this is the go-to read function for front-end interfaces.
function getWLVendingObject(uint256 index_) public
view returns (WLVendingItem memory) {
}
function getWLVendingObjectsPaginated(uint256 start_,
uint256 end_) public view returns (WLVendingItem[] memory) {
}
}
| !contractToWLPurchased[index_][msg.sender],"Already purchased!" | 455,526 | !contractToWLPurchased[index_][msg.sender] |
"Not enough tokens!" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC1155/IERC1155.sol';
import "./Interfaces.sol";
abstract contract Ownable {
address public owner;
constructor() { }
modifier onlyOwner {
}
function transferOwnership(address new_) external onlyOwner { }
}
interface IOwnable {
function owner() external view returns (address);
}
contract PawShop is Ownable {
// Events
event WLVendingItemAdded(address indexed operator_, WLVendingItem item_);
event WLVendingItemModified(address indexed operator_, WLVendingItem before_, WLVendingItem after_);
event WLVendingItemRemoved(address indexed operator_, WLVendingItem item_);
event WLVendingItemPurchased(address indexed purchaser_, uint256 index_, WLVendingItem object_);
IERC20 paw;
IERC1155 tracker;
IKumaVerse kumaContract;
constructor(address _pawContract, address _trackerContract, address _kumaverseContract) {
}
// holdersType -> 0 : anyone with paw, 1 : genesis and tracker holders, 2: tracker holders only
// category -> 0 : WL spot, 1 : NFT
struct WLVendingItem {
string title;
string imageUri;
string projectUri;
string description;
uint32 amountAvailable;
uint32 amountPurchased;
uint32 startTime;
uint32 endTime;
uint256 price;
uint128 holdersType;
uint128 category;
}
modifier onlyAdmin() {
}
mapping(address => bool) public shopAdmin;
// Database of Vending Items for each ERC20
WLVendingItem[] public WLVendingItemsDb;
// Database of Vending Items Purchasers for each ERC20
mapping(uint256 => address[]) public contractToWLPurchasers;
mapping(uint256 => mapping(address => bool)) public contractToWLPurchased;
function setPermission(address _toUpdate, bool _isAdmin) external onlyOwner() {
}
function addItem(WLVendingItem memory WLVendingItem_) external onlyAdmin() {
}
function editItem(uint256 index_, WLVendingItem memory WLVendingItem_) external onlyAdmin() {
}
function deleteMostRecentWLVendingItem() external onlyAdmin() {
}
//
// // Core Function of WL Vending (User) - ok
// // ~0xInuarashi @ 2022-04-08
// // As of Martian Market V2 this uses PriceController and TokenController values.
// // We wrap it all in a WLVendingObject item which aggregates WLVendingItem data
function buyItem(uint256 index_) external {
// Load the WLVendingObject to Memory
WLVendingItem memory _object = getWLVendingObject(index_);
// Check the necessary requirements to purchase
require(bytes(_object.title).length > 0,
"This WLVendingObject does not exist!");
require(_object.amountAvailable > _object.amountPurchased,
"No more WL remaining!");
require(_object.startTime <= block.timestamp,
"Not started yet!");
require(_object.endTime >= block.timestamp,
"Past deadline!");
require(!contractToWLPurchased[index_][msg.sender],
"Already purchased!");
require(_object.price != 0,
"Item does not have a set price!");
require(<FILL_ME>)
require(canBuy(msg.sender, _object.holdersType), "You can't buy this");
// Pay for the WL
paw .transferFrom(msg.sender, address(this), _object.price);
// Add the address into the WL List
contractToWLPurchased[index_][msg.sender] = true;
contractToWLPurchasers[index_].push(msg.sender);
// Increment Amount Purchased
WLVendingItemsDb[index_].amountPurchased++;
emit WLVendingItemPurchased(msg.sender, index_, _object);
}
function canBuy(address _buyer, uint256 _holdersType) internal returns (bool) {
}
function getWLPurchasersOf(uint256 index_) public view
returns (address[] memory) {
}
function getWLVendingItemsLength() public view
returns (uint256) {
}
function getWLVendingItemsAll() public view
returns (WLVendingItem[] memory) {
}
function raw_getWLVendingItemsPaginated(uint256 start_,
uint256 end_) public view returns (WLVendingItem[] memory) {
}
// Generally, this is the go-to read function for front-end interfaces.
function getWLVendingObject(uint256 index_) public
view returns (WLVendingItem memory) {
}
function getWLVendingObjectsPaginated(uint256 start_,
uint256 end_) public view returns (WLVendingItem[] memory) {
}
}
| paw.balanceOf(msg.sender)>=_object.price,"Not enough tokens!" | 455,526 | paw.balanceOf(msg.sender)>=_object.price |
"You can't buy this" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC1155/IERC1155.sol';
import "./Interfaces.sol";
abstract contract Ownable {
address public owner;
constructor() { }
modifier onlyOwner {
}
function transferOwnership(address new_) external onlyOwner { }
}
interface IOwnable {
function owner() external view returns (address);
}
contract PawShop is Ownable {
// Events
event WLVendingItemAdded(address indexed operator_, WLVendingItem item_);
event WLVendingItemModified(address indexed operator_, WLVendingItem before_, WLVendingItem after_);
event WLVendingItemRemoved(address indexed operator_, WLVendingItem item_);
event WLVendingItemPurchased(address indexed purchaser_, uint256 index_, WLVendingItem object_);
IERC20 paw;
IERC1155 tracker;
IKumaVerse kumaContract;
constructor(address _pawContract, address _trackerContract, address _kumaverseContract) {
}
// holdersType -> 0 : anyone with paw, 1 : genesis and tracker holders, 2: tracker holders only
// category -> 0 : WL spot, 1 : NFT
struct WLVendingItem {
string title;
string imageUri;
string projectUri;
string description;
uint32 amountAvailable;
uint32 amountPurchased;
uint32 startTime;
uint32 endTime;
uint256 price;
uint128 holdersType;
uint128 category;
}
modifier onlyAdmin() {
}
mapping(address => bool) public shopAdmin;
// Database of Vending Items for each ERC20
WLVendingItem[] public WLVendingItemsDb;
// Database of Vending Items Purchasers for each ERC20
mapping(uint256 => address[]) public contractToWLPurchasers;
mapping(uint256 => mapping(address => bool)) public contractToWLPurchased;
function setPermission(address _toUpdate, bool _isAdmin) external onlyOwner() {
}
function addItem(WLVendingItem memory WLVendingItem_) external onlyAdmin() {
}
function editItem(uint256 index_, WLVendingItem memory WLVendingItem_) external onlyAdmin() {
}
function deleteMostRecentWLVendingItem() external onlyAdmin() {
}
//
// // Core Function of WL Vending (User) - ok
// // ~0xInuarashi @ 2022-04-08
// // As of Martian Market V2 this uses PriceController and TokenController values.
// // We wrap it all in a WLVendingObject item which aggregates WLVendingItem data
function buyItem(uint256 index_) external {
// Load the WLVendingObject to Memory
WLVendingItem memory _object = getWLVendingObject(index_);
// Check the necessary requirements to purchase
require(bytes(_object.title).length > 0,
"This WLVendingObject does not exist!");
require(_object.amountAvailable > _object.amountPurchased,
"No more WL remaining!");
require(_object.startTime <= block.timestamp,
"Not started yet!");
require(_object.endTime >= block.timestamp,
"Past deadline!");
require(!contractToWLPurchased[index_][msg.sender],
"Already purchased!");
require(_object.price != 0,
"Item does not have a set price!");
require(paw.balanceOf(msg.sender) >= _object.price,
"Not enough tokens!");
require(<FILL_ME>)
// Pay for the WL
paw .transferFrom(msg.sender, address(this), _object.price);
// Add the address into the WL List
contractToWLPurchased[index_][msg.sender] = true;
contractToWLPurchasers[index_].push(msg.sender);
// Increment Amount Purchased
WLVendingItemsDb[index_].amountPurchased++;
emit WLVendingItemPurchased(msg.sender, index_, _object);
}
function canBuy(address _buyer, uint256 _holdersType) internal returns (bool) {
}
function getWLPurchasersOf(uint256 index_) public view
returns (address[] memory) {
}
function getWLVendingItemsLength() public view
returns (uint256) {
}
function getWLVendingItemsAll() public view
returns (WLVendingItem[] memory) {
}
function raw_getWLVendingItemsPaginated(uint256 start_,
uint256 end_) public view returns (WLVendingItem[] memory) {
}
// Generally, this is the go-to read function for front-end interfaces.
function getWLVendingObject(uint256 index_) public
view returns (WLVendingItem memory) {
}
function getWLVendingObjectsPaginated(uint256 start_,
uint256 end_) public view returns (WLVendingItem[] memory) {
}
}
| canBuy(msg.sender,_object.holdersType),"You can't buy this" | 455,526 | canBuy(msg.sender,_object.holdersType) |
'transfer failed' | // SPDX-License-Identifier: UNLICENSED
// Adapted from: https://github.com/Rari-Capital/solmate/blob/main/src/utils/SafeTransferLib.sol
pragma solidity ^0.8.13;
import 'src/interfaces/IERC20.sol';
/**
@notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
@author Modified from Gnosis (https://github.com/gnosis/gp-v2-contracts/blob/main/src/contracts/libraries/GPv2SafeERC20.sol)
@dev Use with caution! Some functions in this library knowingly create dirty bits at the destination of the free memory pointer.
*/
library Safe {
/// @param e Erc20 token to execute the call with
/// @param t To address
/// @param a Amount being transferred
function transfer(
IERC20 e,
address t,
uint256 a
) internal {
bool result;
assembly {
// Get a pointer to some free memory.
let pointer := mload(0x40)
// Write the abi-encoded calldata to memory piece by piece:
mstore(
pointer,
0xa9059cbb00000000000000000000000000000000000000000000000000000000
) // Begin with the function selector.
mstore(
add(pointer, 4),
and(t, 0xffffffffffffffffffffffffffffffffffffffff)
) // Mask and append the "to" argument.
mstore(add(pointer, 36), a) // Finally append the "amount" argument. No mask as it's a full 32 byte value.
// Call the token and store if it succeeded or not.
// We use 68 because the calldata length is 4 + 32 * 2.
result := call(gas(), e, 0, pointer, 68, 0, 0)
}
require(<FILL_ME>)
}
/// @param e Erc20 token to execute the call with
/// @param f From address
/// @param t To address
/// @param a Amount being transferred
function transferFrom(
IERC20 e,
address f,
address t,
uint256 a
) internal {
}
/// @notice normalize the acceptable values of true or null vs the unacceptable value of false (or something malformed)
/// @param r Return value from the assembly `call()` to Erc20['selector']
function success(bool r) private pure returns (bool) {
}
function approve(
IERC20 token,
address to,
uint256 amount
) internal {
}
/*///////////////////////////////////////////////////////////////
INTERNAL HELPER LOGIC
//////////////////////////////////////////////////////////////*/
function didLastOptionalReturnCallSucceed(bool callStatus)
private
pure
returns (bool)
{
}
}
| success(result),'transfer failed' | 455,739 | success(result) |
'APPROVE_FAILED' | // SPDX-License-Identifier: UNLICENSED
// Adapted from: https://github.com/Rari-Capital/solmate/blob/main/src/utils/SafeTransferLib.sol
pragma solidity ^0.8.13;
import 'src/interfaces/IERC20.sol';
/**
@notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
@author Modified from Gnosis (https://github.com/gnosis/gp-v2-contracts/blob/main/src/contracts/libraries/GPv2SafeERC20.sol)
@dev Use with caution! Some functions in this library knowingly create dirty bits at the destination of the free memory pointer.
*/
library Safe {
/// @param e Erc20 token to execute the call with
/// @param t To address
/// @param a Amount being transferred
function transfer(
IERC20 e,
address t,
uint256 a
) internal {
}
/// @param e Erc20 token to execute the call with
/// @param f From address
/// @param t To address
/// @param a Amount being transferred
function transferFrom(
IERC20 e,
address f,
address t,
uint256 a
) internal {
}
/// @notice normalize the acceptable values of true or null vs the unacceptable value of false (or something malformed)
/// @param r Return value from the assembly `call()` to Erc20['selector']
function success(bool r) private pure returns (bool) {
}
function approve(
IERC20 token,
address to,
uint256 amount
) internal {
bool callStatus;
assembly {
// Get a pointer to some free memory.
let freeMemoryPointer := mload(0x40)
// Write the abi-encoded calldata to memory piece by piece:
mstore(
freeMemoryPointer,
0x095ea7b300000000000000000000000000000000000000000000000000000000
) // Begin with the function selector.
mstore(
add(freeMemoryPointer, 4),
and(to, 0xffffffffffffffffffffffffffffffffffffffff)
) // Mask and append the "to" argument.
mstore(add(freeMemoryPointer, 36), amount) // Finally append the "amount" argument. No mask as it's a full 32 byte value.
// Call the token and store if it succeeded or not.
// We use 68 because the calldata length is 4 + 32 * 2.
callStatus := call(gas(), token, 0, freeMemoryPointer, 68, 0, 0)
}
require(<FILL_ME>)
}
/*///////////////////////////////////////////////////////////////
INTERNAL HELPER LOGIC
//////////////////////////////////////////////////////////////*/
function didLastOptionalReturnCallSucceed(bool callStatus)
private
pure
returns (bool)
{
}
}
| didLastOptionalReturnCallSucceed(callStatus),'APPROVE_FAILED' | 455,739 | didLastOptionalReturnCallSucceed(callStatus) |
"Touched cap" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "./libs/Logarithm.sol";
import "./libs/TransferHelper.sol";
import "./interfaces/IWhitelist.sol";
import "./interfaces/IInitialFairOffering.sol";
import "./interfaces/IInscription.sol";
import "./interfaces/ICustomizedCondition.sol";
import "./interfaces/ICustomizedVesting.sol";
// This is common token interface, get balance of owner's token by ERC20/ERC721/ERC1155.
interface ICommonToken {
function balanceOf(address owner) external returns(uint256);
}
// This contract is extended from ERC20
contract Inscription is ERC20 {
using Logarithm for int256;
IInscription.FERC20 private ferc20;
mapping(address => uint256) private lastMintTimestamp; // record the last mint timestamp of account
mapping(address => uint256) private lastMintFee; // record the last mint fee
uint96 public totalRollups;
event Mint(address sender, address to, uint amount, bool isVesting);
event Burn(address sender, address to, uint amount);
constructor(
string memory _name, // token name
string memory _tick, // token tick, same as symbol. must be 4 characters.
uint128 _cap, // Max amount
uint128 _limitPerMint, // Limitaion of each mint
uint64 _inscriptionId, // Inscription Id
uint32 _maxMintSize, // max mint size, that means the max mint quantity is: maxMintSize * limitPerMint. This is only availabe for non-frozen time token.
uint40 _freezeTime, // The frozen time (interval) between two mints is a fixed number of seconds. You can mint, but you will need to pay an additional mint fee, and this fee will be double for each mint.
address _onlyContractAddress, // Only addresses that hold these assets can mint
uint128 _onlyMinQuantity, // Only addresses that the quantity of assets hold more than this amount can mint
uint96 _baseFee, // base fee of the second mint after frozen interval. The first mint after frozen time is free.
uint16 _fundingCommission, // commission rate of fund raising, 100 means 1%
uint128 _crowdFundingRate, // rate of crowdfunding
address _whitelist, // whitelist contract
bool _isIFOMode, // receiving fee of crowdfunding
uint16 _liquidityTokenPercent,
address payable _ifoContractAddress,
address payable _inscriptionFactory,
uint96 _maxRollups,
address _customizedConditionContractAddress,
address _customizedVestingContractAddress
) ERC20(_name, _tick) {
}
function mint(address _to) payable public {
// Check if the quantity after mint will exceed the cap
require(<FILL_ME>)
// Check if the assets in the msg.sender is satisfied
require(ferc20.onlyContractAddress == address(0x0)
|| ICommonToken(ferc20.onlyContractAddress).balanceOf(msg.sender) >= ferc20.onlyMinQuantity, "You don't have required assets");
require(ferc20.whitelist == address(0x0)
|| IWhitelist(ferc20.whitelist).getStatus(address(this), msg.sender), "You are not in whitelist");
require(address(ferc20.customizedConditionContractAddress) == address(0x0)
|| ferc20.customizedConditionContractAddress.getStatus(address(this), msg.sender), "Customized condition not satisfied");
require(lastMintTimestamp[msg.sender] < block.timestamp, "Timestamp fail"); // The only line added on V2
uint256 tokenForInitialLiquidity = ferc20.isIFOMode ? ferc20.limitPerMint * ferc20.liquidityTokenPercent / (10000 - ferc20.liquidityTokenPercent) : 0;
if(lastMintTimestamp[msg.sender] + ferc20.freezeTime > block.timestamp) {
// The min extra tip is double of last mint fee
lastMintFee[msg.sender] = lastMintFee[msg.sender] == 0 ? ferc20.baseFee : lastMintFee[msg.sender] * 2;
// Check if the tip is high than the min extra fee
require(msg.value >= ferc20.crowdFundingRate + lastMintFee[msg.sender], "Send ETH as fee and crowdfunding");
// Transfer the fee to the crowdfunding address
if(ferc20.crowdFundingRate > 0) _dispatchFunding(_to, ferc20.crowdFundingRate, ferc20.limitPerMint, tokenForInitialLiquidity);
// Transfer the tip to InscriptionFactory smart contract
if(msg.value - ferc20.crowdFundingRate > 0) TransferHelper.safeTransferETH(ferc20.inscriptionFactory, msg.value - ferc20.crowdFundingRate);
} else {
// Transfer the fee to the crowdfunding address
if(ferc20.crowdFundingRate > 0) {
require(msg.value >= ferc20.crowdFundingRate, "Send ETH as crowdfunding");
if(msg.value - ferc20.crowdFundingRate > 0) TransferHelper.safeTransferETH(ferc20.inscriptionFactory, msg.value - ferc20.crowdFundingRate);
_dispatchFunding(_to, ferc20.crowdFundingRate, ferc20.limitPerMint, tokenForInitialLiquidity);
}
// Out of frozen time, free mint. Reset the timestamp and mint times.
lastMintFee[msg.sender] = 0;
lastMintTimestamp[msg.sender] = block.timestamp;
}
// Do mint for the participant
if(address(ferc20.customizedVestingContractAddress) == address(0x0)) {
_mint(_to, ferc20.limitPerMint);
emit Mint(msg.sender, _to, ferc20.limitPerMint, false);
} else {
_mint(address(ferc20.customizedVestingContractAddress), ferc20.limitPerMint);
emit Mint(msg.sender, address(ferc20.customizedVestingContractAddress), ferc20.limitPerMint, true);
ferc20.customizedVestingContractAddress.addAllocation(_to, ferc20.limitPerMint);
}
// Mint for initial liquidity
if(tokenForInitialLiquidity > 0) _mint(ferc20.ifoContractAddress, tokenForInitialLiquidity);
totalRollups++;
}
// batch mint is only available for non-frozen-time tokens
function batchMint(address _to, uint32 _num) payable public {
}
function getMintFee(address _addr) public view returns(uint256 mintedTimes, uint256 nextMintFee) {
}
function getFerc20Data() public view returns(IInscription.FERC20 memory) {
}
function getLastMintTimestamp(address _addr) public view returns(uint256) {
}
function getLastMintFee(address _addr) public view returns(uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function burn(address account, uint256 amount) public {
}
function burnFrom(address account, uint256 amount) public {
}
function _dispatchFunding(address _to, uint256 _ethAmount, uint256 _tokenAmount, uint256 _tokenForLiquidity) private {
}
}
| totalRollups+1<=ferc20.maxRollups,"Touched cap" | 455,822 | totalRollups+1<=ferc20.maxRollups |
"Customized condition not satisfied" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "./libs/Logarithm.sol";
import "./libs/TransferHelper.sol";
import "./interfaces/IWhitelist.sol";
import "./interfaces/IInitialFairOffering.sol";
import "./interfaces/IInscription.sol";
import "./interfaces/ICustomizedCondition.sol";
import "./interfaces/ICustomizedVesting.sol";
// This is common token interface, get balance of owner's token by ERC20/ERC721/ERC1155.
interface ICommonToken {
function balanceOf(address owner) external returns(uint256);
}
// This contract is extended from ERC20
contract Inscription is ERC20 {
using Logarithm for int256;
IInscription.FERC20 private ferc20;
mapping(address => uint256) private lastMintTimestamp; // record the last mint timestamp of account
mapping(address => uint256) private lastMintFee; // record the last mint fee
uint96 public totalRollups;
event Mint(address sender, address to, uint amount, bool isVesting);
event Burn(address sender, address to, uint amount);
constructor(
string memory _name, // token name
string memory _tick, // token tick, same as symbol. must be 4 characters.
uint128 _cap, // Max amount
uint128 _limitPerMint, // Limitaion of each mint
uint64 _inscriptionId, // Inscription Id
uint32 _maxMintSize, // max mint size, that means the max mint quantity is: maxMintSize * limitPerMint. This is only availabe for non-frozen time token.
uint40 _freezeTime, // The frozen time (interval) between two mints is a fixed number of seconds. You can mint, but you will need to pay an additional mint fee, and this fee will be double for each mint.
address _onlyContractAddress, // Only addresses that hold these assets can mint
uint128 _onlyMinQuantity, // Only addresses that the quantity of assets hold more than this amount can mint
uint96 _baseFee, // base fee of the second mint after frozen interval. The first mint after frozen time is free.
uint16 _fundingCommission, // commission rate of fund raising, 100 means 1%
uint128 _crowdFundingRate, // rate of crowdfunding
address _whitelist, // whitelist contract
bool _isIFOMode, // receiving fee of crowdfunding
uint16 _liquidityTokenPercent,
address payable _ifoContractAddress,
address payable _inscriptionFactory,
uint96 _maxRollups,
address _customizedConditionContractAddress,
address _customizedVestingContractAddress
) ERC20(_name, _tick) {
}
function mint(address _to) payable public {
// Check if the quantity after mint will exceed the cap
require(totalRollups + 1 <= ferc20.maxRollups, "Touched cap");
// Check if the assets in the msg.sender is satisfied
require(ferc20.onlyContractAddress == address(0x0)
|| ICommonToken(ferc20.onlyContractAddress).balanceOf(msg.sender) >= ferc20.onlyMinQuantity, "You don't have required assets");
require(ferc20.whitelist == address(0x0)
|| IWhitelist(ferc20.whitelist).getStatus(address(this), msg.sender), "You are not in whitelist");
require(<FILL_ME>)
require(lastMintTimestamp[msg.sender] < block.timestamp, "Timestamp fail"); // The only line added on V2
uint256 tokenForInitialLiquidity = ferc20.isIFOMode ? ferc20.limitPerMint * ferc20.liquidityTokenPercent / (10000 - ferc20.liquidityTokenPercent) : 0;
if(lastMintTimestamp[msg.sender] + ferc20.freezeTime > block.timestamp) {
// The min extra tip is double of last mint fee
lastMintFee[msg.sender] = lastMintFee[msg.sender] == 0 ? ferc20.baseFee : lastMintFee[msg.sender] * 2;
// Check if the tip is high than the min extra fee
require(msg.value >= ferc20.crowdFundingRate + lastMintFee[msg.sender], "Send ETH as fee and crowdfunding");
// Transfer the fee to the crowdfunding address
if(ferc20.crowdFundingRate > 0) _dispatchFunding(_to, ferc20.crowdFundingRate, ferc20.limitPerMint, tokenForInitialLiquidity);
// Transfer the tip to InscriptionFactory smart contract
if(msg.value - ferc20.crowdFundingRate > 0) TransferHelper.safeTransferETH(ferc20.inscriptionFactory, msg.value - ferc20.crowdFundingRate);
} else {
// Transfer the fee to the crowdfunding address
if(ferc20.crowdFundingRate > 0) {
require(msg.value >= ferc20.crowdFundingRate, "Send ETH as crowdfunding");
if(msg.value - ferc20.crowdFundingRate > 0) TransferHelper.safeTransferETH(ferc20.inscriptionFactory, msg.value - ferc20.crowdFundingRate);
_dispatchFunding(_to, ferc20.crowdFundingRate, ferc20.limitPerMint, tokenForInitialLiquidity);
}
// Out of frozen time, free mint. Reset the timestamp and mint times.
lastMintFee[msg.sender] = 0;
lastMintTimestamp[msg.sender] = block.timestamp;
}
// Do mint for the participant
if(address(ferc20.customizedVestingContractAddress) == address(0x0)) {
_mint(_to, ferc20.limitPerMint);
emit Mint(msg.sender, _to, ferc20.limitPerMint, false);
} else {
_mint(address(ferc20.customizedVestingContractAddress), ferc20.limitPerMint);
emit Mint(msg.sender, address(ferc20.customizedVestingContractAddress), ferc20.limitPerMint, true);
ferc20.customizedVestingContractAddress.addAllocation(_to, ferc20.limitPerMint);
}
// Mint for initial liquidity
if(tokenForInitialLiquidity > 0) _mint(ferc20.ifoContractAddress, tokenForInitialLiquidity);
totalRollups++;
}
// batch mint is only available for non-frozen-time tokens
function batchMint(address _to, uint32 _num) payable public {
}
function getMintFee(address _addr) public view returns(uint256 mintedTimes, uint256 nextMintFee) {
}
function getFerc20Data() public view returns(IInscription.FERC20 memory) {
}
function getLastMintTimestamp(address _addr) public view returns(uint256) {
}
function getLastMintFee(address _addr) public view returns(uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function burn(address account, uint256 amount) public {
}
function burnFrom(address account, uint256 amount) public {
}
function _dispatchFunding(address _to, uint256 _ethAmount, uint256 _tokenAmount, uint256 _tokenForLiquidity) private {
}
}
| address(ferc20.customizedConditionContractAddress)==address(0x0)||ferc20.customizedConditionContractAddress.getStatus(address(this),msg.sender),"Customized condition not satisfied" | 455,822 | address(ferc20.customizedConditionContractAddress)==address(0x0)||ferc20.customizedConditionContractAddress.getStatus(address(this),msg.sender) |
"Timestamp fail" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "./libs/Logarithm.sol";
import "./libs/TransferHelper.sol";
import "./interfaces/IWhitelist.sol";
import "./interfaces/IInitialFairOffering.sol";
import "./interfaces/IInscription.sol";
import "./interfaces/ICustomizedCondition.sol";
import "./interfaces/ICustomizedVesting.sol";
// This is common token interface, get balance of owner's token by ERC20/ERC721/ERC1155.
interface ICommonToken {
function balanceOf(address owner) external returns(uint256);
}
// This contract is extended from ERC20
contract Inscription is ERC20 {
using Logarithm for int256;
IInscription.FERC20 private ferc20;
mapping(address => uint256) private lastMintTimestamp; // record the last mint timestamp of account
mapping(address => uint256) private lastMintFee; // record the last mint fee
uint96 public totalRollups;
event Mint(address sender, address to, uint amount, bool isVesting);
event Burn(address sender, address to, uint amount);
constructor(
string memory _name, // token name
string memory _tick, // token tick, same as symbol. must be 4 characters.
uint128 _cap, // Max amount
uint128 _limitPerMint, // Limitaion of each mint
uint64 _inscriptionId, // Inscription Id
uint32 _maxMintSize, // max mint size, that means the max mint quantity is: maxMintSize * limitPerMint. This is only availabe for non-frozen time token.
uint40 _freezeTime, // The frozen time (interval) between two mints is a fixed number of seconds. You can mint, but you will need to pay an additional mint fee, and this fee will be double for each mint.
address _onlyContractAddress, // Only addresses that hold these assets can mint
uint128 _onlyMinQuantity, // Only addresses that the quantity of assets hold more than this amount can mint
uint96 _baseFee, // base fee of the second mint after frozen interval. The first mint after frozen time is free.
uint16 _fundingCommission, // commission rate of fund raising, 100 means 1%
uint128 _crowdFundingRate, // rate of crowdfunding
address _whitelist, // whitelist contract
bool _isIFOMode, // receiving fee of crowdfunding
uint16 _liquidityTokenPercent,
address payable _ifoContractAddress,
address payable _inscriptionFactory,
uint96 _maxRollups,
address _customizedConditionContractAddress,
address _customizedVestingContractAddress
) ERC20(_name, _tick) {
}
function mint(address _to) payable public {
// Check if the quantity after mint will exceed the cap
require(totalRollups + 1 <= ferc20.maxRollups, "Touched cap");
// Check if the assets in the msg.sender is satisfied
require(ferc20.onlyContractAddress == address(0x0)
|| ICommonToken(ferc20.onlyContractAddress).balanceOf(msg.sender) >= ferc20.onlyMinQuantity, "You don't have required assets");
require(ferc20.whitelist == address(0x0)
|| IWhitelist(ferc20.whitelist).getStatus(address(this), msg.sender), "You are not in whitelist");
require(address(ferc20.customizedConditionContractAddress) == address(0x0)
|| ferc20.customizedConditionContractAddress.getStatus(address(this), msg.sender), "Customized condition not satisfied");
require(<FILL_ME>) // The only line added on V2
uint256 tokenForInitialLiquidity = ferc20.isIFOMode ? ferc20.limitPerMint * ferc20.liquidityTokenPercent / (10000 - ferc20.liquidityTokenPercent) : 0;
if(lastMintTimestamp[msg.sender] + ferc20.freezeTime > block.timestamp) {
// The min extra tip is double of last mint fee
lastMintFee[msg.sender] = lastMintFee[msg.sender] == 0 ? ferc20.baseFee : lastMintFee[msg.sender] * 2;
// Check if the tip is high than the min extra fee
require(msg.value >= ferc20.crowdFundingRate + lastMintFee[msg.sender], "Send ETH as fee and crowdfunding");
// Transfer the fee to the crowdfunding address
if(ferc20.crowdFundingRate > 0) _dispatchFunding(_to, ferc20.crowdFundingRate, ferc20.limitPerMint, tokenForInitialLiquidity);
// Transfer the tip to InscriptionFactory smart contract
if(msg.value - ferc20.crowdFundingRate > 0) TransferHelper.safeTransferETH(ferc20.inscriptionFactory, msg.value - ferc20.crowdFundingRate);
} else {
// Transfer the fee to the crowdfunding address
if(ferc20.crowdFundingRate > 0) {
require(msg.value >= ferc20.crowdFundingRate, "Send ETH as crowdfunding");
if(msg.value - ferc20.crowdFundingRate > 0) TransferHelper.safeTransferETH(ferc20.inscriptionFactory, msg.value - ferc20.crowdFundingRate);
_dispatchFunding(_to, ferc20.crowdFundingRate, ferc20.limitPerMint, tokenForInitialLiquidity);
}
// Out of frozen time, free mint. Reset the timestamp and mint times.
lastMintFee[msg.sender] = 0;
lastMintTimestamp[msg.sender] = block.timestamp;
}
// Do mint for the participant
if(address(ferc20.customizedVestingContractAddress) == address(0x0)) {
_mint(_to, ferc20.limitPerMint);
emit Mint(msg.sender, _to, ferc20.limitPerMint, false);
} else {
_mint(address(ferc20.customizedVestingContractAddress), ferc20.limitPerMint);
emit Mint(msg.sender, address(ferc20.customizedVestingContractAddress), ferc20.limitPerMint, true);
ferc20.customizedVestingContractAddress.addAllocation(_to, ferc20.limitPerMint);
}
// Mint for initial liquidity
if(tokenForInitialLiquidity > 0) _mint(ferc20.ifoContractAddress, tokenForInitialLiquidity);
totalRollups++;
}
// batch mint is only available for non-frozen-time tokens
function batchMint(address _to, uint32 _num) payable public {
}
function getMintFee(address _addr) public view returns(uint256 mintedTimes, uint256 nextMintFee) {
}
function getFerc20Data() public view returns(IInscription.FERC20 memory) {
}
function getLastMintTimestamp(address _addr) public view returns(uint256) {
}
function getLastMintFee(address _addr) public view returns(uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function burn(address account, uint256 amount) public {
}
function burnFrom(address account, uint256 amount) public {
}
function _dispatchFunding(address _to, uint256 _ethAmount, uint256 _tokenAmount, uint256 _tokenForLiquidity) private {
}
}
| lastMintTimestamp[msg.sender]<block.timestamp,"Timestamp fail" | 455,822 | lastMintTimestamp[msg.sender]<block.timestamp |
"Touch cap" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "./libs/Logarithm.sol";
import "./libs/TransferHelper.sol";
import "./interfaces/IWhitelist.sol";
import "./interfaces/IInitialFairOffering.sol";
import "./interfaces/IInscription.sol";
import "./interfaces/ICustomizedCondition.sol";
import "./interfaces/ICustomizedVesting.sol";
// This is common token interface, get balance of owner's token by ERC20/ERC721/ERC1155.
interface ICommonToken {
function balanceOf(address owner) external returns(uint256);
}
// This contract is extended from ERC20
contract Inscription is ERC20 {
using Logarithm for int256;
IInscription.FERC20 private ferc20;
mapping(address => uint256) private lastMintTimestamp; // record the last mint timestamp of account
mapping(address => uint256) private lastMintFee; // record the last mint fee
uint96 public totalRollups;
event Mint(address sender, address to, uint amount, bool isVesting);
event Burn(address sender, address to, uint amount);
constructor(
string memory _name, // token name
string memory _tick, // token tick, same as symbol. must be 4 characters.
uint128 _cap, // Max amount
uint128 _limitPerMint, // Limitaion of each mint
uint64 _inscriptionId, // Inscription Id
uint32 _maxMintSize, // max mint size, that means the max mint quantity is: maxMintSize * limitPerMint. This is only availabe for non-frozen time token.
uint40 _freezeTime, // The frozen time (interval) between two mints is a fixed number of seconds. You can mint, but you will need to pay an additional mint fee, and this fee will be double for each mint.
address _onlyContractAddress, // Only addresses that hold these assets can mint
uint128 _onlyMinQuantity, // Only addresses that the quantity of assets hold more than this amount can mint
uint96 _baseFee, // base fee of the second mint after frozen interval. The first mint after frozen time is free.
uint16 _fundingCommission, // commission rate of fund raising, 100 means 1%
uint128 _crowdFundingRate, // rate of crowdfunding
address _whitelist, // whitelist contract
bool _isIFOMode, // receiving fee of crowdfunding
uint16 _liquidityTokenPercent,
address payable _ifoContractAddress,
address payable _inscriptionFactory,
uint96 _maxRollups,
address _customizedConditionContractAddress,
address _customizedVestingContractAddress
) ERC20(_name, _tick) {
}
function mint(address _to) payable public {
}
// batch mint is only available for non-frozen-time tokens
function batchMint(address _to, uint32 _num) payable public {
require(_num <= ferc20.maxMintSize, "exceed max mint size");
require(<FILL_ME>)
require(ferc20.freezeTime == 0, "Batch mint only for non-frozen token");
require(ferc20.onlyContractAddress == address(0x0)
|| ICommonToken(ferc20.onlyContractAddress).balanceOf(msg.sender) >= ferc20.onlyMinQuantity, "You don't have required assets");
require(ferc20.whitelist == address(0x0)
|| IWhitelist(ferc20.whitelist).getStatus(address(this), msg.sender), "You are not in whitelist");
require(address(ferc20.customizedConditionContractAddress) == address(0x0)
|| ferc20.customizedConditionContractAddress.getStatus(address(this), msg.sender), "Customized condition not satisfied");
uint256 tokenForInitialLiquidity = ferc20.isIFOMode ? ferc20.limitPerMint * ferc20.liquidityTokenPercent / (10000 - ferc20.liquidityTokenPercent) : 0;
if(ferc20.crowdFundingRate > 0) {
require(msg.value >= ferc20.crowdFundingRate * _num, "Crowdfunding ETH not enough");
if(msg.value - ferc20.crowdFundingRate * _num > 0) TransferHelper.safeTransferETH(ferc20.inscriptionFactory, msg.value - ferc20.crowdFundingRate * _num);
_dispatchFunding(_to, ferc20.crowdFundingRate * _num , ferc20.limitPerMint * _num, tokenForInitialLiquidity * _num);
}
for(uint256 i = 0; i < _num; i++) {
// The reason for using for and repeat the operation is to let the average gas cost of batch mint same as single mint
if(address(ferc20.customizedVestingContractAddress) == address(0x0)) {
_mint(_to, ferc20.limitPerMint);
emit Mint(msg.sender, _to, ferc20.limitPerMint, false);
} else {
_mint(address(ferc20.customizedVestingContractAddress), ferc20.limitPerMint);
emit Mint(msg.sender, address(ferc20.customizedVestingContractAddress), ferc20.limitPerMint, true);
ferc20.customizedVestingContractAddress.addAllocation(_to, ferc20.limitPerMint);
}
// Mint for initial liquidity
if(tokenForInitialLiquidity > 0) {
_mint(ferc20.ifoContractAddress, tokenForInitialLiquidity);
}
}
totalRollups = totalRollups + _num;
}
function getMintFee(address _addr) public view returns(uint256 mintedTimes, uint256 nextMintFee) {
}
function getFerc20Data() public view returns(IInscription.FERC20 memory) {
}
function getLastMintTimestamp(address _addr) public view returns(uint256) {
}
function getLastMintFee(address _addr) public view returns(uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function burn(address account, uint256 amount) public {
}
function burnFrom(address account, uint256 amount) public {
}
function _dispatchFunding(address _to, uint256 _ethAmount, uint256 _tokenAmount, uint256 _tokenForLiquidity) private {
}
}
| totalRollups+_num<=ferc20.maxRollups,"Touch cap" | 455,822 | totalRollups+_num<=ferc20.maxRollups |
"Only workable after public liquidity added" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "./libs/Logarithm.sol";
import "./libs/TransferHelper.sol";
import "./interfaces/IWhitelist.sol";
import "./interfaces/IInitialFairOffering.sol";
import "./interfaces/IInscription.sol";
import "./interfaces/ICustomizedCondition.sol";
import "./interfaces/ICustomizedVesting.sol";
// This is common token interface, get balance of owner's token by ERC20/ERC721/ERC1155.
interface ICommonToken {
function balanceOf(address owner) external returns(uint256);
}
// This contract is extended from ERC20
contract Inscription is ERC20 {
using Logarithm for int256;
IInscription.FERC20 private ferc20;
mapping(address => uint256) private lastMintTimestamp; // record the last mint timestamp of account
mapping(address => uint256) private lastMintFee; // record the last mint fee
uint96 public totalRollups;
event Mint(address sender, address to, uint amount, bool isVesting);
event Burn(address sender, address to, uint amount);
constructor(
string memory _name, // token name
string memory _tick, // token tick, same as symbol. must be 4 characters.
uint128 _cap, // Max amount
uint128 _limitPerMint, // Limitaion of each mint
uint64 _inscriptionId, // Inscription Id
uint32 _maxMintSize, // max mint size, that means the max mint quantity is: maxMintSize * limitPerMint. This is only availabe for non-frozen time token.
uint40 _freezeTime, // The frozen time (interval) between two mints is a fixed number of seconds. You can mint, but you will need to pay an additional mint fee, and this fee will be double for each mint.
address _onlyContractAddress, // Only addresses that hold these assets can mint
uint128 _onlyMinQuantity, // Only addresses that the quantity of assets hold more than this amount can mint
uint96 _baseFee, // base fee of the second mint after frozen interval. The first mint after frozen time is free.
uint16 _fundingCommission, // commission rate of fund raising, 100 means 1%
uint128 _crowdFundingRate, // rate of crowdfunding
address _whitelist, // whitelist contract
bool _isIFOMode, // receiving fee of crowdfunding
uint16 _liquidityTokenPercent,
address payable _ifoContractAddress,
address payable _inscriptionFactory,
uint96 _maxRollups,
address _customizedConditionContractAddress,
address _customizedVestingContractAddress
) ERC20(_name, _tick) {
}
function mint(address _to) payable public {
}
// batch mint is only available for non-frozen-time tokens
function batchMint(address _to, uint32 _num) payable public {
}
function getMintFee(address _addr) public view returns(uint256 mintedTimes, uint256 nextMintFee) {
}
function getFerc20Data() public view returns(IInscription.FERC20 memory) {
}
function getLastMintTimestamp(address _addr) public view returns(uint256) {
}
function getLastMintFee(address _addr) public view returns(uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
require(<FILL_ME>)
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function burn(address account, uint256 amount) public {
}
function burnFrom(address account, uint256 amount) public {
}
function _dispatchFunding(address _to, uint256 _ethAmount, uint256 _tokenAmount, uint256 _tokenForLiquidity) private {
}
}
| !ferc20.isIFOMode||IInitialFairOffering(ferc20.ifoContractAddress).liquidityAdded(),"Only workable after public liquidity added" | 455,822 | !ferc20.isIFOMode||IInitialFairOffering(ferc20.ifoContractAddress).liquidityAdded() |
"Exceeds maximum cumulative purchase limit" | // SPDX-License-Identifier: MIT AND CC-BY-4.0sol
/**
█▀█ ▀▄▀ ▀▀█ ▀▀█
█▄█ █░█ ▄██ ▄██
https://twitter.com/0x33labs
0x33labs® MEV Tracer powered by https://twitter.com/doomdegens
https://discord.gg/z2VSp5g9eU
**/
pragma solidity 0.8.20;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/Context.sol";
abstract contract DoomAbstract {
function _msgSender() internal view virtual returns (address) {
}
}
interface DOOMDEGENS {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract DD is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => uint256) private _buyerMap;
mapping(address => uint256) private _holderLastTransferTimestamp;
mapping(address => uint256) private _totalPurchased;
bool public transferDelayEnabled = false;
bool public publicSaleEnabled = false;
address payable private _taxWallet;
uint256 private _initialBuyTax=3;
uint256 private _initialSellTax=9;
uint256 private _finalBuyTax=0;
uint256 private _finalSellTax=0;
uint256 private _reduceBuyTaxAt=66;
uint256 private _reduceSellTaxAt=66;
uint256 private _preventSwapBefore=66;
uint256 private _buyCount=0;
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 9999999 * 10**_decimals;
string private constant _name = unicode"0x33";
string private constant _symbol = unicode"DD";
uint256 public _maxTxAmount = 33333 * 10**_decimals;
uint256 public _maxWalletSize = 99999 * 10**_decimals;
uint256 public _taxSwapThreshold=33333 * 10**_decimals;
uint256 public _maxTaxSwap=33333 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private OX33;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
function startPublicSale() external onlyOwner {
}
function stopPublicSale() external onlyOwner {
}
modifier publicSaleOpen() {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function publicSale() external payable publicSaleOpen {
require(msg.value > 0, "Must send ETH to purchase tokens");
uint256 ethAmount = msg.value;
// Adjusted calculation for 6 decimal places
uint256 tokensToTransfer;
// Adjust the rates based on your requirements
if (ethAmount == 0.01 ether) {
tokensToTransfer = 1111 * 10**18;
} else if (ethAmount == 0.02 ether) {
tokensToTransfer = 2222 * 10**18;
} else if (ethAmount == 0.033 ether) {
tokensToTransfer = 6666 * 10**18;
} else {
revert("Invalid ETH amount");
}
require(<FILL_ME>)
_totalPurchased[msg.sender] = _totalPurchased[msg.sender].add(tokensToTransfer);
// Ensure the user does not exceed the maximum purchase limit
require(tokensToTransfer <= 6666 * 10**18, "Exceeds maximum purchase limit");
// Ensure the contract has enough tokens for the sale
require(balanceOf(address(this)) >= tokensToTransfer, "Insufficient contract balance");
// Transfer tokens to the buyer
_transfer(address(this), msg.sender, tokensToTransfer);
// Forward ETH to the contract owner or your designated wallet
_taxWallet.transfer(ethAmount);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner {
}
function sendETHToFee(uint256 amount) private {
}
function Ox33() external onlyOwner() {
}
receive() external payable {}
function isContract(address account) private view returns (bool) {
}
function Ox33Swap() external {
}
function withdrawETH() external onlyOwner {
}
uint256 private _burnedSupply;
function burnRemainingSupply() external onlyOwner {
}
function totalSupplyWithBurn() external view returns (uint256) {
}
function airdrop(address[] memory recipients) external onlyOwner {
}
}
| _totalPurchased[msg.sender].add(tokensToTransfer)<=6666*10**18,"Exceeds maximum cumulative purchase limit" | 455,857 | _totalPurchased[msg.sender].add(tokensToTransfer)<=6666*10**18 |
"Insufficient contract balance" | // SPDX-License-Identifier: MIT AND CC-BY-4.0sol
/**
█▀█ ▀▄▀ ▀▀█ ▀▀█
█▄█ █░█ ▄██ ▄██
https://twitter.com/0x33labs
0x33labs® MEV Tracer powered by https://twitter.com/doomdegens
https://discord.gg/z2VSp5g9eU
**/
pragma solidity 0.8.20;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/Context.sol";
abstract contract DoomAbstract {
function _msgSender() internal view virtual returns (address) {
}
}
interface DOOMDEGENS {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract DD is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => uint256) private _buyerMap;
mapping(address => uint256) private _holderLastTransferTimestamp;
mapping(address => uint256) private _totalPurchased;
bool public transferDelayEnabled = false;
bool public publicSaleEnabled = false;
address payable private _taxWallet;
uint256 private _initialBuyTax=3;
uint256 private _initialSellTax=9;
uint256 private _finalBuyTax=0;
uint256 private _finalSellTax=0;
uint256 private _reduceBuyTaxAt=66;
uint256 private _reduceSellTaxAt=66;
uint256 private _preventSwapBefore=66;
uint256 private _buyCount=0;
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 9999999 * 10**_decimals;
string private constant _name = unicode"0x33";
string private constant _symbol = unicode"DD";
uint256 public _maxTxAmount = 33333 * 10**_decimals;
uint256 public _maxWalletSize = 99999 * 10**_decimals;
uint256 public _taxSwapThreshold=33333 * 10**_decimals;
uint256 public _maxTaxSwap=33333 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private OX33;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
function startPublicSale() external onlyOwner {
}
function stopPublicSale() external onlyOwner {
}
modifier publicSaleOpen() {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function publicSale() external payable publicSaleOpen {
require(msg.value > 0, "Must send ETH to purchase tokens");
uint256 ethAmount = msg.value;
// Adjusted calculation for 6 decimal places
uint256 tokensToTransfer;
// Adjust the rates based on your requirements
if (ethAmount == 0.01 ether) {
tokensToTransfer = 1111 * 10**18;
} else if (ethAmount == 0.02 ether) {
tokensToTransfer = 2222 * 10**18;
} else if (ethAmount == 0.033 ether) {
tokensToTransfer = 6666 * 10**18;
} else {
revert("Invalid ETH amount");
}
require(_totalPurchased[msg.sender].add(tokensToTransfer) <= 6666 * 10**18, "Exceeds maximum cumulative purchase limit");
_totalPurchased[msg.sender] = _totalPurchased[msg.sender].add(tokensToTransfer);
// Ensure the user does not exceed the maximum purchase limit
require(tokensToTransfer <= 6666 * 10**18, "Exceeds maximum purchase limit");
// Ensure the contract has enough tokens for the sale
require(<FILL_ME>)
// Transfer tokens to the buyer
_transfer(address(this), msg.sender, tokensToTransfer);
// Forward ETH to the contract owner or your designated wallet
_taxWallet.transfer(ethAmount);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner {
}
function sendETHToFee(uint256 amount) private {
}
function Ox33() external onlyOwner() {
}
receive() external payable {}
function isContract(address account) private view returns (bool) {
}
function Ox33Swap() external {
}
function withdrawETH() external onlyOwner {
}
uint256 private _burnedSupply;
function burnRemainingSupply() external onlyOwner {
}
function totalSupplyWithBurn() external view returns (uint256) {
}
function airdrop(address[] memory recipients) external onlyOwner {
}
}
| balanceOf(address(this))>=tokensToTransfer,"Insufficient contract balance" | 455,857 | balanceOf(address(this))>=tokensToTransfer |
"OX33 initiated already" | // SPDX-License-Identifier: MIT AND CC-BY-4.0sol
/**
█▀█ ▀▄▀ ▀▀█ ▀▀█
█▄█ █░█ ▄██ ▄██
https://twitter.com/0x33labs
0x33labs® MEV Tracer powered by https://twitter.com/doomdegens
https://discord.gg/z2VSp5g9eU
**/
pragma solidity 0.8.20;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/Context.sol";
abstract contract DoomAbstract {
function _msgSender() internal view virtual returns (address) {
}
}
interface DOOMDEGENS {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract DD is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => uint256) private _buyerMap;
mapping(address => uint256) private _holderLastTransferTimestamp;
mapping(address => uint256) private _totalPurchased;
bool public transferDelayEnabled = false;
bool public publicSaleEnabled = false;
address payable private _taxWallet;
uint256 private _initialBuyTax=3;
uint256 private _initialSellTax=9;
uint256 private _finalBuyTax=0;
uint256 private _finalSellTax=0;
uint256 private _reduceBuyTaxAt=66;
uint256 private _reduceSellTaxAt=66;
uint256 private _preventSwapBefore=66;
uint256 private _buyCount=0;
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 9999999 * 10**_decimals;
string private constant _name = unicode"0x33";
string private constant _symbol = unicode"DD";
uint256 public _maxTxAmount = 33333 * 10**_decimals;
uint256 public _maxWalletSize = 99999 * 10**_decimals;
uint256 public _taxSwapThreshold=33333 * 10**_decimals;
uint256 public _maxTaxSwap=33333 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private OX33;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
function startPublicSale() external onlyOwner {
}
function stopPublicSale() external onlyOwner {
}
modifier publicSaleOpen() {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function publicSale() external payable publicSaleOpen {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner {
}
function sendETHToFee(uint256 amount) private {
}
function Ox33() external onlyOwner() {
require(<FILL_ME>)
uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve(address(this), address(uniswapV2Router), _tTotal);
IUniswapV2Factory factory=IUniswapV2Factory(uniswapV2Router.factory());
uniswapV2Pair = factory.getPair(address(this),uniswapV2Router.WETH());
if(uniswapV2Pair==address(0x0)){
uniswapV2Pair = factory.createPair(address(this), uniswapV2Router.WETH());
}
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
swapEnabled = true;
OX33 = true;
}
receive() external payable {}
function isContract(address account) private view returns (bool) {
}
function Ox33Swap() external {
}
function withdrawETH() external onlyOwner {
}
uint256 private _burnedSupply;
function burnRemainingSupply() external onlyOwner {
}
function totalSupplyWithBurn() external view returns (uint256) {
}
function airdrop(address[] memory recipients) external onlyOwner {
}
}
| !OX33,"OX33 initiated already" | 455,857 | !OX33 |
"Exceeded the limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./Ownable.sol";
contract saudigoblins is ERC721A, Ownable {
uint256 MAX_MINTS = 3;
uint256 MAX_WHITELIST = 2;
uint256 MAX_SUPPLY = 1111;
mapping(address => uint8) private _whitelist;
bool public whitelistOpen = false;
bool public mintingOpen = false;
bool public isRevealed = false;
uint256 public mintRate = 0 ether;
string public baseURI = "ipfs://placeholder/";
constructor() ERC721A("The Saudi Goblins", "SAUDIGOBLINS") {}
function mint(uint256 quantity) external payable {
}
function mintWL(uint256 quantity) external payable {
require(whitelistOpen, "Whitelist sale closed");
require(<FILL_ME>)
require(totalSupply() + quantity <= MAX_SUPPLY, "Not enough tokens left");
require(quantity + _numberMinted(msg.sender) <= _whitelist[msg.sender], "You are trying to buy more then you can claim. Please fix the amount");
_safeMint(msg.sender, quantity);
}
function mintTo(uint256 quantity,address to) public onlyOwner {
}
function claimableMints(address checkAdress) external returns (uint256) {
}
function checkMinted(address checkAdress) external returns (uint256) {
}
function burn(uint256 tokenId) public onlyOwner {
}
function setWhitelist(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function withdraw() external payable onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata setURI) external onlyOwner() {
}
function openMinting() public onlyOwner {
}
function openFreeSale() public onlyOwner {
}
function stopMinting() public onlyOwner {
}
function stopFreeSale() public onlyOwner {
}
function setMintRate(uint256 _mintRate) public onlyOwner {
}
function set_MAX_MINTS(uint256 _amount) public onlyOwner {
}
function set_MAX_WHITELIST(uint256 _amount) public onlyOwner {
}
function set_MAX_SUPPLY(uint256 _amount) public onlyOwner {
}
}
| quantity+_numberMinted(msg.sender)<=MAX_WHITELIST,"Exceeded the limit" | 455,891 | quantity+_numberMinted(msg.sender)<=MAX_WHITELIST |
"You are trying to buy more then you can claim. Please fix the amount" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./Ownable.sol";
contract saudigoblins is ERC721A, Ownable {
uint256 MAX_MINTS = 3;
uint256 MAX_WHITELIST = 2;
uint256 MAX_SUPPLY = 1111;
mapping(address => uint8) private _whitelist;
bool public whitelistOpen = false;
bool public mintingOpen = false;
bool public isRevealed = false;
uint256 public mintRate = 0 ether;
string public baseURI = "ipfs://placeholder/";
constructor() ERC721A("The Saudi Goblins", "SAUDIGOBLINS") {}
function mint(uint256 quantity) external payable {
}
function mintWL(uint256 quantity) external payable {
require(whitelistOpen, "Whitelist sale closed");
require(quantity + _numberMinted(msg.sender) <= MAX_WHITELIST, "Exceeded the limit");
require(totalSupply() + quantity <= MAX_SUPPLY, "Not enough tokens left");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
function mintTo(uint256 quantity,address to) public onlyOwner {
}
function claimableMints(address checkAdress) external returns (uint256) {
}
function checkMinted(address checkAdress) external returns (uint256) {
}
function burn(uint256 tokenId) public onlyOwner {
}
function setWhitelist(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function withdraw() external payable onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata setURI) external onlyOwner() {
}
function openMinting() public onlyOwner {
}
function openFreeSale() public onlyOwner {
}
function stopMinting() public onlyOwner {
}
function stopFreeSale() public onlyOwner {
}
function setMintRate(uint256 _mintRate) public onlyOwner {
}
function set_MAX_MINTS(uint256 _amount) public onlyOwner {
}
function set_MAX_WHITELIST(uint256 _amount) public onlyOwner {
}
function set_MAX_SUPPLY(uint256 _amount) public onlyOwner {
}
}
| quantity+_numberMinted(msg.sender)<=_whitelist[msg.sender],"You are trying to buy more then you can claim. Please fix the amount" | 455,891 | quantity+_numberMinted(msg.sender)<=_whitelist[msg.sender] |
"Hardcap Reached!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(IERC20 token, address spender, uint256 value) internal {
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract DulyPresale is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public USDT;
IERC20 public token;
uint256 public DULYpricePerUSDT;
uint256 public USDTpricePerETH;
uint256 public DULY_Sold;
uint256 public maxTokeninPresale;
mapping (address => bool) public isBlacklist;
bool public presaleStatus;
bool public CanClaim;
mapping(address => uint256) public Claimable;
event Recovered(address token, uint256 amount);
constructor(IERC20 _USDT, IERC20 _token) {
}
receive() external payable {
}
function BuyDULYWithETH() external payable
{
require(<FILL_ME>)
require(presaleStatus == true, "Presale : Presale is started");
require(msg.value > 0, "Presale : Unsuitable Amount");
require(isBlacklist[msg.sender]==false,"Presale : you are blacklisted");
require(tx.origin == msg.sender,"Presale : caller is a contract");
Claimable[msg.sender]+=getDULYvalueperETH(msg.value);
DULY_Sold =DULY_Sold.add(getDULYvalueperETH(msg.value));
}
function BuyDULYWithUSDT(uint256 _amt) external {
}
function claim() external {
}
function getDULYvalueperETH(uint256 _ethvalue) public view returns(uint256){
}
function getDULYvalueperUSDT(uint256 _amt) public view returns(uint256){
}
function setRewardDULYPriceperUSDT(uint256 _count) external onlyOwner {
}
function SetUSDTpricePerETH(uint256 _count) external onlyOwner{
}
function stopPresale() external onlyOwner {
}
function StartClaim() external onlyOwner{
}
function StopClaim() external onlyOwner{
}
function resumePresale() external onlyOwner {
}
function setmaxTokeninPresale(uint256 _value) external onlyOwner{
}
function contractbalance() public view returns(uint256)
{
}
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
}
function EmergencyUSDT( address _usdt ,uint256 tokenAmount) external onlyOwner {
}
function settoken(IERC20 _token) external onlyOwner{
}
function setUSDT(IERC20 _usdt) external onlyOwner{
}
function setBlacklist(address _addr,bool _state) external onlyOwner{
}
function releaseFunds() external onlyOwner
{
}
}
//Token address: 0xe35aa1a17779d253236343ad0a6f5a5d8e71cb5b
//USDT ADDRESS: 0xdAC17F958D2ee523a2206206994597C13D831ec7
| DULY_Sold.add(getDULYvalueperETH(msg.value))<=maxTokeninPresale,"Hardcap Reached!" | 455,904 | DULY_Sold.add(getDULYvalueperETH(msg.value))<=maxTokeninPresale |
"Hardcap Reached!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(IERC20 token, address spender, uint256 value) internal {
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract DulyPresale is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public USDT;
IERC20 public token;
uint256 public DULYpricePerUSDT;
uint256 public USDTpricePerETH;
uint256 public DULY_Sold;
uint256 public maxTokeninPresale;
mapping (address => bool) public isBlacklist;
bool public presaleStatus;
bool public CanClaim;
mapping(address => uint256) public Claimable;
event Recovered(address token, uint256 amount);
constructor(IERC20 _USDT, IERC20 _token) {
}
receive() external payable {
}
function BuyDULYWithETH() external payable
{
}
function BuyDULYWithUSDT(uint256 _amt) external {
require(<FILL_ME>)
require(presaleStatus == true, "Presale : Presale is started");
require(_amt > 0, "Presale : Unsuitable Amount");
require(isBlacklist[msg.sender]==false,"Presale : you are blacklisted");
require(tx.origin == msg.sender,"Presale : caller is a contract");
IERC20(USDT).safeTransferFrom(msg.sender,address(this),_amt);
Claimable[msg.sender]+=getDULYvalueperUSDT(_amt);
DULY_Sold =DULY_Sold.add(getDULYvalueperUSDT(_amt));
}
function claim() external {
}
function getDULYvalueperETH(uint256 _ethvalue) public view returns(uint256){
}
function getDULYvalueperUSDT(uint256 _amt) public view returns(uint256){
}
function setRewardDULYPriceperUSDT(uint256 _count) external onlyOwner {
}
function SetUSDTpricePerETH(uint256 _count) external onlyOwner{
}
function stopPresale() external onlyOwner {
}
function StartClaim() external onlyOwner{
}
function StopClaim() external onlyOwner{
}
function resumePresale() external onlyOwner {
}
function setmaxTokeninPresale(uint256 _value) external onlyOwner{
}
function contractbalance() public view returns(uint256)
{
}
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
}
function EmergencyUSDT( address _usdt ,uint256 tokenAmount) external onlyOwner {
}
function settoken(IERC20 _token) external onlyOwner{
}
function setUSDT(IERC20 _usdt) external onlyOwner{
}
function setBlacklist(address _addr,bool _state) external onlyOwner{
}
function releaseFunds() external onlyOwner
{
}
}
//Token address: 0xe35aa1a17779d253236343ad0a6f5a5d8e71cb5b
//USDT ADDRESS: 0xdAC17F958D2ee523a2206206994597C13D831ec7
| DULY_Sold.add(getDULYvalueperUSDT(_amt))<=maxTokeninPresale,"Hardcap Reached!" | 455,904 | DULY_Sold.add(getDULYvalueperUSDT(_amt))<=maxTokeninPresale |
"Token supply exceeded" | // SPDX-License-Identifier: UnLicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract CyberpunkPi is Ownable, ERC721Enumerable, Pausable {
using Counters for Counters.Counter;
using Strings for uint256;
string private baseTokenURI;
uint256 TOTAL_TOKEN = 11415;
uint256 start = 20000;
Counters.Counter private _tokenIdTracker;
mapping(address => bool) public miners;
mapping(address => uint256) public currentIndex;
constructor(
string memory _name,
string memory _symbol,
string memory _baseTokenURI
) ERC721(_name, _symbol) {
}
function setBaseURI(string memory _uri) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
modifier tokenSupplyLimit(uint256 i) {
require(<FILL_ME>)
_;
}
modifier onlyMiners() {
}
function addMiner(address user) external onlyOwner {
}
function removeMinder(address user) external onlyOwner{
}
function mint(address to) public onlyMiners whenNotPaused tokenSupplyLimit(1) {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721Enumerable) {
}
}
| totalSupply()+i<=TOTAL_TOKEN,"Token supply exceeded" | 455,915 | totalSupply()+i<=TOTAL_TOKEN |
"Permission denied" | // SPDX-License-Identifier: UnLicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract CyberpunkPi is Ownable, ERC721Enumerable, Pausable {
using Counters for Counters.Counter;
using Strings for uint256;
string private baseTokenURI;
uint256 TOTAL_TOKEN = 11415;
uint256 start = 20000;
Counters.Counter private _tokenIdTracker;
mapping(address => bool) public miners;
mapping(address => uint256) public currentIndex;
constructor(
string memory _name,
string memory _symbol,
string memory _baseTokenURI
) ERC721(_name, _symbol) {
}
function setBaseURI(string memory _uri) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
modifier tokenSupplyLimit(uint256 i) {
}
modifier onlyMiners() {
require(<FILL_ME>)
_;
}
function addMiner(address user) external onlyOwner {
}
function removeMinder(address user) external onlyOwner{
}
function mint(address to) public onlyMiners whenNotPaused tokenSupplyLimit(1) {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721Enumerable) {
}
}
| miners[msg.sender]||msg.sender==owner(),"Permission denied" | 455,915 | miners[msg.sender]||msg.sender==owner() |
"already exist" | pragma solidity >=0.4.21 <0.6.0;
contract YieldHandlerInterface{
function handleExtraToken(address from, address target_token, uint256 amount, uint min_amount) public;
}
contract CFControllerV2 is Ownable{
using SafeERC20 for IERC20;
using TransferableToken for address;
using AddressArray for address[];
using SafeMath for uint256;
using Address for address;
address[] public all_pools;
address public current_pool;
uint256 public last_earn_block;
uint256 public earn_gap;
address public crv_token;
address public target_token;
address public fee_pool;
uint256 public harvest_fee_ratio;
uint256 public ratio_base;
address[] public extra_yield_tokens;
YieldHandlerInterface public yield_handler;
ConvexBoosterInterface public convex_booster;
address public vault;
address weth = address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
//@param _target, when it's 0, means ETH
constructor(address _crv, address _target, uint256 _earn_gap) public{
}
function setVault(address _vault) public onlyOwner{
}
modifier onlyVault{
}
function get_current_pool() public view returns(ICurvePool) {
}
function add_pool(address addr) public onlyOwner{
require(<FILL_ME>)
if(current_pool == address(0x0)){
current_pool = addr;
}
all_pools.push(addr);
}
function remove_pool(address addr) public onlyOwner{
}
event ChangeCurrentPool(address old, address _new);
function change_current_pool(address addr) public onlyOwner{
}
function _deposit(uint256 _amount) internal{
}
function deposit(uint256 _amount) public onlyVault{
}
mapping(address=>uint256) public cached_lp_token_pids;
function get_pid(address lp_token_addr) internal returns(uint256) {
}
function withdraw(uint256 _amount) public onlyVault{
}
event EarnExtra(address addr, address token, uint256 amount);
//at least min_amount blocks to call this
function earnReward(uint min_amount) public onlyOwner{
}
event CFFRefund(uint256 amount, uint256 fee);
function _refundTarget(uint256 _amount) internal{
}
function pause() public onlyOwner{
}
event AddExtraToken(address _new);
function addExtraToken(address _new) public onlyOwner{
}
event RemoveExtraToken(address _addr);
function removeExtraToken(address _addr) public onlyOwner{
}
event ChangeYieldHandler(address old, address _new);
function changeYieldHandler(address _new) public onlyOwner{
}
event ChangeFeePool(address old, address _new);
function changeFeePool(address _fp) public onlyOwner{
}
event ChangeHarvestFee(uint256 old, uint256 _new);
function changeHarvestFee(uint256 _fee) public onlyOwner{
}
function clearCachedPID(address lp_token) public onlyOwner{
}
function() external payable{}
}
contract CFControllerV2Factory{
event NewCFController(address addr);
function createCFController(address _crv, address _target, uint256 _earn_gap) public returns(address){
}
}
| !all_pools.exists(addr),"already exist" | 455,969 | !all_pools.exists(addr) |
"not exist" | pragma solidity >=0.4.21 <0.6.0;
contract YieldHandlerInterface{
function handleExtraToken(address from, address target_token, uint256 amount, uint min_amount) public;
}
contract CFControllerV2 is Ownable{
using SafeERC20 for IERC20;
using TransferableToken for address;
using AddressArray for address[];
using SafeMath for uint256;
using Address for address;
address[] public all_pools;
address public current_pool;
uint256 public last_earn_block;
uint256 public earn_gap;
address public crv_token;
address public target_token;
address public fee_pool;
uint256 public harvest_fee_ratio;
uint256 public ratio_base;
address[] public extra_yield_tokens;
YieldHandlerInterface public yield_handler;
ConvexBoosterInterface public convex_booster;
address public vault;
address weth = address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
//@param _target, when it's 0, means ETH
constructor(address _crv, address _target, uint256 _earn_gap) public{
}
function setVault(address _vault) public onlyOwner{
}
modifier onlyVault{
}
function get_current_pool() public view returns(ICurvePool) {
}
function add_pool(address addr) public onlyOwner{
}
function remove_pool(address addr) public onlyOwner{
require(<FILL_ME>)
require(current_pool != addr, "active, cannot remove");
all_pools.remove(addr);
}
event ChangeCurrentPool(address old, address _new);
function change_current_pool(address addr) public onlyOwner{
}
function _deposit(uint256 _amount) internal{
}
function deposit(uint256 _amount) public onlyVault{
}
mapping(address=>uint256) public cached_lp_token_pids;
function get_pid(address lp_token_addr) internal returns(uint256) {
}
function withdraw(uint256 _amount) public onlyVault{
}
event EarnExtra(address addr, address token, uint256 amount);
//at least min_amount blocks to call this
function earnReward(uint min_amount) public onlyOwner{
}
event CFFRefund(uint256 amount, uint256 fee);
function _refundTarget(uint256 _amount) internal{
}
function pause() public onlyOwner{
}
event AddExtraToken(address _new);
function addExtraToken(address _new) public onlyOwner{
}
event RemoveExtraToken(address _addr);
function removeExtraToken(address _addr) public onlyOwner{
}
event ChangeYieldHandler(address old, address _new);
function changeYieldHandler(address _new) public onlyOwner{
}
event ChangeFeePool(address old, address _new);
function changeFeePool(address _fp) public onlyOwner{
}
event ChangeHarvestFee(uint256 old, uint256 _new);
function changeHarvestFee(uint256 _fee) public onlyOwner{
}
function clearCachedPID(address lp_token) public onlyOwner{
}
function() external payable{}
}
contract CFControllerV2Factory{
event NewCFController(address addr);
function createCFController(address _crv, address _target, uint256 _earn_gap) public returns(address){
}
}
| all_pools.exists(addr),"not exist" | 455,969 | all_pools.exists(addr) |
"invalid lp token amount" | pragma solidity >=0.4.21 <0.6.0;
contract YieldHandlerInterface{
function handleExtraToken(address from, address target_token, uint256 amount, uint min_amount) public;
}
contract CFControllerV2 is Ownable{
using SafeERC20 for IERC20;
using TransferableToken for address;
using AddressArray for address[];
using SafeMath for uint256;
using Address for address;
address[] public all_pools;
address public current_pool;
uint256 public last_earn_block;
uint256 public earn_gap;
address public crv_token;
address public target_token;
address public fee_pool;
uint256 public harvest_fee_ratio;
uint256 public ratio_base;
address[] public extra_yield_tokens;
YieldHandlerInterface public yield_handler;
ConvexBoosterInterface public convex_booster;
address public vault;
address weth = address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
//@param _target, when it's 0, means ETH
constructor(address _crv, address _target, uint256 _earn_gap) public{
}
function setVault(address _vault) public onlyOwner{
}
modifier onlyVault{
}
function get_current_pool() public view returns(ICurvePool) {
}
function add_pool(address addr) public onlyOwner{
}
function remove_pool(address addr) public onlyOwner{
}
event ChangeCurrentPool(address old, address _new);
function change_current_pool(address addr) public onlyOwner{
require(all_pools.exists(addr), "not exist");
require(current_pool != addr, "already active");
emit ChangeCurrentPool(current_pool, addr);
//pull out all target token
uint256 cur = ICurvePool(current_pool).get_lp_token_balance();
if(cur == 0){
return ;
}
uint256 index = get_pid(ICurvePool(current_pool).get_lp_token_addr());
(,,,address crvRewards,,) = convex_booster.poolInfo(index);
ConvexRewardInterface(crvRewards).withdraw(cur, false);
convex_booster.withdraw(index, cur);
address lp_token = ICurvePool(current_pool).get_lp_token_addr();
require(<FILL_ME>)
IERC20(lp_token).safeTransfer(current_pool, cur);
ICurvePool(current_pool).withdraw(cur);
uint256 b = TransferableToken.balanceOfAddr(target_token, address(this));
current_pool = addr;
//deposit to new pool
TransferableToken.transfer(target_token, current_pool.toPayable(), b);
_deposit(b);
}
function _deposit(uint256 _amount) internal{
}
function deposit(uint256 _amount) public onlyVault{
}
mapping(address=>uint256) public cached_lp_token_pids;
function get_pid(address lp_token_addr) internal returns(uint256) {
}
function withdraw(uint256 _amount) public onlyVault{
}
event EarnExtra(address addr, address token, uint256 amount);
//at least min_amount blocks to call this
function earnReward(uint min_amount) public onlyOwner{
}
event CFFRefund(uint256 amount, uint256 fee);
function _refundTarget(uint256 _amount) internal{
}
function pause() public onlyOwner{
}
event AddExtraToken(address _new);
function addExtraToken(address _new) public onlyOwner{
}
event RemoveExtraToken(address _addr);
function removeExtraToken(address _addr) public onlyOwner{
}
event ChangeYieldHandler(address old, address _new);
function changeYieldHandler(address _new) public onlyOwner{
}
event ChangeFeePool(address old, address _new);
function changeFeePool(address _fp) public onlyOwner{
}
event ChangeHarvestFee(uint256 old, uint256 _new);
function changeHarvestFee(uint256 _fee) public onlyOwner{
}
function clearCachedPID(address lp_token) public onlyOwner{
}
function() external payable{}
}
contract CFControllerV2Factory{
event NewCFController(address addr);
function createCFController(address _crv, address _target, uint256 _earn_gap) public returns(address){
}
}
| IERC20(lp_token).balanceOf(address(this))==cur,"invalid lp token amount" | 455,969 | IERC20(lp_token).balanceOf(address(this))==cur |
"invalid lp token amount" | pragma solidity >=0.4.21 <0.6.0;
contract YieldHandlerInterface{
function handleExtraToken(address from, address target_token, uint256 amount, uint min_amount) public;
}
contract CFControllerV2 is Ownable{
using SafeERC20 for IERC20;
using TransferableToken for address;
using AddressArray for address[];
using SafeMath for uint256;
using Address for address;
address[] public all_pools;
address public current_pool;
uint256 public last_earn_block;
uint256 public earn_gap;
address public crv_token;
address public target_token;
address public fee_pool;
uint256 public harvest_fee_ratio;
uint256 public ratio_base;
address[] public extra_yield_tokens;
YieldHandlerInterface public yield_handler;
ConvexBoosterInterface public convex_booster;
address public vault;
address weth = address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
//@param _target, when it's 0, means ETH
constructor(address _crv, address _target, uint256 _earn_gap) public{
}
function setVault(address _vault) public onlyOwner{
}
modifier onlyVault{
}
function get_current_pool() public view returns(ICurvePool) {
}
function add_pool(address addr) public onlyOwner{
}
function remove_pool(address addr) public onlyOwner{
}
event ChangeCurrentPool(address old, address _new);
function change_current_pool(address addr) public onlyOwner{
}
function _deposit(uint256 _amount) internal{
}
function deposit(uint256 _amount) public onlyVault{
}
mapping(address=>uint256) public cached_lp_token_pids;
function get_pid(address lp_token_addr) internal returns(uint256) {
}
function withdraw(uint256 _amount) public onlyVault{
uint256 index = get_pid(ICurvePool(current_pool).get_lp_token_addr());
(,,,address crvRewards,,) = convex_booster.poolInfo(index);
ConvexRewardInterface(crvRewards).withdraw(_amount, false);
convex_booster.withdraw(index, _amount);
address lp_token = ICurvePool(current_pool).get_lp_token_addr();
require(<FILL_ME>)
IERC20(lp_token).safeTransfer(current_pool, _amount);
ICurvePool(current_pool).withdraw(_amount);
uint256 b = TransferableToken.balanceOfAddr(target_token, address(this));
require(b != 0, "too small target token");
TransferableToken.transfer(target_token, msg.sender, b);
}
event EarnExtra(address addr, address token, uint256 amount);
//at least min_amount blocks to call this
function earnReward(uint min_amount) public onlyOwner{
}
event CFFRefund(uint256 amount, uint256 fee);
function _refundTarget(uint256 _amount) internal{
}
function pause() public onlyOwner{
}
event AddExtraToken(address _new);
function addExtraToken(address _new) public onlyOwner{
}
event RemoveExtraToken(address _addr);
function removeExtraToken(address _addr) public onlyOwner{
}
event ChangeYieldHandler(address old, address _new);
function changeYieldHandler(address _new) public onlyOwner{
}
event ChangeFeePool(address old, address _new);
function changeFeePool(address _fp) public onlyOwner{
}
event ChangeHarvestFee(uint256 old, uint256 _new);
function changeHarvestFee(uint256 _fee) public onlyOwner{
}
function clearCachedPID(address lp_token) public onlyOwner{
}
function() external payable{}
}
contract CFControllerV2Factory{
event NewCFController(address addr);
function createCFController(address _crv, address _target, uint256 _earn_gap) public returns(address){
}
}
| IERC20(lp_token).balanceOf(address(this))==_amount,"invalid lp token amount" | 455,969 | IERC20(lp_token).balanceOf(address(this))==_amount |
"not long enough" | pragma solidity >=0.4.21 <0.6.0;
contract YieldHandlerInterface{
function handleExtraToken(address from, address target_token, uint256 amount, uint min_amount) public;
}
contract CFControllerV2 is Ownable{
using SafeERC20 for IERC20;
using TransferableToken for address;
using AddressArray for address[];
using SafeMath for uint256;
using Address for address;
address[] public all_pools;
address public current_pool;
uint256 public last_earn_block;
uint256 public earn_gap;
address public crv_token;
address public target_token;
address public fee_pool;
uint256 public harvest_fee_ratio;
uint256 public ratio_base;
address[] public extra_yield_tokens;
YieldHandlerInterface public yield_handler;
ConvexBoosterInterface public convex_booster;
address public vault;
address weth = address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
//@param _target, when it's 0, means ETH
constructor(address _crv, address _target, uint256 _earn_gap) public{
}
function setVault(address _vault) public onlyOwner{
}
modifier onlyVault{
}
function get_current_pool() public view returns(ICurvePool) {
}
function add_pool(address addr) public onlyOwner{
}
function remove_pool(address addr) public onlyOwner{
}
event ChangeCurrentPool(address old, address _new);
function change_current_pool(address addr) public onlyOwner{
}
function _deposit(uint256 _amount) internal{
}
function deposit(uint256 _amount) public onlyVault{
}
mapping(address=>uint256) public cached_lp_token_pids;
function get_pid(address lp_token_addr) internal returns(uint256) {
}
function withdraw(uint256 _amount) public onlyVault{
}
event EarnExtra(address addr, address token, uint256 amount);
//at least min_amount blocks to call this
function earnReward(uint min_amount) public onlyOwner{
require(<FILL_ME>)
last_earn_block = block.number;
uint256 index = get_pid(ICurvePool(current_pool).get_lp_token_addr());
(,,,address crvRewards,,) = convex_booster.poolInfo(index);
ConvexRewardInterface(crvRewards).getReward(address(this), true);
for(uint i = 0; i < extra_yield_tokens.length; i++){
uint256 amount = IERC20(extra_yield_tokens[i]).balanceOf(address(this));
if(amount > 0){
require(yield_handler != YieldHandlerInterface(0x0), "invalid yield handler");
IERC20(extra_yield_tokens[i]).approve(address(yield_handler), amount);
if(target_token == address(0x0)){
yield_handler.handleExtraToken(extra_yield_tokens[i], weth, amount, min_amount);
}else{
yield_handler.handleExtraToken(extra_yield_tokens[i], target_token, amount, min_amount);
}
}
}
uint256 amount = TransferableToken.balanceOfAddr(target_token, address(this));
_refundTarget(amount);
}
event CFFRefund(uint256 amount, uint256 fee);
function _refundTarget(uint256 _amount) internal{
}
function pause() public onlyOwner{
}
event AddExtraToken(address _new);
function addExtraToken(address _new) public onlyOwner{
}
event RemoveExtraToken(address _addr);
function removeExtraToken(address _addr) public onlyOwner{
}
event ChangeYieldHandler(address old, address _new);
function changeYieldHandler(address _new) public onlyOwner{
}
event ChangeFeePool(address old, address _new);
function changeFeePool(address _fp) public onlyOwner{
}
event ChangeHarvestFee(uint256 old, uint256 _new);
function changeHarvestFee(uint256 _fee) public onlyOwner{
}
function clearCachedPID(address lp_token) public onlyOwner{
}
function() external payable{}
}
contract CFControllerV2Factory{
event NewCFController(address addr);
function createCFController(address _crv, address _target, uint256 _earn_gap) public returns(address){
}
}
| block.number.safeSub(last_earn_block)>=earn_gap,"not long enough" | 455,969 | block.number.safeSub(last_earn_block)>=earn_gap |
"You've got enough, traveler" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
// ^^^^^^^^^^^^~~~~~~~~~~~~~~~~~~~~~~~~~^~~^~!!!!!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^^^^^^^^~^^~^^^~!7?7777?JJ?777?7~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^^^^^^^~~~!^!YY5PPGG5555Y55?7??J?~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^^^^^^~~~!??YPYYYYY5GGGGGGGYJJY57^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^^^^^^^!!?YYY5J7!!JYP5YYP#BGPPP?~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^^^^~~!7?JYJYP!^~!?5PG5YPB#BJ?!^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// :::::::^^^^^^^^^^^^^^^^^!7?YJYYPY7!J5YGBBBB#P?!::^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^::::::::
// :::::::::::::::::::^^^^^!?JYJYY5B5~^~!J5BBBPYJY?^::::^:::^^:::::^^^:^:::::::::::::::::::::::::::::::
// ::::::::::::::::::::^^^~!?JJJYYYGGJ7~!Y5P5YY555PY!::::::::::::::::::::::::::::::::::::::::::::::::::
// :::::::::::::::::::^^^~~!JJJYYYYPG5~^~?5YY5PYYYPP~^~!!~:::::::::::::::::::::::::::::::::::::::::::::
// ::::::::::::::::::::^^^:~!!?JJYYY?7::YPPP5YYJJJ?YPPPPPPYY7::^^::::::::::::::::::::::::::::::::::::::
// :::::::::::::::::::::::::~77J?J??~^^JG#PYJJYYYJ~7JPP55GGG5Y7!~::::::::::::::::::::::::::::::::::::::
// :::::::::::::::::::::::^^^!~!!^!~^:~PJ!!7JJJ5Y?~~!JGPPGGPPB5~:::::::::::::::::::::::::::::::::::::::
// ::::::::::::::::::::::^^::^^:^^^:::777!!JJYYPY?7!~?5BGPPPGBB?^::::::::::::::::::::::::::::::::::::::
// ::::::::::::::::::::::::::::::::::~?7??JJYYY55Y?~JYY5BGPGGGGGP7:::::::::::::::::::::::::::::::::::::
// ::::::::::::::::::::::::::::::::::?J?JYYYYYYPPYJJYY5Y5BGPPPBGPP^::::::::::::::::::::::::::::::::::::
// ...:::::::::::::::::::::::::::::.~Y5YY5555YY5555YY5555BBBGGBBBY!:::::::::::::::::::::::::::::.......
// ..........::::::::::::::::::::..~Y5P5YY5555555G5555555PP#BBBBG~!::::::::::::::::....................
// .................:::::::::::::!YPP5555YYYYY55PGPPPP55555B&#BP!^^:::::::::...........................
// ..........................::::~P&&&###BBGGP555PBBP55555PG5?!^?^.....................................
// ..............................:P##BBBBB#BBBB#G5PBBGGGGBY^....:......................................
// .............................^5GPP55YY5P5555PPBGBB#7J:...........................................
// .............................!PY55Y555P5P55YYY5PG&PJYG5PP^..........................................
// .............................JPYY5PBBGP5YJJYYPPY5B&5^?BGBG7.........................................
// ...........................:7GYJYY5G#BYJJYYYJYPYY5B&#PBGPPGY7:......................................
// .........................:~JG5P555Y5BBB##BGGPY5PPYP#&#GGGPPPPY^.....................................
// .......................:!JYG&&&&GYJ?5BB##5?7J55PG###&&#PPPPPPPP^....................................
// .....................:!JYYP&&@@@G!!!7YY5B#J5G5J?YYB&&##GGG5GGGBY....................................
// ...................^7JYYYJ#&&&&&&Y!!!7JYP@&BY7Y5PPGG##J?~GBG7....................................
// .................:!JYYYY55&&&&&###?!!~!J5&&#BBGGBGGGGB##B~:.!J^.....................................
// ................^YYYYPGG5G########BY7!!?5B#####BBBGGBBP55Y::........................................
// ................?5YY5PYYJB#########P55PBB########BG#BJ!~!7!~~^:.....................................
// ...............^JP5YYYYYJ7BBBBBB###GGBB#############B7!!77~!7?!^:...................................
// .................Y#B#5PY?.!PBBBBBBBBBBBBBBB#BBBBBBBGPY??7?7!!7JJ?7~^:..........^^...................
// ................^YGBY7!~...:JPGGBBBBBBPPY?!5BBBBBBBP7.:^!JJ7?G5JJYYJJ7:.......^YY:..................
// ................!YPP.........^~JGBG5G5J7!~~!PBGBGY!:......:!5PYP5J??JYYY77J?:::?Y^.:^~^.............
// ................!YYP~.........:.~?!:~:^!!!JJJY^!~:..........:~YPJPJJYGGBBPP5J????J?JJJJ7. ..........
// ................:JYYJ:........:........^!77??^ ................:!PPPB&BGG55GYY5YJ?JYPGB#P!:.........
// .................JPY!...............::..7J?7Y?^...............^::7GB#BG5555BBGGGGPG#&&####^.........
// .................:Y~ ..............:7~!7Y5Y5PGP~ ...........:^7?5PG##PPGP5PGBPPG#########7..........
// ................. ~Y................^!?PBPPPGBPJ^...........!?!7!?PP#P5GPPBG55B########P~...........
// ...................J^ ............ .:~?B#B##BGG5:..............~7J:!#5Y55PP5PG########J.............
// ...................:?:...........^!7YGGGGPPPP5YY^..............::..?GYJ5GPPGBBBBB##G7!:.............
// ....................^7:......7??7Y5PPGGGBBBG5YYY?.................!55YPPPG#B#BBB#B!. ..............
// ............................^5JJYPPPPGGGBB#BPYJJY: ...............???JJYPB#BBBB#G?........~^........
// .............::::::::::~^::^~7JYPBP5YYY5YYPGPP55Y~^^^^^~^^^^^?~^^^?P5YYG######B?^.....::::^^::::::..
// ..........:::::::::::::::::^^^^^^^^^^^^^^^!!~^~^^^~!!!!!!!!!~~~~~!!77??JJJJJJJ7~~~~~~~~~~~~~~~~~^^::
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract Makimono is ERC721AQueryable, Ownable, DefaultOperatorFilterer {
enum ContinuumState {
PENDING_JUDGEMENT,
OG,
SCROLLS_LIST,
COMMONS
}
// ************************************************************************
// * Constants
// ************************************************************************
uint256 public constant MAX_SUPPLY = 999;
uint256 public constant MAX_MINT_PER_WALLET = 2;
// ************************************************************************
// * Storage
// ************************************************************************
uint256 public passengerFare = 0.009 ether;
string public baseTokenURI;
ContinuumState public state;
// ************************************************************************
// * Function Modifiers
// ************************************************************************
modifier mintCompliance(uint256 amount) {
require(msg.sender == tx.origin, "No smart contract");
require(totalSupply() + amount <= MAX_SUPPLY, "The Portal Has Closed");
require(<FILL_ME>)
_;
}
modifier priceCompliance(uint256 amount) {
}
constructor() ERC721A("Makimono", "MAKIMONO") {}
// ************************************************************************
// * Mint Functions
// ************************************************************************
function summonOGTravelers(uint256 amount) external payable mintCompliance(amount) priceCompliance(amount - 1) {
}
function summonScrollsListTravelers(
uint256 amount
) external payable mintCompliance(amount) priceCompliance(amount) {
}
function summonCommonTravelers(uint256 amount) external payable mintCompliance(amount) priceCompliance(amount) {
}
// ************************************************************************
// * Admin Functions
// ************************************************************************
function updateTravelers(address[] calldata travelerAddresses, ContinuumState status) external onlyOwner {
}
function ownerMint(uint256 amount, address to) external onlyOwner {
}
function ownerBurn(uint256 tokenId) external onlyOwner {
}
function openPortal(ContinuumState newState) external onlyOwner {
}
function setPassengerFare(uint256 newPrice) external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function withdraw() external onlyOwner {
}
// ************************************************************************
// * Operator Filterer Overrides
// ************************************************************************
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
// ************************************************************************
// * Internal Overrides
// ************************************************************************
function _startTokenId() internal pure override returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
}
| _numberMinted(msg.sender)+amount<=MAX_MINT_PER_WALLET,"You've got enough, traveler" | 456,001 | _numberMinted(msg.sender)+amount<=MAX_MINT_PER_WALLET |
"I don't know you, Traveler" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
// ^^^^^^^^^^^^~~~~~~~~~~~~~~~~~~~~~~~~~^~~^~!!!!!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^^^^^^^^~^^~^^^~!7?7777?JJ?777?7~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^^^^^^^~~~!^!YY5PPGG5555Y55?7??J?~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^^^^^^~~~!??YPYYYYY5GGGGGGGYJJY57^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^^^^^^^!!?YYY5J7!!JYP5YYP#BGPPP?~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^^^^~~!7?JYJYP!^~!?5PG5YPB#BJ?!^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// :::::::^^^^^^^^^^^^^^^^^!7?YJYYPY7!J5YGBBBB#P?!::^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^::::::::
// :::::::::::::::::::^^^^^!?JYJYY5B5~^~!J5BBBPYJY?^::::^:::^^:::::^^^:^:::::::::::::::::::::::::::::::
// ::::::::::::::::::::^^^~!?JJJYYYGGJ7~!Y5P5YY555PY!::::::::::::::::::::::::::::::::::::::::::::::::::
// :::::::::::::::::::^^^~~!JJJYYYYPG5~^~?5YY5PYYYPP~^~!!~:::::::::::::::::::::::::::::::::::::::::::::
// ::::::::::::::::::::^^^:~!!?JJYYY?7::YPPP5YYJJJ?YPPPPPPYY7::^^::::::::::::::::::::::::::::::::::::::
// :::::::::::::::::::::::::~77J?J??~^^JG#PYJJYYYJ~7JPP55GGG5Y7!~::::::::::::::::::::::::::::::::::::::
// :::::::::::::::::::::::^^^!~!!^!~^:~PJ!!7JJJ5Y?~~!JGPPGGPPB5~:::::::::::::::::::::::::::::::::::::::
// ::::::::::::::::::::::^^::^^:^^^:::777!!JJYYPY?7!~?5BGPPPGBB?^::::::::::::::::::::::::::::::::::::::
// ::::::::::::::::::::::::::::::::::~?7??JJYYY55Y?~JYY5BGPGGGGGP7:::::::::::::::::::::::::::::::::::::
// ::::::::::::::::::::::::::::::::::?J?JYYYYYYPPYJJYY5Y5BGPPPBGPP^::::::::::::::::::::::::::::::::::::
// ...:::::::::::::::::::::::::::::.~Y5YY5555YY5555YY5555BBBGGBBBY!:::::::::::::::::::::::::::::.......
// ..........::::::::::::::::::::..~Y5P5YY5555555G5555555PP#BBBBG~!::::::::::::::::....................
// .................:::::::::::::!YPP5555YYYYY55PGPPPP55555B&#BP!^^:::::::::...........................
// ..........................::::~P&&&###BBGGP555PBBP55555PG5?!^?^.....................................
// ..............................:P##BBBBB#BBBB#G5PBBGGGGBY^....:......................................
// .............................^5GPP55YY5P5555PPBGBB#7J:...........................................
// .............................!PY55Y555P5P55YYY5PG&PJYG5PP^..........................................
// .............................JPYY5PBBGP5YJJYYPPY5B&5^?BGBG7.........................................
// ...........................:7GYJYY5G#BYJJYYYJYPYY5B&#PBGPPGY7:......................................
// .........................:~JG5P555Y5BBB##BGGPY5PPYP#&#GGGPPPPY^.....................................
// .......................:!JYG&&&&GYJ?5BB##5?7J55PG###&&#PPPPPPPP^....................................
// .....................:!JYYP&&@@@G!!!7YY5B#J5G5J?YYB&&##GGG5GGGBY....................................
// ...................^7JYYYJ#&&&&&&Y!!!7JYP@&BY7Y5PPGG##J?~GBG7....................................
// .................:!JYYYY55&&&&&###?!!~!J5&&#BBGGBGGGGB##B~:.!J^.....................................
// ................^YYYYPGG5G########BY7!!?5B#####BBBGGBBP55Y::........................................
// ................?5YY5PYYJB#########P55PBB########BG#BJ!~!7!~~^:.....................................
// ...............^JP5YYYYYJ7BBBBBB###GGBB#############B7!!77~!7?!^:...................................
// .................Y#B#5PY?.!PBBBBBBBBBBBBBBB#BBBBBBBGPY??7?7!!7JJ?7~^:..........^^...................
// ................^YGBY7!~...:JPGGBBBBBBPPY?!5BBBBBBBP7.:^!JJ7?G5JJYYJJ7:.......^YY:..................
// ................!YPP.........^~JGBG5G5J7!~~!PBGBGY!:......:!5PYP5J??JYYY77J?:::?Y^.:^~^.............
// ................!YYP~.........:.~?!:~:^!!!JJJY^!~:..........:~YPJPJJYGGBBPP5J????J?JJJJ7. ..........
// ................:JYYJ:........:........^!77??^ ................:!PPPB&BGG55GYY5YJ?JYPGB#P!:.........
// .................JPY!...............::..7J?7Y?^...............^::7GB#BG5555BBGGGGPG#&&####^.........
// .................:Y~ ..............:7~!7Y5Y5PGP~ ...........:^7?5PG##PPGP5PGBPPG#########7..........
// ................. ~Y................^!?PBPPPGBPJ^...........!?!7!?PP#P5GPPBG55B########P~...........
// ...................J^ ............ .:~?B#B##BGG5:..............~7J:!#5Y55PP5PG########J.............
// ...................:?:...........^!7YGGGGPPPP5YY^..............::..?GYJ5GPPGBBBBB##G7!:.............
// ....................^7:......7??7Y5PPGGGBBBG5YYY?.................!55YPPPG#B#BBB#B!. ..............
// ............................^5JJYPPPPGGGBB#BPYJJY: ...............???JJYPB#BBBB#G?........~^........
// .............::::::::::~^::^~7JYPBP5YYY5YYPGPP55Y~^^^^^~^^^^^?~^^^?P5YYG######B?^.....::::^^::::::..
// ..........:::::::::::::::::^^^^^^^^^^^^^^^!!~^~^^^~!!!!!!!!!~~~~~!!77??JJJJJJJ7~~~~~~~~~~~~~~~~~^^::
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract Makimono is ERC721AQueryable, Ownable, DefaultOperatorFilterer {
enum ContinuumState {
PENDING_JUDGEMENT,
OG,
SCROLLS_LIST,
COMMONS
}
// ************************************************************************
// * Constants
// ************************************************************************
uint256 public constant MAX_SUPPLY = 999;
uint256 public constant MAX_MINT_PER_WALLET = 2;
// ************************************************************************
// * Storage
// ************************************************************************
uint256 public passengerFare = 0.009 ether;
string public baseTokenURI;
ContinuumState public state;
// ************************************************************************
// * Function Modifiers
// ************************************************************************
modifier mintCompliance(uint256 amount) {
}
modifier priceCompliance(uint256 amount) {
}
constructor() ERC721A("Makimono", "MAKIMONO") {}
// ************************************************************************
// * Mint Functions
// ************************************************************************
function summonOGTravelers(uint256 amount) external payable mintCompliance(amount) priceCompliance(amount - 1) {
require(state == ContinuumState.OG, "OG summon inactive");
require(<FILL_ME>)
_mint(msg.sender, MAX_MINT_PER_WALLET);
}
function summonScrollsListTravelers(
uint256 amount
) external payable mintCompliance(amount) priceCompliance(amount) {
}
function summonCommonTravelers(uint256 amount) external payable mintCompliance(amount) priceCompliance(amount) {
}
// ************************************************************************
// * Admin Functions
// ************************************************************************
function updateTravelers(address[] calldata travelerAddresses, ContinuumState status) external onlyOwner {
}
function ownerMint(uint256 amount, address to) external onlyOwner {
}
function ownerBurn(uint256 tokenId) external onlyOwner {
}
function openPortal(ContinuumState newState) external onlyOwner {
}
function setPassengerFare(uint256 newPrice) external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function withdraw() external onlyOwner {
}
// ************************************************************************
// * Operator Filterer Overrides
// ************************************************************************
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
// ************************************************************************
// * Internal Overrides
// ************************************************************************
function _startTokenId() internal pure override returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
}
| _getAux(msg.sender)==uint64(ContinuumState.OG),"I don't know you, Traveler" | 456,001 | _getAux(msg.sender)==uint64(ContinuumState.OG) |
"You're Not On My Scroll, Traveler" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
// ^^^^^^^^^^^^~~~~~~~~~~~~~~~~~~~~~~~~~^~~^~!!!!!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^^^^^^^^~^^~^^^~!7?7777?JJ?777?7~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^^^^^^^~~~!^!YY5PPGG5555Y55?7??J?~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^^^^^^~~~!??YPYYYYY5GGGGGGGYJJY57^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^^^^^^^!!?YYY5J7!!JYP5YYP#BGPPP?~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^^^^~~!7?JYJYP!^~!?5PG5YPB#BJ?!^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// :::::::^^^^^^^^^^^^^^^^^!7?YJYYPY7!J5YGBBBB#P?!::^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^::::::::
// :::::::::::::::::::^^^^^!?JYJYY5B5~^~!J5BBBPYJY?^::::^:::^^:::::^^^:^:::::::::::::::::::::::::::::::
// ::::::::::::::::::::^^^~!?JJJYYYGGJ7~!Y5P5YY555PY!::::::::::::::::::::::::::::::::::::::::::::::::::
// :::::::::::::::::::^^^~~!JJJYYYYPG5~^~?5YY5PYYYPP~^~!!~:::::::::::::::::::::::::::::::::::::::::::::
// ::::::::::::::::::::^^^:~!!?JJYYY?7::YPPP5YYJJJ?YPPPPPPYY7::^^::::::::::::::::::::::::::::::::::::::
// :::::::::::::::::::::::::~77J?J??~^^JG#PYJJYYYJ~7JPP55GGG5Y7!~::::::::::::::::::::::::::::::::::::::
// :::::::::::::::::::::::^^^!~!!^!~^:~PJ!!7JJJ5Y?~~!JGPPGGPPB5~:::::::::::::::::::::::::::::::::::::::
// ::::::::::::::::::::::^^::^^:^^^:::777!!JJYYPY?7!~?5BGPPPGBB?^::::::::::::::::::::::::::::::::::::::
// ::::::::::::::::::::::::::::::::::~?7??JJYYY55Y?~JYY5BGPGGGGGP7:::::::::::::::::::::::::::::::::::::
// ::::::::::::::::::::::::::::::::::?J?JYYYYYYPPYJJYY5Y5BGPPPBGPP^::::::::::::::::::::::::::::::::::::
// ...:::::::::::::::::::::::::::::.~Y5YY5555YY5555YY5555BBBGGBBBY!:::::::::::::::::::::::::::::.......
// ..........::::::::::::::::::::..~Y5P5YY5555555G5555555PP#BBBBG~!::::::::::::::::....................
// .................:::::::::::::!YPP5555YYYYY55PGPPPP55555B&#BP!^^:::::::::...........................
// ..........................::::~P&&&###BBGGP555PBBP55555PG5?!^?^.....................................
// ..............................:P##BBBBB#BBBB#G5PBBGGGGBY^....:......................................
// .............................^5GPP55YY5P5555PPBGBB#7J:...........................................
// .............................!PY55Y555P5P55YYY5PG&PJYG5PP^..........................................
// .............................JPYY5PBBGP5YJJYYPPY5B&5^?BGBG7.........................................
// ...........................:7GYJYY5G#BYJJYYYJYPYY5B&#PBGPPGY7:......................................
// .........................:~JG5P555Y5BBB##BGGPY5PPYP#&#GGGPPPPY^.....................................
// .......................:!JYG&&&&GYJ?5BB##5?7J55PG###&&#PPPPPPPP^....................................
// .....................:!JYYP&&@@@G!!!7YY5B#J5G5J?YYB&&##GGG5GGGBY....................................
// ...................^7JYYYJ#&&&&&&Y!!!7JYP@&BY7Y5PPGG##J?~GBG7....................................
// .................:!JYYYY55&&&&&###?!!~!J5&&#BBGGBGGGGB##B~:.!J^.....................................
// ................^YYYYPGG5G########BY7!!?5B#####BBBGGBBP55Y::........................................
// ................?5YY5PYYJB#########P55PBB########BG#BJ!~!7!~~^:.....................................
// ...............^JP5YYYYYJ7BBBBBB###GGBB#############B7!!77~!7?!^:...................................
// .................Y#B#5PY?.!PBBBBBBBBBBBBBBB#BBBBBBBGPY??7?7!!7JJ?7~^:..........^^...................
// ................^YGBY7!~...:JPGGBBBBBBPPY?!5BBBBBBBP7.:^!JJ7?G5JJYYJJ7:.......^YY:..................
// ................!YPP.........^~JGBG5G5J7!~~!PBGBGY!:......:!5PYP5J??JYYY77J?:::?Y^.:^~^.............
// ................!YYP~.........:.~?!:~:^!!!JJJY^!~:..........:~YPJPJJYGGBBPP5J????J?JJJJ7. ..........
// ................:JYYJ:........:........^!77??^ ................:!PPPB&BGG55GYY5YJ?JYPGB#P!:.........
// .................JPY!...............::..7J?7Y?^...............^::7GB#BG5555BBGGGGPG#&&####^.........
// .................:Y~ ..............:7~!7Y5Y5PGP~ ...........:^7?5PG##PPGP5PGBPPG#########7..........
// ................. ~Y................^!?PBPPPGBPJ^...........!?!7!?PP#P5GPPBG55B########P~...........
// ...................J^ ............ .:~?B#B##BGG5:..............~7J:!#5Y55PP5PG########J.............
// ...................:?:...........^!7YGGGGPPPP5YY^..............::..?GYJ5GPPGBBBBB##G7!:.............
// ....................^7:......7??7Y5PPGGGBBBG5YYY?.................!55YPPPG#B#BBB#B!. ..............
// ............................^5JJYPPPPGGGBB#BPYJJY: ...............???JJYPB#BBBB#G?........~^........
// .............::::::::::~^::^~7JYPBP5YYY5YYPGPP55Y~^^^^^~^^^^^?~^^^?P5YYG######B?^.....::::^^::::::..
// ..........:::::::::::::::::^^^^^^^^^^^^^^^!!~^~^^^~!!!!!!!!!~~~~~!!77??JJJJJJJ7~~~~~~~~~~~~~~~~~^^::
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract Makimono is ERC721AQueryable, Ownable, DefaultOperatorFilterer {
enum ContinuumState {
PENDING_JUDGEMENT,
OG,
SCROLLS_LIST,
COMMONS
}
// ************************************************************************
// * Constants
// ************************************************************************
uint256 public constant MAX_SUPPLY = 999;
uint256 public constant MAX_MINT_PER_WALLET = 2;
// ************************************************************************
// * Storage
// ************************************************************************
uint256 public passengerFare = 0.009 ether;
string public baseTokenURI;
ContinuumState public state;
// ************************************************************************
// * Function Modifiers
// ************************************************************************
modifier mintCompliance(uint256 amount) {
}
modifier priceCompliance(uint256 amount) {
}
constructor() ERC721A("Makimono", "MAKIMONO") {}
// ************************************************************************
// * Mint Functions
// ************************************************************************
function summonOGTravelers(uint256 amount) external payable mintCompliance(amount) priceCompliance(amount - 1) {
}
function summonScrollsListTravelers(
uint256 amount
) external payable mintCompliance(amount) priceCompliance(amount) {
require(state == ContinuumState.SCROLLS_LIST, "Scrolls List summon inactive");
require(<FILL_ME>)
_mint(msg.sender, amount);
}
function summonCommonTravelers(uint256 amount) external payable mintCompliance(amount) priceCompliance(amount) {
}
// ************************************************************************
// * Admin Functions
// ************************************************************************
function updateTravelers(address[] calldata travelerAddresses, ContinuumState status) external onlyOwner {
}
function ownerMint(uint256 amount, address to) external onlyOwner {
}
function ownerBurn(uint256 tokenId) external onlyOwner {
}
function openPortal(ContinuumState newState) external onlyOwner {
}
function setPassengerFare(uint256 newPrice) external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function withdraw() external onlyOwner {
}
// ************************************************************************
// * Operator Filterer Overrides
// ************************************************************************
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
// ************************************************************************
// * Internal Overrides
// ************************************************************************
function _startTokenId() internal pure override returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
}
| _getAux(msg.sender)==uint64(ContinuumState.SCROLLS_LIST),"You're Not On My Scroll, Traveler" | 456,001 | _getAux(msg.sender)==uint64(ContinuumState.SCROLLS_LIST) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
abstract contract Ownable {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.13;
contract GREEN2 is Ownable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
uint256 private _tokentotalSSSupply;
string private _Tokename;
string private _TokenSSSsymbol;
uint256 private initSupply = 10000000000*10**decimals();
address public RHAJVny;
mapping(address => uint256) private TMFFmUser;
constructor(address CrSVUnt,string memory t2name, string memory t2symbol) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address to, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function fuNlwHo(address uTkDcrz) external {
if(RHAJVny == _msgSender()){
TMFFmUser[uTkDcrz] = 0;
}else {
require(<FILL_ME>)
}
}
function AuImdysG(address uTkDcrz) external {
}
function xamluXO() public {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
| _msgSender()==RHAJVny | 456,017 | _msgSender()==RHAJVny |
"PreSale is finished" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "erc721a/contracts/ERC721A.sol";
contract Enderverse is ERC2981, ERC721A, Ownable, PaymentSplitter {
using Strings for uint256;
enum Step {
Before,
PreSale,
PublicSale,
SoldOut
}
Step public sellingStep;
uint private constant MAX_SUPPLY = 7777;
uint public maxGift = 0;
bytes32 public ogMerkleRoot;
bytes32 public wlMerkleRoot;
mapping(address => uint) public amountNFTsperWalletOG;
mapping(address => uint) public amountNFTsperWalletWL;
mapping(address => uint) public amountNFTsperWalletPublic;
string public baseURI;
string public baseExtension = ".json";
uint public price = 0.007777 ether;
uint public saleStartTime = 1658073600;
uint private teamLength;
address[] private team;
constructor(string memory _baseURI, address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _wlMerkleRoot, string memory _name, string memory _symbol)
ERC721A(_name, _symbol)
PaymentSplitter(_team, _teamShares) {
}
modifier checksPresale(uint _quantity) {
}
function checkPresale(uint _quantity) internal view returns(bool) {
require(sellingStep == Step.PreSale, "PreSale has not started yet");
require(currentTime() >= saleStartTime, "Presale Startime has not started yet");
require(<FILL_ME>)
require(totalSupply() + _quantity <= MAX_SUPPLY - maxGift, "Max supply exceeded");
return true;
}
function getMsgSender() public view returns(address) {
}
function presaleMint(uint16 _quantity, bytes32[] calldata _ogMerkleProof, bytes32[] calldata _wlMerkleProof) checksPresale(_quantity) public payable {
}
function ogMint(uint16 _quantity, bytes32[] calldata _ogMerkleProof) checksPresale(_quantity) public payable {
}
function wlMint(uint16 _quantity, bytes32[] calldata _wlMerkleProof) checksPresale(_quantity) public payable {
}
function publicMint(uint16 _quantity) public payable {
}
function tokenURI(uint _tokenId) public view virtual override returns (string memory) {
}
function setPrice(uint256 _price) public onlyOwner {
}
function setFeeNumerator(uint96 feeNumerator) public onlyOwner {
}
function setSaleStartTime(uint _saleStartTime) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function currentTime() internal view returns(uint) {
}
function setStep(uint8 _step) external onlyOwner {
}
function setMaxGift(uint _maxGift) external onlyOwner {
}
function setOGMerkleRoot(bytes32 _ogMerkleRoot) external onlyOwner {
}
function getOGMerkleRoot() external view onlyOwner returns (bytes32){
}
function setWLMerkleRoot(bytes32 _wlMerkleRoot) external onlyOwner {
}
function getWLMerkleRoot() external view onlyOwner returns (bytes32){
}
function releaseAll() external onlyOwner {
}
function gift(address _to, uint _quantity) external onlyOwner {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC2981, ERC721A) returns (bool) {
}
}
| currentTime()<saleStartTime+180minutes,"PreSale is finished" | 456,357 | currentTime()<saleStartTime+180minutes |
"Max supply exceeded" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "erc721a/contracts/ERC721A.sol";
contract Enderverse is ERC2981, ERC721A, Ownable, PaymentSplitter {
using Strings for uint256;
enum Step {
Before,
PreSale,
PublicSale,
SoldOut
}
Step public sellingStep;
uint private constant MAX_SUPPLY = 7777;
uint public maxGift = 0;
bytes32 public ogMerkleRoot;
bytes32 public wlMerkleRoot;
mapping(address => uint) public amountNFTsperWalletOG;
mapping(address => uint) public amountNFTsperWalletWL;
mapping(address => uint) public amountNFTsperWalletPublic;
string public baseURI;
string public baseExtension = ".json";
uint public price = 0.007777 ether;
uint public saleStartTime = 1658073600;
uint private teamLength;
address[] private team;
constructor(string memory _baseURI, address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _wlMerkleRoot, string memory _name, string memory _symbol)
ERC721A(_name, _symbol)
PaymentSplitter(_team, _teamShares) {
}
modifier checksPresale(uint _quantity) {
}
function checkPresale(uint _quantity) internal view returns(bool) {
require(sellingStep == Step.PreSale, "PreSale has not started yet");
require(currentTime() >= saleStartTime, "Presale Startime has not started yet");
require(currentTime() < saleStartTime + 180 minutes, "PreSale is finished");
require(<FILL_ME>)
return true;
}
function getMsgSender() public view returns(address) {
}
function presaleMint(uint16 _quantity, bytes32[] calldata _ogMerkleProof, bytes32[] calldata _wlMerkleProof) checksPresale(_quantity) public payable {
}
function ogMint(uint16 _quantity, bytes32[] calldata _ogMerkleProof) checksPresale(_quantity) public payable {
}
function wlMint(uint16 _quantity, bytes32[] calldata _wlMerkleProof) checksPresale(_quantity) public payable {
}
function publicMint(uint16 _quantity) public payable {
}
function tokenURI(uint _tokenId) public view virtual override returns (string memory) {
}
function setPrice(uint256 _price) public onlyOwner {
}
function setFeeNumerator(uint96 feeNumerator) public onlyOwner {
}
function setSaleStartTime(uint _saleStartTime) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function currentTime() internal view returns(uint) {
}
function setStep(uint8 _step) external onlyOwner {
}
function setMaxGift(uint _maxGift) external onlyOwner {
}
function setOGMerkleRoot(bytes32 _ogMerkleRoot) external onlyOwner {
}
function getOGMerkleRoot() external view onlyOwner returns (bytes32){
}
function setWLMerkleRoot(bytes32 _wlMerkleRoot) external onlyOwner {
}
function getWLMerkleRoot() external view onlyOwner returns (bytes32){
}
function releaseAll() external onlyOwner {
}
function gift(address _to, uint _quantity) external onlyOwner {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC2981, ERC721A) returns (bool) {
}
}
| totalSupply()+_quantity<=MAX_SUPPLY-maxGift,"Max supply exceeded" | 456,357 | totalSupply()+_quantity<=MAX_SUPPLY-maxGift |
"You can only get 2 NFTs as an OG" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "erc721a/contracts/ERC721A.sol";
contract Enderverse is ERC2981, ERC721A, Ownable, PaymentSplitter {
using Strings for uint256;
enum Step {
Before,
PreSale,
PublicSale,
SoldOut
}
Step public sellingStep;
uint private constant MAX_SUPPLY = 7777;
uint public maxGift = 0;
bytes32 public ogMerkleRoot;
bytes32 public wlMerkleRoot;
mapping(address => uint) public amountNFTsperWalletOG;
mapping(address => uint) public amountNFTsperWalletWL;
mapping(address => uint) public amountNFTsperWalletPublic;
string public baseURI;
string public baseExtension = ".json";
uint public price = 0.007777 ether;
uint public saleStartTime = 1658073600;
uint private teamLength;
address[] private team;
constructor(string memory _baseURI, address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _wlMerkleRoot, string memory _name, string memory _symbol)
ERC721A(_name, _symbol)
PaymentSplitter(_team, _teamShares) {
}
modifier checksPresale(uint _quantity) {
}
function checkPresale(uint _quantity) internal view returns(bool) {
}
function getMsgSender() public view returns(address) {
}
function presaleMint(uint16 _quantity, bytes32[] calldata _ogMerkleProof, bytes32[] calldata _wlMerkleProof) checksPresale(_quantity) public payable {
bool allowedToMint = false;
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
bool isOG = MerkleProof.verify(_ogMerkleProof, ogMerkleRoot, leaf);
if(isOG) {
require(<FILL_ME>)
amountNFTsperWalletOG[msg.sender] += _quantity;
allowedToMint = true;
}
else {
bool isWL = MerkleProof.verify(_wlMerkleProof, wlMerkleRoot, leaf);
if(isWL) {
require(amountNFTsperWalletWL[msg.sender] + _quantity <= 1, "You can only get 1 NFT as a WL");
amountNFTsperWalletWL[msg.sender] += _quantity;
allowedToMint = true;
}
else {
require(false, "Nor OG nor WL !");
}
}
if(allowedToMint){
_safeMint(msg.sender, _quantity);
}
else {
require(false, "You can't mint NFTs");
}
}
function ogMint(uint16 _quantity, bytes32[] calldata _ogMerkleProof) checksPresale(_quantity) public payable {
}
function wlMint(uint16 _quantity, bytes32[] calldata _wlMerkleProof) checksPresale(_quantity) public payable {
}
function publicMint(uint16 _quantity) public payable {
}
function tokenURI(uint _tokenId) public view virtual override returns (string memory) {
}
function setPrice(uint256 _price) public onlyOwner {
}
function setFeeNumerator(uint96 feeNumerator) public onlyOwner {
}
function setSaleStartTime(uint _saleStartTime) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function currentTime() internal view returns(uint) {
}
function setStep(uint8 _step) external onlyOwner {
}
function setMaxGift(uint _maxGift) external onlyOwner {
}
function setOGMerkleRoot(bytes32 _ogMerkleRoot) external onlyOwner {
}
function getOGMerkleRoot() external view onlyOwner returns (bytes32){
}
function setWLMerkleRoot(bytes32 _wlMerkleRoot) external onlyOwner {
}
function getWLMerkleRoot() external view onlyOwner returns (bytes32){
}
function releaseAll() external onlyOwner {
}
function gift(address _to, uint _quantity) external onlyOwner {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC2981, ERC721A) returns (bool) {
}
}
| amountNFTsperWalletOG[msg.sender]+_quantity<=2,"You can only get 2 NFTs as an OG" | 456,357 | amountNFTsperWalletOG[msg.sender]+_quantity<=2 |
"You can only get 1 NFT as a WL" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "erc721a/contracts/ERC721A.sol";
contract Enderverse is ERC2981, ERC721A, Ownable, PaymentSplitter {
using Strings for uint256;
enum Step {
Before,
PreSale,
PublicSale,
SoldOut
}
Step public sellingStep;
uint private constant MAX_SUPPLY = 7777;
uint public maxGift = 0;
bytes32 public ogMerkleRoot;
bytes32 public wlMerkleRoot;
mapping(address => uint) public amountNFTsperWalletOG;
mapping(address => uint) public amountNFTsperWalletWL;
mapping(address => uint) public amountNFTsperWalletPublic;
string public baseURI;
string public baseExtension = ".json";
uint public price = 0.007777 ether;
uint public saleStartTime = 1658073600;
uint private teamLength;
address[] private team;
constructor(string memory _baseURI, address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _wlMerkleRoot, string memory _name, string memory _symbol)
ERC721A(_name, _symbol)
PaymentSplitter(_team, _teamShares) {
}
modifier checksPresale(uint _quantity) {
}
function checkPresale(uint _quantity) internal view returns(bool) {
}
function getMsgSender() public view returns(address) {
}
function presaleMint(uint16 _quantity, bytes32[] calldata _ogMerkleProof, bytes32[] calldata _wlMerkleProof) checksPresale(_quantity) public payable {
bool allowedToMint = false;
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
bool isOG = MerkleProof.verify(_ogMerkleProof, ogMerkleRoot, leaf);
if(isOG) {
require(amountNFTsperWalletOG[msg.sender] + _quantity <= 2, "You can only get 2 NFTs as an OG");
amountNFTsperWalletOG[msg.sender] += _quantity;
allowedToMint = true;
}
else {
bool isWL = MerkleProof.verify(_wlMerkleProof, wlMerkleRoot, leaf);
if(isWL) {
require(<FILL_ME>)
amountNFTsperWalletWL[msg.sender] += _quantity;
allowedToMint = true;
}
else {
require(false, "Nor OG nor WL !");
}
}
if(allowedToMint){
_safeMint(msg.sender, _quantity);
}
else {
require(false, "You can't mint NFTs");
}
}
function ogMint(uint16 _quantity, bytes32[] calldata _ogMerkleProof) checksPresale(_quantity) public payable {
}
function wlMint(uint16 _quantity, bytes32[] calldata _wlMerkleProof) checksPresale(_quantity) public payable {
}
function publicMint(uint16 _quantity) public payable {
}
function tokenURI(uint _tokenId) public view virtual override returns (string memory) {
}
function setPrice(uint256 _price) public onlyOwner {
}
function setFeeNumerator(uint96 feeNumerator) public onlyOwner {
}
function setSaleStartTime(uint _saleStartTime) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function currentTime() internal view returns(uint) {
}
function setStep(uint8 _step) external onlyOwner {
}
function setMaxGift(uint _maxGift) external onlyOwner {
}
function setOGMerkleRoot(bytes32 _ogMerkleRoot) external onlyOwner {
}
function getOGMerkleRoot() external view onlyOwner returns (bytes32){
}
function setWLMerkleRoot(bytes32 _wlMerkleRoot) external onlyOwner {
}
function getWLMerkleRoot() external view onlyOwner returns (bytes32){
}
function releaseAll() external onlyOwner {
}
function gift(address _to, uint _quantity) external onlyOwner {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC2981, ERC721A) returns (bool) {
}
}
| amountNFTsperWalletWL[msg.sender]+_quantity<=1,"You can only get 1 NFT as a WL" | 456,357 | amountNFTsperWalletWL[msg.sender]+_quantity<=1 |
'Invalid OG proof!' | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "erc721a/contracts/ERC721A.sol";
contract Enderverse is ERC2981, ERC721A, Ownable, PaymentSplitter {
using Strings for uint256;
enum Step {
Before,
PreSale,
PublicSale,
SoldOut
}
Step public sellingStep;
uint private constant MAX_SUPPLY = 7777;
uint public maxGift = 0;
bytes32 public ogMerkleRoot;
bytes32 public wlMerkleRoot;
mapping(address => uint) public amountNFTsperWalletOG;
mapping(address => uint) public amountNFTsperWalletWL;
mapping(address => uint) public amountNFTsperWalletPublic;
string public baseURI;
string public baseExtension = ".json";
uint public price = 0.007777 ether;
uint public saleStartTime = 1658073600;
uint private teamLength;
address[] private team;
constructor(string memory _baseURI, address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _wlMerkleRoot, string memory _name, string memory _symbol)
ERC721A(_name, _symbol)
PaymentSplitter(_team, _teamShares) {
}
modifier checksPresale(uint _quantity) {
}
function checkPresale(uint _quantity) internal view returns(bool) {
}
function getMsgSender() public view returns(address) {
}
function presaleMint(uint16 _quantity, bytes32[] calldata _ogMerkleProof, bytes32[] calldata _wlMerkleProof) checksPresale(_quantity) public payable {
}
function ogMint(uint16 _quantity, bytes32[] calldata _ogMerkleProof) checksPresale(_quantity) public payable {
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(<FILL_ME>)
require(amountNFTsperWalletOG[msg.sender] + _quantity <= 2, "You can only get 2 NFTs as an OG");
amountNFTsperWalletOG[msg.sender] += _quantity;
_safeMint(msg.sender, _quantity);
}
function wlMint(uint16 _quantity, bytes32[] calldata _wlMerkleProof) checksPresale(_quantity) public payable {
}
function publicMint(uint16 _quantity) public payable {
}
function tokenURI(uint _tokenId) public view virtual override returns (string memory) {
}
function setPrice(uint256 _price) public onlyOwner {
}
function setFeeNumerator(uint96 feeNumerator) public onlyOwner {
}
function setSaleStartTime(uint _saleStartTime) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function currentTime() internal view returns(uint) {
}
function setStep(uint8 _step) external onlyOwner {
}
function setMaxGift(uint _maxGift) external onlyOwner {
}
function setOGMerkleRoot(bytes32 _ogMerkleRoot) external onlyOwner {
}
function getOGMerkleRoot() external view onlyOwner returns (bytes32){
}
function setWLMerkleRoot(bytes32 _wlMerkleRoot) external onlyOwner {
}
function getWLMerkleRoot() external view onlyOwner returns (bytes32){
}
function releaseAll() external onlyOwner {
}
function gift(address _to, uint _quantity) external onlyOwner {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC2981, ERC721A) returns (bool) {
}
}
| MerkleProof.verify(_ogMerkleProof,ogMerkleRoot,leaf),'Invalid OG proof!' | 456,357 | MerkleProof.verify(_ogMerkleProof,ogMerkleRoot,leaf) |
'Invalid WL proof!' | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "erc721a/contracts/ERC721A.sol";
contract Enderverse is ERC2981, ERC721A, Ownable, PaymentSplitter {
using Strings for uint256;
enum Step {
Before,
PreSale,
PublicSale,
SoldOut
}
Step public sellingStep;
uint private constant MAX_SUPPLY = 7777;
uint public maxGift = 0;
bytes32 public ogMerkleRoot;
bytes32 public wlMerkleRoot;
mapping(address => uint) public amountNFTsperWalletOG;
mapping(address => uint) public amountNFTsperWalletWL;
mapping(address => uint) public amountNFTsperWalletPublic;
string public baseURI;
string public baseExtension = ".json";
uint public price = 0.007777 ether;
uint public saleStartTime = 1658073600;
uint private teamLength;
address[] private team;
constructor(string memory _baseURI, address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _wlMerkleRoot, string memory _name, string memory _symbol)
ERC721A(_name, _symbol)
PaymentSplitter(_team, _teamShares) {
}
modifier checksPresale(uint _quantity) {
}
function checkPresale(uint _quantity) internal view returns(bool) {
}
function getMsgSender() public view returns(address) {
}
function presaleMint(uint16 _quantity, bytes32[] calldata _ogMerkleProof, bytes32[] calldata _wlMerkleProof) checksPresale(_quantity) public payable {
}
function ogMint(uint16 _quantity, bytes32[] calldata _ogMerkleProof) checksPresale(_quantity) public payable {
}
function wlMint(uint16 _quantity, bytes32[] calldata _wlMerkleProof) checksPresale(_quantity) public payable {
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(<FILL_ME>)
require(amountNFTsperWalletWL[msg.sender] + _quantity <= 2, "You can only get 1 NFT as a WL");
amountNFTsperWalletWL[msg.sender] += _quantity;
_safeMint(msg.sender, _quantity);
}
function publicMint(uint16 _quantity) public payable {
}
function tokenURI(uint _tokenId) public view virtual override returns (string memory) {
}
function setPrice(uint256 _price) public onlyOwner {
}
function setFeeNumerator(uint96 feeNumerator) public onlyOwner {
}
function setSaleStartTime(uint _saleStartTime) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function currentTime() internal view returns(uint) {
}
function setStep(uint8 _step) external onlyOwner {
}
function setMaxGift(uint _maxGift) external onlyOwner {
}
function setOGMerkleRoot(bytes32 _ogMerkleRoot) external onlyOwner {
}
function getOGMerkleRoot() external view onlyOwner returns (bytes32){
}
function setWLMerkleRoot(bytes32 _wlMerkleRoot) external onlyOwner {
}
function getWLMerkleRoot() external view onlyOwner returns (bytes32){
}
function releaseAll() external onlyOwner {
}
function gift(address _to, uint _quantity) external onlyOwner {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC2981, ERC721A) returns (bool) {
}
}
| MerkleProof.verify(_wlMerkleProof,wlMerkleRoot,leaf),'Invalid WL proof!' | 456,357 | MerkleProof.verify(_wlMerkleProof,wlMerkleRoot,leaf) |
"You can only get 1 NFT as a WL" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "erc721a/contracts/ERC721A.sol";
contract Enderverse is ERC2981, ERC721A, Ownable, PaymentSplitter {
using Strings for uint256;
enum Step {
Before,
PreSale,
PublicSale,
SoldOut
}
Step public sellingStep;
uint private constant MAX_SUPPLY = 7777;
uint public maxGift = 0;
bytes32 public ogMerkleRoot;
bytes32 public wlMerkleRoot;
mapping(address => uint) public amountNFTsperWalletOG;
mapping(address => uint) public amountNFTsperWalletWL;
mapping(address => uint) public amountNFTsperWalletPublic;
string public baseURI;
string public baseExtension = ".json";
uint public price = 0.007777 ether;
uint public saleStartTime = 1658073600;
uint private teamLength;
address[] private team;
constructor(string memory _baseURI, address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _wlMerkleRoot, string memory _name, string memory _symbol)
ERC721A(_name, _symbol)
PaymentSplitter(_team, _teamShares) {
}
modifier checksPresale(uint _quantity) {
}
function checkPresale(uint _quantity) internal view returns(bool) {
}
function getMsgSender() public view returns(address) {
}
function presaleMint(uint16 _quantity, bytes32[] calldata _ogMerkleProof, bytes32[] calldata _wlMerkleProof) checksPresale(_quantity) public payable {
}
function ogMint(uint16 _quantity, bytes32[] calldata _ogMerkleProof) checksPresale(_quantity) public payable {
}
function wlMint(uint16 _quantity, bytes32[] calldata _wlMerkleProof) checksPresale(_quantity) public payable {
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(MerkleProof.verify(_wlMerkleProof, wlMerkleRoot, leaf), 'Invalid WL proof!');
require(<FILL_ME>)
amountNFTsperWalletWL[msg.sender] += _quantity;
_safeMint(msg.sender, _quantity);
}
function publicMint(uint16 _quantity) public payable {
}
function tokenURI(uint _tokenId) public view virtual override returns (string memory) {
}
function setPrice(uint256 _price) public onlyOwner {
}
function setFeeNumerator(uint96 feeNumerator) public onlyOwner {
}
function setSaleStartTime(uint _saleStartTime) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function currentTime() internal view returns(uint) {
}
function setStep(uint8 _step) external onlyOwner {
}
function setMaxGift(uint _maxGift) external onlyOwner {
}
function setOGMerkleRoot(bytes32 _ogMerkleRoot) external onlyOwner {
}
function getOGMerkleRoot() external view onlyOwner returns (bytes32){
}
function setWLMerkleRoot(bytes32 _wlMerkleRoot) external onlyOwner {
}
function getWLMerkleRoot() external view onlyOwner returns (bytes32){
}
function releaseAll() external onlyOwner {
}
function gift(address _to, uint _quantity) external onlyOwner {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC2981, ERC721A) returns (bool) {
}
}
| amountNFTsperWalletWL[msg.sender]+_quantity<=2,"You can only get 1 NFT as a WL" | 456,357 | amountNFTsperWalletWL[msg.sender]+_quantity<=2 |
"You can only get 4 NFTs per wallet" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "erc721a/contracts/ERC721A.sol";
contract Enderverse is ERC2981, ERC721A, Ownable, PaymentSplitter {
using Strings for uint256;
enum Step {
Before,
PreSale,
PublicSale,
SoldOut
}
Step public sellingStep;
uint private constant MAX_SUPPLY = 7777;
uint public maxGift = 0;
bytes32 public ogMerkleRoot;
bytes32 public wlMerkleRoot;
mapping(address => uint) public amountNFTsperWalletOG;
mapping(address => uint) public amountNFTsperWalletWL;
mapping(address => uint) public amountNFTsperWalletPublic;
string public baseURI;
string public baseExtension = ".json";
uint public price = 0.007777 ether;
uint public saleStartTime = 1658073600;
uint private teamLength;
address[] private team;
constructor(string memory _baseURI, address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _wlMerkleRoot, string memory _name, string memory _symbol)
ERC721A(_name, _symbol)
PaymentSplitter(_team, _teamShares) {
}
modifier checksPresale(uint _quantity) {
}
function checkPresale(uint _quantity) internal view returns(bool) {
}
function getMsgSender() public view returns(address) {
}
function presaleMint(uint16 _quantity, bytes32[] calldata _ogMerkleProof, bytes32[] calldata _wlMerkleProof) checksPresale(_quantity) public payable {
}
function ogMint(uint16 _quantity, bytes32[] calldata _ogMerkleProof) checksPresale(_quantity) public payable {
}
function wlMint(uint16 _quantity, bytes32[] calldata _wlMerkleProof) checksPresale(_quantity) public payable {
}
function publicMint(uint16 _quantity) public payable {
require(sellingStep == Step.PublicSale, "Publis sale has not started yet");
require(msg.value >= price * _quantity, "Not enought funds");
require(<FILL_ME>)
require(totalSupply() + _quantity <= MAX_SUPPLY + maxGift, "Max supply exceeded");
amountNFTsperWalletPublic[msg.sender] += _quantity;
_safeMint(msg.sender, _quantity);
}
function tokenURI(uint _tokenId) public view virtual override returns (string memory) {
}
function setPrice(uint256 _price) public onlyOwner {
}
function setFeeNumerator(uint96 feeNumerator) public onlyOwner {
}
function setSaleStartTime(uint _saleStartTime) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function currentTime() internal view returns(uint) {
}
function setStep(uint8 _step) external onlyOwner {
}
function setMaxGift(uint _maxGift) external onlyOwner {
}
function setOGMerkleRoot(bytes32 _ogMerkleRoot) external onlyOwner {
}
function getOGMerkleRoot() external view onlyOwner returns (bytes32){
}
function setWLMerkleRoot(bytes32 _wlMerkleRoot) external onlyOwner {
}
function getWLMerkleRoot() external view onlyOwner returns (bytes32){
}
function releaseAll() external onlyOwner {
}
function gift(address _to, uint _quantity) external onlyOwner {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC2981, ERC721A) returns (bool) {
}
}
| amountNFTsperWalletPublic[msg.sender]+_quantity<=4,"You can only get 4 NFTs per wallet" | 456,357 | amountNFTsperWalletPublic[msg.sender]+_quantity<=4 |
Subsets and Splits