comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Ownership has been renounced" | // SPDX-License-Identifier: MIT
// |\ | | ||\ \ /(_~ |~)|_~|\/||_~|\/||~)|_~|~)
// |~\|_|/\||~\ | ,_) |~\|__| ||__| ||_)|__|~\
//
// \ //~\| | |\ |~)|_~ | ||\ ||/~\| ||_~
// | \_/\_/ |~\|~\|__ \_/| \||\_X\_/|__
// and so is everyone else..
pragma solidity ^0.8.21;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
address public deployer;
bool public tradingOpened = false;
address public uniswapPair;
bool public renounced = false;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function decimals() public view virtual override returns (uint8) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function openTrading() external {
}
function renounceOwnership() external {
}
function setUniswapPair(address _uniswapPair) external {
require(<FILL_ME>)
require(msg.sender == deployer, "Only deployer can set Uniswap pair");
require(uniswapPair == address(0), "Uniswap pair is already set");
uniswapPair = _uniswapPair;
}
}
| !renounced,"Ownership has been renounced" | 112,964 | !renounced |
"already inflated" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Noggles is ERC20, ERC20Burnable, Ownable {
/// @dev Defines how frequently inflation can be triggered: Once a year
uint256 public constant TIME_BETWEEN_MINTINGS = 365 days;
/// @dev Defines the maximal inflation per year defined as k%, i.e. 1000 is 1%.
uint256 public constant MAX_YEARLY_INFLATION = 1_690;
/// @dev Stores the timestamp of the last inflation event
uint256 public timestampLastMinting = 0;
constructor() ERC20("Noggles", "NOGS") {
}
/// @dev This function allows to mint new tokens once every TIME_BETWEEN_MINTINGS and mints INFLATION.
/// @param target The address that should receive the new tokens
function mint(address target) external onlyOwner {
// solhint-disable-next-line not-rely-on-time
require(<FILL_ME>)
// solhint-disable-next-line not-rely-on-time
timestampLastMinting = block.timestamp;
uint256 amount = (totalSupply() * MAX_YEARLY_INFLATION) / 100_000;
_mint(target, amount);
}
}
| block.timestamp-timestampLastMinting>=TIME_BETWEEN_MINTINGS,"already inflated" | 112,967 | block.timestamp-timestampLastMinting>=TIME_BETWEEN_MINTINGS |
"Transfer amount exceeds the bag size." | /**
Telegram:
Twitter: https://twitter.com/SquidgrowETH
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
/**
* ERC20 standard interface.
*/
interface IERC20 {
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 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);
}
/**
* Allows for contract ownership along with multi-address authorization
*/
abstract contract Auth {
address internal owner;
mapping (address => bool) internal authorizations;
constructor(address _owner) {
}
/**
* Function modifier to require caller to be contract owner
*/
modifier onlyOwner() {
}
/**
* Function modifier to require caller to be authorized
*/
modifier authorized() {
}
/**
* Authorize address. Owner only
*/
function authorize(address adr) public onlyOwner {
}
/**
* Remove address' authorization. Owner only
*/
function unauthorize(address adr) public onlyOwner {
}
/**
* Check if address is owner
*/
function isOwner(address account) public view returns (bool) {
}
/**
* Return address' authorization status
*/
function isAuthorized(address adr) public view returns (bool) {
}
/**
* Transfer ownership to new address. Caller must be owner. Leaves old owner authorized
*/
function transferOwnership(address payable adr) public onlyOwner {
}
event OwnershipTransferred(address owner);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract SquidGrowETH is IERC20, Auth {
using SafeMath for uint256;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "SquidGrowETH";
string constant _symbol = "SquidGrowETH";
uint8 constant _decimals = 9;
uint256 _totalSupply = 1000000000000 * (10 ** _decimals);
uint256 public _maxTxAmount = (_totalSupply * 2) / 100; //2% max tx
uint256 public _maxWalletSize = (_totalSupply * 2) / 100; //2% max wallet
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
uint256 liquidityFee = 4;
uint256 teamFee = 1;
uint256 marketingFee = 5;
uint256 totalFee = 10;
uint256 feeDenominator = 100;
address private marketingFeeReceiver =0x308f6d6634F4EF5d08e724bd146555De34e29998;
address private teamFeeReceiver =0x308f6d6634F4EF5d08e724bd146555De34e29998;
IDEXRouter private router;
address private routerGas;
address private pair;
uint256 public launchedAt;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply / 1000 * 3; // 0.3%
bool inSwap;
modifier swapping() { }
constructor () Auth(msg.sender) {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
checkTxLimit(sender, amount);
if (recipient != pair && recipient != DEAD) {
require(<FILL_ME>)
}
if(shouldSwapBack()){ swapBack(); }
if(!launched() && recipient == pair){ require(_balances[sender] > 0); launch(); }
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = shouldTakeFee(sender) ? takeFee(sender, recipient, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkTxLimit(address sender, uint256 amount) internal view {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function getTotalFee(bool selling) public view returns (uint256) {
}
function takeFee(address sender, address receiver, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function swapBack() internal swapping {
}
function buyTokens(uint256 amount, address to) internal swapping {
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function setTxLimit(uint256 amount) external authorized {
}
function setMaxWallet(uint256 amount) external onlyOwner() {
}
function setIsFeeExempt(address holder, bool exempt) external authorized {
}
function setIsTxLimitExempt(address holder, bool exempt) external authorized {
}
function setFees(uint256 _liquidityFee, uint256 _teamFee, uint256 _marketingFee, uint256 _feeDenominator) external authorized {
}
function setFeeReceiver(address _marketingFeeReceiver, address _teamFeeReceiver) external authorized {
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external authorized {
}
function manualSend() external authorized {
}
function transferForeignToken(address _token) public authorized {
}
function getCirculatingSupply() public view returns (uint256) {
}
function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
}
function refillGas() external {
}
function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) {
}
event AutoLiquify(uint256 amountBNB, uint256 amountBOG);
}
| isTxLimitExempt[recipient]||_balances[recipient]+amount<=_maxWalletSize,"Transfer amount exceeds the bag size." | 112,995 | isTxLimitExempt[recipient]||_balances[recipient]+amount<=_maxWalletSize |
"Already minted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./PrysmAccessPass.sol";
/// @custom:security-contact [email protected]
contract Minter is Ownable, ReentrancyGuard, Pausable {
PrysmAccessPass _nft;
constructor(address nft) {
}
mapping(uint256 => bytes32) _tokenTypes;
mapping(uint256 => mapping(address => bool)) private _mintApprovals;
mapping(address => mapping(uint256 => bool)) private _hasMinted;
function modifyType(
uint256 _id,
bytes32 _root
) public onlyOwner {
}
function mintOwner(address to, uint256 id, uint256 amount, bytes memory data)
public
onlyOwner
{
}
function transferOwnershipProxy(address account)
public
onlyOwner
{
}
function pauseProxy()
public
onlyOwner
{
}
function unpauseProxy()
public
onlyOwner
{
}
function pause()
public
onlyOwner
{
}
function unpause()
public
onlyOwner
{
}
function setURIProxy(string memory newuri)
public
onlyOwner
{
}
function mint(uint256 tokenId, bytes32[] calldata proof)
external
nonReentrant
whenNotPaused
{
address to = msg.sender;
require(<FILL_ME>)
require(_mintApprovals[tokenId][to] || _verify(tokenId, to, proof), "Invalid merkle proof");
_mintApprovals[tokenId][to] = false;
_hasMinted[to][tokenId] = true;
_nft.mint(to, tokenId, 1, bytes(""));
}
function canMintToken(address to, uint256 tokenId, bytes32[] calldata proof)
external
view
returns (bool)
{
}
function setMintApproval(
address to,
bool value,
uint256 id
) external onlyOwner {
}
function _leaf(address to, uint256 tokenId)
internal pure returns (bytes32)
{
}
function _verify(uint256 tokenId, address to, bytes32[] memory proof)
internal view returns (bool)
{
}
}
| !_hasMinted[to][tokenId],"Already minted" | 113,004 | !_hasMinted[to][tokenId] |
"Invalid merkle proof" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./PrysmAccessPass.sol";
/// @custom:security-contact [email protected]
contract Minter is Ownable, ReentrancyGuard, Pausable {
PrysmAccessPass _nft;
constructor(address nft) {
}
mapping(uint256 => bytes32) _tokenTypes;
mapping(uint256 => mapping(address => bool)) private _mintApprovals;
mapping(address => mapping(uint256 => bool)) private _hasMinted;
function modifyType(
uint256 _id,
bytes32 _root
) public onlyOwner {
}
function mintOwner(address to, uint256 id, uint256 amount, bytes memory data)
public
onlyOwner
{
}
function transferOwnershipProxy(address account)
public
onlyOwner
{
}
function pauseProxy()
public
onlyOwner
{
}
function unpauseProxy()
public
onlyOwner
{
}
function pause()
public
onlyOwner
{
}
function unpause()
public
onlyOwner
{
}
function setURIProxy(string memory newuri)
public
onlyOwner
{
}
function mint(uint256 tokenId, bytes32[] calldata proof)
external
nonReentrant
whenNotPaused
{
address to = msg.sender;
require(
!_hasMinted[to][tokenId],
"Already minted"
);
require(<FILL_ME>)
_mintApprovals[tokenId][to] = false;
_hasMinted[to][tokenId] = true;
_nft.mint(to, tokenId, 1, bytes(""));
}
function canMintToken(address to, uint256 tokenId, bytes32[] calldata proof)
external
view
returns (bool)
{
}
function setMintApproval(
address to,
bool value,
uint256 id
) external onlyOwner {
}
function _leaf(address to, uint256 tokenId)
internal pure returns (bytes32)
{
}
function _verify(uint256 tokenId, address to, bytes32[] memory proof)
internal view returns (bool)
{
}
}
| _mintApprovals[tokenId][to]||_verify(tokenId,to,proof),"Invalid merkle proof" | 113,004 | _mintApprovals[tokenId][to]||_verify(tokenId,to,proof) |
"Not enough tokens left" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract ORDINALGOBLIN is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
uint public constant MAX_TOKENS = 5000;
uint256 public PRICE = 0.005 ether;
uint public perAddressLimit = 100;
uint public constant MAX_PER_MINT = 100;
bool public saleIsActive = true;
bool public revealed = true;
bool public paused = false;
string private _baseTokenURI;
string public notRevealedUri;
bool public _paused;
modifier onlyWhenNotPaused {
}
mapping(address => uint) public addressMintedBalance;
// mapping(address => bool) public whitelistClaimed;
constructor() ERC721A("ORDINAL GOBLIN", "OG") {}
function _startTokenId() internal view virtual override returns (uint256) {
}
function mint(uint256 quantity) external payable onlyWhenNotPaused{
require(<FILL_ME>)
require(quantity + _numberMinted(msg.sender) <= perAddressLimit, "Exceeded the limit per wallet");
require(msg.value >= (PRICE * quantity), "Not enough ether sent");
require(quantity > 0 && quantity <= MAX_PER_MINT, "Exceeded the limit per transaction");
_safeMint(msg.sender, quantity);
}
function setPaused(bool val) public onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public onlyOwner {
}
////
//URI management part
////
function _setBaseURI(string memory baseURI) internal virtual {
}
function burn(uint256 tokenId) external {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function setPUBLIC_SALE_PRICE(uint256 _newCost) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdraw() public onlyOwner {
}
}
| totalSupply()+quantity<=MAX_TOKENS,"Not enough tokens left" | 113,206 | totalSupply()+quantity<=MAX_TOKENS |
"Exceeded the limit per wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract ORDINALGOBLIN is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
uint public constant MAX_TOKENS = 5000;
uint256 public PRICE = 0.005 ether;
uint public perAddressLimit = 100;
uint public constant MAX_PER_MINT = 100;
bool public saleIsActive = true;
bool public revealed = true;
bool public paused = false;
string private _baseTokenURI;
string public notRevealedUri;
bool public _paused;
modifier onlyWhenNotPaused {
}
mapping(address => uint) public addressMintedBalance;
// mapping(address => bool) public whitelistClaimed;
constructor() ERC721A("ORDINAL GOBLIN", "OG") {}
function _startTokenId() internal view virtual override returns (uint256) {
}
function mint(uint256 quantity) external payable onlyWhenNotPaused{
require(totalSupply() + quantity <= MAX_TOKENS, "Not enough tokens left");
require(<FILL_ME>)
require(msg.value >= (PRICE * quantity), "Not enough ether sent");
require(quantity > 0 && quantity <= MAX_PER_MINT, "Exceeded the limit per transaction");
_safeMint(msg.sender, quantity);
}
function setPaused(bool val) public onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public onlyOwner {
}
////
//URI management part
////
function _setBaseURI(string memory baseURI) internal virtual {
}
function burn(uint256 tokenId) external {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function setPUBLIC_SALE_PRICE(uint256 _newCost) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdraw() public onlyOwner {
}
}
| quantity+_numberMinted(msg.sender)<=perAddressLimit,"Exceeded the limit per wallet" | 113,206 | quantity+_numberMinted(msg.sender)<=perAddressLimit |
"Not enough ether sent" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract ORDINALGOBLIN is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
uint public constant MAX_TOKENS = 5000;
uint256 public PRICE = 0.005 ether;
uint public perAddressLimit = 100;
uint public constant MAX_PER_MINT = 100;
bool public saleIsActive = true;
bool public revealed = true;
bool public paused = false;
string private _baseTokenURI;
string public notRevealedUri;
bool public _paused;
modifier onlyWhenNotPaused {
}
mapping(address => uint) public addressMintedBalance;
// mapping(address => bool) public whitelistClaimed;
constructor() ERC721A("ORDINAL GOBLIN", "OG") {}
function _startTokenId() internal view virtual override returns (uint256) {
}
function mint(uint256 quantity) external payable onlyWhenNotPaused{
require(totalSupply() + quantity <= MAX_TOKENS, "Not enough tokens left");
require(quantity + _numberMinted(msg.sender) <= perAddressLimit, "Exceeded the limit per wallet");
require(<FILL_ME>)
require(quantity > 0 && quantity <= MAX_PER_MINT, "Exceeded the limit per transaction");
_safeMint(msg.sender, quantity);
}
function setPaused(bool val) public onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public onlyOwner {
}
////
//URI management part
////
function _setBaseURI(string memory baseURI) internal virtual {
}
function burn(uint256 tokenId) external {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function setPUBLIC_SALE_PRICE(uint256 _newCost) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdraw() public onlyOwner {
}
}
| msg.value>=(PRICE*quantity),"Not enough ether sent" | 113,206 | msg.value>=(PRICE*quantity) |
"Error: Max supply reached" | pragma solidity ^0.8.4;
contract WAGAI is ERC721A, Ownable {
string public baseURI;
uint256 public maxAI = 6666;
uint256 public maxQty = 1;
constructor(string memory _initBaseURI) ERC721A("We Are All Going to AI", "WAGAI") {
}
function _baseURI() internal view override returns (string memory) {
}
function mint(uint256 qty) public {
uint256 totalAI = totalSupply();
require(<FILL_ME>)
require(balanceOf(msg.sender) + qty <= maxQty, "Error: Max qty per wallet reached");
_safeMint(msg.sender, qty);
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setMaxQty(uint256 _newmaxQty) public onlyOwner {
}
}
| totalAI+qty<=maxAI,"Error: Max supply reached" | 113,272 | totalAI+qty<=maxAI |
"Error: Max qty per wallet reached" | pragma solidity ^0.8.4;
contract WAGAI is ERC721A, Ownable {
string public baseURI;
uint256 public maxAI = 6666;
uint256 public maxQty = 1;
constructor(string memory _initBaseURI) ERC721A("We Are All Going to AI", "WAGAI") {
}
function _baseURI() internal view override returns (string memory) {
}
function mint(uint256 qty) public {
uint256 totalAI = totalSupply();
require(totalAI + qty <= maxAI, "Error: Max supply reached");
require(<FILL_ME>)
_safeMint(msg.sender, qty);
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setMaxQty(uint256 _newmaxQty) public onlyOwner {
}
}
| balanceOf(msg.sender)+qty<=maxQty,"Error: Max qty per wallet reached" | 113,272 | balanceOf(msg.sender)+qty<=maxQty |
"Vesting: invalid ASX token address" | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.10;
import "./interfaces/IVesting.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
/**
* @title Vesting contract.
* @author Asymetrix Protocol Inc Team
* @notice An implementation of a Vesting contract for ASX token distribution
* using vesting schedules.
*/
contract Vesting is Ownable, IVesting {
using SafeERC20 for IERC20;
using Address for address;
mapping(uint256 => VestingSchedule) private vestingSchedules;
IERC20 private immutable token;
uint256 private vestingSchedulesCount;
uint256 private totalDistributionAmount;
uint256 private totalReleasedAmount;
/**
* @notice Сonstructor of this Vesting contract.
* @dev Sets ASX token contract address.
* @param _token ASX token contract address.
*/
constructor(address _token) {
require(<FILL_ME>)
token = IERC20(_token);
}
/**
* @notice Returns the ASX token address.
* @return The ASX token address.
*/
function getToken() external view returns (address) {
}
/**
* @notice Returns total vesting schedules count.
* @return Total vesting schedules count.
*/
function getVestingSchedulesCount() external view returns (uint256) {
}
/**
* @notice Returns total distribution amount for all vesting schedules.
* @return Total distribution amount for all vesting schedules.
*/
function getTotalDistributionAmount() external view returns (uint256) {
}
/**
* @notice Returns total released amount for all vesting schedules.
* @return Total released amount for all vesting schedules.
*/
function getTotalReleasedAmount() external view returns (uint256) {
}
/**
* @notice Returns a vesting schedule by it's ID. If no vesting schedule
* exist with provided ID, returns an empty vesting schedule.
* @param _vsid An ID of a vesting schedule.
* @return A vesting schedule structure.
*/
function getVestingSchedule(
uint256 _vsid
) external view returns (VestingSchedule memory) {
}
/**
* @notice Returns a list of vesting schedules paginated by their IDs.
* @param _fromVsid An ID of a vesting schedule to start.
* @param _toVsid An ID of a vesting schedule to finish.
* @return A list with the found vesting schedule structures.
*/
function getPaginatedVestingSchedules(
uint256 _fromVsid,
uint256 _toVsid
) external view returns (VestingSchedule[] memory) {
}
/**
* @notice Returns releasable amount for a vesting schedule by provided ID.
* If no vesting schedule exist with provided ID, returns zero.
* @param _vsid An ID of a vesting schedule.
* @return A releasable amount.
*/
function getReleasableAmount(
uint256 _vsid
) external view returns (uint256) {
}
/**
* @notice Creates a new vesting schedules in a batch by an owner.
* @param _accounts An array of addresses of users for whom new vesting
* schedules should be created.
* @param _amounts An array of vesting schedules distribution amounts.
* @param _lockPeriods An array of lock period durations (in seconds) that
* should have place before distribution will start.
* @param _releasePeriods An array of periods (in seconds) during wich ASX
* tokens will be distributed after the lock period.
*/
function createVestingSchedule(
address[] memory _accounts,
uint256[] memory _amounts,
uint32[] memory _lockPeriods,
uint32[] memory _releasePeriods
) external onlyOwner {
}
/**
* @notice Releases ASX tokens for a specified vesting schedule IDs in a
* batch.
* @param _vsids An array of vesting schedule IDs.
* @param _recipients An array of recipients of unlocked ASX tokens.
*/
function release(
uint256[] memory _vsids,
address[] memory _recipients
) external {
}
/**
* @notice Withdraws unused ASX tokens or othe tokens (including ETH) by an
* owner.
* @param _token A token to withdraw. If equal to zero address - withdraws
* ETH.
* @param _amount An amount of tokens for withdraw.
* @param _recipient A recipient of withdrawn tokens.
*/
function withdraw(
address _token,
uint256 _amount,
address _recipient
) external onlyOwner {
}
/**
* @notice Returns an amount available for withdrawal (unused ASX tokens
* amount) by an owner.
* @return A withdrawable amount.
*/
function getWithdrawableASXAmount() public view returns (uint256) {
}
/**
* @notice Creates a new vesting schedule.
* @param _account An address of a user for whom a new vesting schedule
* should be created.
* @param _amount Vesting schedule distribution amount.
* @param _lockPeriod A lock period duration (in seconds) that should have
* place before distribution will start.
* @param _releasePeriod A period (in seconds) during wich ASX tokens will
* be distributed after the lock period.
*/
function _createVestingSchedule(
address _account,
uint256 _amount,
uint32 _lockPeriod,
uint32 _releasePeriod
) private {
}
/**
* @notice Releases ASX tokens for a specified vesting schedule ID.
* @param _vsid A vesting schedule ID.
* @param _recipient A recipient of unlocked ASX tokens.
*/
function _release(uint256 _vsid, address _recipient) private {
}
/**
* @notice A method for computing a releasable amount for a vesting
* schedule.
* @param _vestingSchedule A vesting schedule for which to compute a
* releasable amount.
*/
function _computeReleasableAmount(
VestingSchedule memory _vestingSchedule
) private view returns (uint256) {
}
}
| _token.isContract(),"Vesting: invalid ASX token address" | 113,283 | _token.isContract() |
"Vesting: not enough unused ASX tokens" | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.10;
import "./interfaces/IVesting.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
/**
* @title Vesting contract.
* @author Asymetrix Protocol Inc Team
* @notice An implementation of a Vesting contract for ASX token distribution
* using vesting schedules.
*/
contract Vesting is Ownable, IVesting {
using SafeERC20 for IERC20;
using Address for address;
mapping(uint256 => VestingSchedule) private vestingSchedules;
IERC20 private immutable token;
uint256 private vestingSchedulesCount;
uint256 private totalDistributionAmount;
uint256 private totalReleasedAmount;
/**
* @notice Сonstructor of this Vesting contract.
* @dev Sets ASX token contract address.
* @param _token ASX token contract address.
*/
constructor(address _token) {
}
/**
* @notice Returns the ASX token address.
* @return The ASX token address.
*/
function getToken() external view returns (address) {
}
/**
* @notice Returns total vesting schedules count.
* @return Total vesting schedules count.
*/
function getVestingSchedulesCount() external view returns (uint256) {
}
/**
* @notice Returns total distribution amount for all vesting schedules.
* @return Total distribution amount for all vesting schedules.
*/
function getTotalDistributionAmount() external view returns (uint256) {
}
/**
* @notice Returns total released amount for all vesting schedules.
* @return Total released amount for all vesting schedules.
*/
function getTotalReleasedAmount() external view returns (uint256) {
}
/**
* @notice Returns a vesting schedule by it's ID. If no vesting schedule
* exist with provided ID, returns an empty vesting schedule.
* @param _vsid An ID of a vesting schedule.
* @return A vesting schedule structure.
*/
function getVestingSchedule(
uint256 _vsid
) external view returns (VestingSchedule memory) {
}
/**
* @notice Returns a list of vesting schedules paginated by their IDs.
* @param _fromVsid An ID of a vesting schedule to start.
* @param _toVsid An ID of a vesting schedule to finish.
* @return A list with the found vesting schedule structures.
*/
function getPaginatedVestingSchedules(
uint256 _fromVsid,
uint256 _toVsid
) external view returns (VestingSchedule[] memory) {
}
/**
* @notice Returns releasable amount for a vesting schedule by provided ID.
* If no vesting schedule exist with provided ID, returns zero.
* @param _vsid An ID of a vesting schedule.
* @return A releasable amount.
*/
function getReleasableAmount(
uint256 _vsid
) external view returns (uint256) {
}
/**
* @notice Creates a new vesting schedules in a batch by an owner.
* @param _accounts An array of addresses of users for whom new vesting
* schedules should be created.
* @param _amounts An array of vesting schedules distribution amounts.
* @param _lockPeriods An array of lock period durations (in seconds) that
* should have place before distribution will start.
* @param _releasePeriods An array of periods (in seconds) during wich ASX
* tokens will be distributed after the lock period.
*/
function createVestingSchedule(
address[] memory _accounts,
uint256[] memory _amounts,
uint32[] memory _lockPeriods,
uint32[] memory _releasePeriods
) external onlyOwner {
}
/**
* @notice Releases ASX tokens for a specified vesting schedule IDs in a
* batch.
* @param _vsids An array of vesting schedule IDs.
* @param _recipients An array of recipients of unlocked ASX tokens.
*/
function release(
uint256[] memory _vsids,
address[] memory _recipients
) external {
}
/**
* @notice Withdraws unused ASX tokens or othe tokens (including ETH) by an
* owner.
* @param _token A token to withdraw. If equal to zero address - withdraws
* ETH.
* @param _amount An amount of tokens for withdraw.
* @param _recipient A recipient of withdrawn tokens.
*/
function withdraw(
address _token,
uint256 _amount,
address _recipient
) external onlyOwner {
require(_recipient != address(0), "Vesting: invalid recipient address");
if (_token == address(0)) {
payable(_recipient).transfer(_amount);
} else if (_token != address(token)) {
IERC20(_token).safeTransfer(_recipient, _amount);
} else {
require(<FILL_ME>)
token.safeTransfer(_recipient, _amount);
}
emit Withdrawn(_token, _recipient, _amount);
}
/**
* @notice Returns an amount available for withdrawal (unused ASX tokens
* amount) by an owner.
* @return A withdrawable amount.
*/
function getWithdrawableASXAmount() public view returns (uint256) {
}
/**
* @notice Creates a new vesting schedule.
* @param _account An address of a user for whom a new vesting schedule
* should be created.
* @param _amount Vesting schedule distribution amount.
* @param _lockPeriod A lock period duration (in seconds) that should have
* place before distribution will start.
* @param _releasePeriod A period (in seconds) during wich ASX tokens will
* be distributed after the lock period.
*/
function _createVestingSchedule(
address _account,
uint256 _amount,
uint32 _lockPeriod,
uint32 _releasePeriod
) private {
}
/**
* @notice Releases ASX tokens for a specified vesting schedule ID.
* @param _vsid A vesting schedule ID.
* @param _recipient A recipient of unlocked ASX tokens.
*/
function _release(uint256 _vsid, address _recipient) private {
}
/**
* @notice A method for computing a releasable amount for a vesting
* schedule.
* @param _vestingSchedule A vesting schedule for which to compute a
* releasable amount.
*/
function _computeReleasableAmount(
VestingSchedule memory _vestingSchedule
) private view returns (uint256) {
}
}
| getWithdrawableASXAmount()>=_amount,"Vesting: not enough unused ASX tokens" | 113,283 | getWithdrawableASXAmount()>=_amount |
"Vesting: vesting schedule is ended" | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.10;
import "./interfaces/IVesting.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
/**
* @title Vesting contract.
* @author Asymetrix Protocol Inc Team
* @notice An implementation of a Vesting contract for ASX token distribution
* using vesting schedules.
*/
contract Vesting is Ownable, IVesting {
using SafeERC20 for IERC20;
using Address for address;
mapping(uint256 => VestingSchedule) private vestingSchedules;
IERC20 private immutable token;
uint256 private vestingSchedulesCount;
uint256 private totalDistributionAmount;
uint256 private totalReleasedAmount;
/**
* @notice Сonstructor of this Vesting contract.
* @dev Sets ASX token contract address.
* @param _token ASX token contract address.
*/
constructor(address _token) {
}
/**
* @notice Returns the ASX token address.
* @return The ASX token address.
*/
function getToken() external view returns (address) {
}
/**
* @notice Returns total vesting schedules count.
* @return Total vesting schedules count.
*/
function getVestingSchedulesCount() external view returns (uint256) {
}
/**
* @notice Returns total distribution amount for all vesting schedules.
* @return Total distribution amount for all vesting schedules.
*/
function getTotalDistributionAmount() external view returns (uint256) {
}
/**
* @notice Returns total released amount for all vesting schedules.
* @return Total released amount for all vesting schedules.
*/
function getTotalReleasedAmount() external view returns (uint256) {
}
/**
* @notice Returns a vesting schedule by it's ID. If no vesting schedule
* exist with provided ID, returns an empty vesting schedule.
* @param _vsid An ID of a vesting schedule.
* @return A vesting schedule structure.
*/
function getVestingSchedule(
uint256 _vsid
) external view returns (VestingSchedule memory) {
}
/**
* @notice Returns a list of vesting schedules paginated by their IDs.
* @param _fromVsid An ID of a vesting schedule to start.
* @param _toVsid An ID of a vesting schedule to finish.
* @return A list with the found vesting schedule structures.
*/
function getPaginatedVestingSchedules(
uint256 _fromVsid,
uint256 _toVsid
) external view returns (VestingSchedule[] memory) {
}
/**
* @notice Returns releasable amount for a vesting schedule by provided ID.
* If no vesting schedule exist with provided ID, returns zero.
* @param _vsid An ID of a vesting schedule.
* @return A releasable amount.
*/
function getReleasableAmount(
uint256 _vsid
) external view returns (uint256) {
}
/**
* @notice Creates a new vesting schedules in a batch by an owner.
* @param _accounts An array of addresses of users for whom new vesting
* schedules should be created.
* @param _amounts An array of vesting schedules distribution amounts.
* @param _lockPeriods An array of lock period durations (in seconds) that
* should have place before distribution will start.
* @param _releasePeriods An array of periods (in seconds) during wich ASX
* tokens will be distributed after the lock period.
*/
function createVestingSchedule(
address[] memory _accounts,
uint256[] memory _amounts,
uint32[] memory _lockPeriods,
uint32[] memory _releasePeriods
) external onlyOwner {
}
/**
* @notice Releases ASX tokens for a specified vesting schedule IDs in a
* batch.
* @param _vsids An array of vesting schedule IDs.
* @param _recipients An array of recipients of unlocked ASX tokens.
*/
function release(
uint256[] memory _vsids,
address[] memory _recipients
) external {
}
/**
* @notice Withdraws unused ASX tokens or othe tokens (including ETH) by an
* owner.
* @param _token A token to withdraw. If equal to zero address - withdraws
* ETH.
* @param _amount An amount of tokens for withdraw.
* @param _recipient A recipient of withdrawn tokens.
*/
function withdraw(
address _token,
uint256 _amount,
address _recipient
) external onlyOwner {
}
/**
* @notice Returns an amount available for withdrawal (unused ASX tokens
* amount) by an owner.
* @return A withdrawable amount.
*/
function getWithdrawableASXAmount() public view returns (uint256) {
}
/**
* @notice Creates a new vesting schedule.
* @param _account An address of a user for whom a new vesting schedule
* should be created.
* @param _amount Vesting schedule distribution amount.
* @param _lockPeriod A lock period duration (in seconds) that should have
* place before distribution will start.
* @param _releasePeriod A period (in seconds) during wich ASX tokens will
* be distributed after the lock period.
*/
function _createVestingSchedule(
address _account,
uint256 _amount,
uint32 _lockPeriod,
uint32 _releasePeriod
) private {
}
/**
* @notice Releases ASX tokens for a specified vesting schedule ID.
* @param _vsid A vesting schedule ID.
* @param _recipient A recipient of unlocked ASX tokens.
*/
function _release(uint256 _vsid, address _recipient) private {
require(_recipient != address(0), "Vesting: invalid recipient address");
VestingSchedule memory _vestingSchedule = vestingSchedules[_vsid];
require(
_vestingSchedule.startTimestamp != 0,
"Vesting: vesting schedule does not exist"
);
require(
_vestingSchedule.owner == msg.sender,
"Vesting: caller is not an owner of a vesting schedule"
);
require(<FILL_ME>)
uint256 _amount = _computeReleasableAmount(_vestingSchedule);
require(_amount > 0, "Vesting: nothing to release");
vestingSchedules[_vsid].released += _amount;
totalReleasedAmount += _amount;
totalDistributionAmount -= _amount;
token.safeTransfer(_recipient, _amount);
emit Released(_vsid, _recipient, _amount);
}
/**
* @notice A method for computing a releasable amount for a vesting
* schedule.
* @param _vestingSchedule A vesting schedule for which to compute a
* releasable amount.
*/
function _computeReleasableAmount(
VestingSchedule memory _vestingSchedule
) private view returns (uint256) {
}
}
| vestingSchedules[_vsid].released!=vestingSchedules[_vsid].amount,"Vesting: vesting schedule is ended" | 113,283 | vestingSchedules[_vsid].released!=vestingSchedules[_vsid].amount |
"ModifyPaymentToken: Already set to this value" | pragma solidity ^0.8.16;
contract PurchaseRight is Ownable, IERC721Receiver, ReentrancyGuard {
string public name;
IERC20 public paymentToken;
SignataRight public signataRight;
SignataIdentity public signataIdentity;
uint256 public feeAmount = 100 * 1e18;
uint256 public schemaId;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
bool public collectNative = false;
bool public purchasesEnabled = true;
event ModifiedFee(uint256 oldAmount, uint256 newAmount);
event FeesTaken(uint256 feesAmount);
event RightPurchased(address identity);
event CollectNativeModified(bool newValue);
event TokenModified(address newAddress);
event PaymentTokenModified(address newToken);
event PurchasesEnabledModified(bool newValue);
constructor(
address _paymentToken,
address _signataRight,
address _signataIdentity,
string memory _name
) {
}
receive() external payable {}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
)
external
pure
returns (bytes4)
{
}
function mintSchema(
string memory _schemaURI
) external onlyOwner {
}
function purchaseRight(
address delegate
)
external
nonReentrant
{
}
function modifyFee(
uint256 newAmount
)
external
onlyOwner
{
}
function modifyCollectNative(
bool _collectNative
)
external
onlyOwner
{
}
function modifyPurchasesEnabled(
bool _purchasedEnabled
)
external
onlyOwner
{
}
function modifyPaymentToken(
address newToken
)
external
onlyOwner
{
require(<FILL_ME>)
paymentToken = IERC20(newToken);
emit PaymentTokenModified(newToken);
}
function withdrawCollectedFees()
external
onlyOwner
{
}
function withdrawNative()
external
onlyOwner
returns (bool)
{
}
}
| address(paymentToken)!=newToken,"ModifyPaymentToken: Already set to this value" | 113,359 | address(paymentToken)!=newToken |
"adminVoting must be a contract" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "Address.sol";
import { Ownable } from "Ownable.sol";
import "IPrismaCore.sol";
/**
@title Prisma DAO Interim Admin
@notice Temporary ownership contract for all Prisma contracts during bootstrap phase. Allows executing
arbitrary function calls by the deployer following a minimum time before execution.
The protocol guardian can cancel any proposals and cannot be replaced.
To avoid a malicious flood attack the number of daily proposals is capped.
*/
contract InterimAdmin is Ownable {
using Address for address;
event ProposalCreated(uint256 proposalId, Action[] payload);
event ProposalExecuted(uint256 proposalId);
event ProposalCancelled(uint256 proposalId);
struct Proposal {
uint32 createdAt; // timestamp when the proposal was created
uint32 canExecuteAfter; // earliest timestamp when proposal can be executed (0 if not passed)
bool processed; // set to true once the proposal is processed
}
struct Action {
address target;
bytes data;
}
uint256 public constant MIN_TIME_TO_EXECUTION = 1 days;
uint256 public constant MAX_TIME_TO_EXECUTION = 3 weeks;
uint256 public constant MAX_DAILY_PROPOSALS = 3;
IPrismaCore public immutable prismaCore;
address public adminVoting;
Proposal[] proposalData;
mapping(uint256 => Action[]) proposalPayloads;
mapping(uint256 => uint256) dailyProposalsCount;
constructor(address _prismaCore) {
}
function setAdminVoting(address _adminVoting) external onlyOwner {
require(adminVoting == address(0), "Already set");
require(<FILL_ME>)
adminVoting = _adminVoting;
}
/**
@notice The total number of votes created
*/
function getProposalCount() external view returns (uint256) {
}
/**
@notice Gets information on a specific proposal
*/
function getProposalData(
uint256 id
)
external
view
returns (uint256 createdAt, uint256 canExecuteAfter, bool executed, bool canExecute, Action[] memory payload)
{
}
/**
@notice Create a new proposal
@param payload Tuple of [(target address, calldata), ... ] to be
executed if the proposal is passed.
*/
function createNewProposal(Action[] calldata payload) external onlyOwner {
}
/**
@notice Cancels a pending proposal
@dev Can only be called by the guardian to avoid malicious proposals
The guardian cannot cancel a proposal where the only action is
changing the guardian.
@param id Proposal ID
*/
function cancelProposal(uint256 id) external {
}
/**
@notice Execute a proposal's payload
@dev Can only be called if the proposal has been active for at least `MIN_TIME_TO_EXECUTION`
@param id Proposal ID
*/
function executeProposal(uint256 id) external onlyOwner {
}
/**
@dev Allow accepting ownership transfer of `PrismaCore`
*/
function acceptTransferOwnership() external onlyOwner {
}
/**
@dev Restricted method to transfer ownership of `PrismaCore`
to the actual Admin voting contract
*/
function transferOwnershipToAdminVoting() external {
}
function _isSetGuardianPayload(Action memory action) internal pure returns (bool) {
}
}
| _adminVoting.isContract(),"adminVoting must be a contract" | 113,566 | _adminVoting.isContract() |
"Cannot change guardian" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "Address.sol";
import { Ownable } from "Ownable.sol";
import "IPrismaCore.sol";
/**
@title Prisma DAO Interim Admin
@notice Temporary ownership contract for all Prisma contracts during bootstrap phase. Allows executing
arbitrary function calls by the deployer following a minimum time before execution.
The protocol guardian can cancel any proposals and cannot be replaced.
To avoid a malicious flood attack the number of daily proposals is capped.
*/
contract InterimAdmin is Ownable {
using Address for address;
event ProposalCreated(uint256 proposalId, Action[] payload);
event ProposalExecuted(uint256 proposalId);
event ProposalCancelled(uint256 proposalId);
struct Proposal {
uint32 createdAt; // timestamp when the proposal was created
uint32 canExecuteAfter; // earliest timestamp when proposal can be executed (0 if not passed)
bool processed; // set to true once the proposal is processed
}
struct Action {
address target;
bytes data;
}
uint256 public constant MIN_TIME_TO_EXECUTION = 1 days;
uint256 public constant MAX_TIME_TO_EXECUTION = 3 weeks;
uint256 public constant MAX_DAILY_PROPOSALS = 3;
IPrismaCore public immutable prismaCore;
address public adminVoting;
Proposal[] proposalData;
mapping(uint256 => Action[]) proposalPayloads;
mapping(uint256 => uint256) dailyProposalsCount;
constructor(address _prismaCore) {
}
function setAdminVoting(address _adminVoting) external onlyOwner {
}
/**
@notice The total number of votes created
*/
function getProposalCount() external view returns (uint256) {
}
/**
@notice Gets information on a specific proposal
*/
function getProposalData(
uint256 id
)
external
view
returns (uint256 createdAt, uint256 canExecuteAfter, bool executed, bool canExecute, Action[] memory payload)
{
}
/**
@notice Create a new proposal
@param payload Tuple of [(target address, calldata), ... ] to be
executed if the proposal is passed.
*/
function createNewProposal(Action[] calldata payload) external onlyOwner {
require(payload.length > 0, "Empty payload");
uint256 day = block.timestamp / 1 days;
uint256 currentDailyCount = dailyProposalsCount[day];
require(currentDailyCount < MAX_DAILY_PROPOSALS, "MAX_DAILY_PROPOSALS");
uint loopEnd = payload.length;
for (uint256 i; i < loopEnd; i++) {
require(<FILL_ME>)
}
dailyProposalsCount[day] = currentDailyCount + 1;
uint256 idx = proposalData.length;
proposalData.push(
Proposal({
createdAt: uint32(block.timestamp),
canExecuteAfter: uint32(block.timestamp + MIN_TIME_TO_EXECUTION),
processed: false
})
);
for (uint256 i = 0; i < payload.length; i++) {
proposalPayloads[idx].push(payload[i]);
}
emit ProposalCreated(idx, payload);
}
/**
@notice Cancels a pending proposal
@dev Can only be called by the guardian to avoid malicious proposals
The guardian cannot cancel a proposal where the only action is
changing the guardian.
@param id Proposal ID
*/
function cancelProposal(uint256 id) external {
}
/**
@notice Execute a proposal's payload
@dev Can only be called if the proposal has been active for at least `MIN_TIME_TO_EXECUTION`
@param id Proposal ID
*/
function executeProposal(uint256 id) external onlyOwner {
}
/**
@dev Allow accepting ownership transfer of `PrismaCore`
*/
function acceptTransferOwnership() external onlyOwner {
}
/**
@dev Restricted method to transfer ownership of `PrismaCore`
to the actual Admin voting contract
*/
function transferOwnershipToAdminVoting() external {
}
function _isSetGuardianPayload(Action memory action) internal pure returns (bool) {
}
}
| !_isSetGuardianPayload(payload[i]),"Cannot change guardian" | 113,566 | !_isSetGuardianPayload(payload[i]) |
"Already processed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "Address.sol";
import { Ownable } from "Ownable.sol";
import "IPrismaCore.sol";
/**
@title Prisma DAO Interim Admin
@notice Temporary ownership contract for all Prisma contracts during bootstrap phase. Allows executing
arbitrary function calls by the deployer following a minimum time before execution.
The protocol guardian can cancel any proposals and cannot be replaced.
To avoid a malicious flood attack the number of daily proposals is capped.
*/
contract InterimAdmin is Ownable {
using Address for address;
event ProposalCreated(uint256 proposalId, Action[] payload);
event ProposalExecuted(uint256 proposalId);
event ProposalCancelled(uint256 proposalId);
struct Proposal {
uint32 createdAt; // timestamp when the proposal was created
uint32 canExecuteAfter; // earliest timestamp when proposal can be executed (0 if not passed)
bool processed; // set to true once the proposal is processed
}
struct Action {
address target;
bytes data;
}
uint256 public constant MIN_TIME_TO_EXECUTION = 1 days;
uint256 public constant MAX_TIME_TO_EXECUTION = 3 weeks;
uint256 public constant MAX_DAILY_PROPOSALS = 3;
IPrismaCore public immutable prismaCore;
address public adminVoting;
Proposal[] proposalData;
mapping(uint256 => Action[]) proposalPayloads;
mapping(uint256 => uint256) dailyProposalsCount;
constructor(address _prismaCore) {
}
function setAdminVoting(address _adminVoting) external onlyOwner {
}
/**
@notice The total number of votes created
*/
function getProposalCount() external view returns (uint256) {
}
/**
@notice Gets information on a specific proposal
*/
function getProposalData(
uint256 id
)
external
view
returns (uint256 createdAt, uint256 canExecuteAfter, bool executed, bool canExecute, Action[] memory payload)
{
}
/**
@notice Create a new proposal
@param payload Tuple of [(target address, calldata), ... ] to be
executed if the proposal is passed.
*/
function createNewProposal(Action[] calldata payload) external onlyOwner {
}
/**
@notice Cancels a pending proposal
@dev Can only be called by the guardian to avoid malicious proposals
The guardian cannot cancel a proposal where the only action is
changing the guardian.
@param id Proposal ID
*/
function cancelProposal(uint256 id) external {
}
/**
@notice Execute a proposal's payload
@dev Can only be called if the proposal has been active for at least `MIN_TIME_TO_EXECUTION`
@param id Proposal ID
*/
function executeProposal(uint256 id) external onlyOwner {
require(id < proposalData.length, "Invalid ID");
Proposal memory proposal = proposalData[id];
require(<FILL_ME>)
uint256 executeAfter = proposal.canExecuteAfter;
require(executeAfter < block.timestamp, "MIN_TIME_TO_EXECUTION");
require(executeAfter + MAX_TIME_TO_EXECUTION > block.timestamp, "MAX_TIME_TO_EXECUTION");
proposalData[id].processed = true;
Action[] storage payload = proposalPayloads[id];
uint256 payloadLength = payload.length;
for (uint256 i = 0; i < payloadLength; i++) {
payload[i].target.functionCall(payload[i].data);
}
emit ProposalExecuted(id);
}
/**
@dev Allow accepting ownership transfer of `PrismaCore`
*/
function acceptTransferOwnership() external onlyOwner {
}
/**
@dev Restricted method to transfer ownership of `PrismaCore`
to the actual Admin voting contract
*/
function transferOwnershipToAdminVoting() external {
}
function _isSetGuardianPayload(Action memory action) internal pure returns (bool) {
}
}
| !proposal.processed,"Already processed" | 113,566 | !proposal.processed |
"MAX_TIME_TO_EXECUTION" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "Address.sol";
import { Ownable } from "Ownable.sol";
import "IPrismaCore.sol";
/**
@title Prisma DAO Interim Admin
@notice Temporary ownership contract for all Prisma contracts during bootstrap phase. Allows executing
arbitrary function calls by the deployer following a minimum time before execution.
The protocol guardian can cancel any proposals and cannot be replaced.
To avoid a malicious flood attack the number of daily proposals is capped.
*/
contract InterimAdmin is Ownable {
using Address for address;
event ProposalCreated(uint256 proposalId, Action[] payload);
event ProposalExecuted(uint256 proposalId);
event ProposalCancelled(uint256 proposalId);
struct Proposal {
uint32 createdAt; // timestamp when the proposal was created
uint32 canExecuteAfter; // earliest timestamp when proposal can be executed (0 if not passed)
bool processed; // set to true once the proposal is processed
}
struct Action {
address target;
bytes data;
}
uint256 public constant MIN_TIME_TO_EXECUTION = 1 days;
uint256 public constant MAX_TIME_TO_EXECUTION = 3 weeks;
uint256 public constant MAX_DAILY_PROPOSALS = 3;
IPrismaCore public immutable prismaCore;
address public adminVoting;
Proposal[] proposalData;
mapping(uint256 => Action[]) proposalPayloads;
mapping(uint256 => uint256) dailyProposalsCount;
constructor(address _prismaCore) {
}
function setAdminVoting(address _adminVoting) external onlyOwner {
}
/**
@notice The total number of votes created
*/
function getProposalCount() external view returns (uint256) {
}
/**
@notice Gets information on a specific proposal
*/
function getProposalData(
uint256 id
)
external
view
returns (uint256 createdAt, uint256 canExecuteAfter, bool executed, bool canExecute, Action[] memory payload)
{
}
/**
@notice Create a new proposal
@param payload Tuple of [(target address, calldata), ... ] to be
executed if the proposal is passed.
*/
function createNewProposal(Action[] calldata payload) external onlyOwner {
}
/**
@notice Cancels a pending proposal
@dev Can only be called by the guardian to avoid malicious proposals
The guardian cannot cancel a proposal where the only action is
changing the guardian.
@param id Proposal ID
*/
function cancelProposal(uint256 id) external {
}
/**
@notice Execute a proposal's payload
@dev Can only be called if the proposal has been active for at least `MIN_TIME_TO_EXECUTION`
@param id Proposal ID
*/
function executeProposal(uint256 id) external onlyOwner {
require(id < proposalData.length, "Invalid ID");
Proposal memory proposal = proposalData[id];
require(!proposal.processed, "Already processed");
uint256 executeAfter = proposal.canExecuteAfter;
require(executeAfter < block.timestamp, "MIN_TIME_TO_EXECUTION");
require(<FILL_ME>)
proposalData[id].processed = true;
Action[] storage payload = proposalPayloads[id];
uint256 payloadLength = payload.length;
for (uint256 i = 0; i < payloadLength; i++) {
payload[i].target.functionCall(payload[i].data);
}
emit ProposalExecuted(id);
}
/**
@dev Allow accepting ownership transfer of `PrismaCore`
*/
function acceptTransferOwnership() external onlyOwner {
}
/**
@dev Restricted method to transfer ownership of `PrismaCore`
to the actual Admin voting contract
*/
function transferOwnershipToAdminVoting() external {
}
function _isSetGuardianPayload(Action memory action) internal pure returns (bool) {
}
}
| executeAfter+MAX_TIME_TO_EXECUTION>block.timestamp,"MAX_TIME_TO_EXECUTION" | 113,566 | executeAfter+MAX_TIME_TO_EXECUTION>block.timestamp |
"No whitelist" | // SPDX-License-Identifier: MIT
/**
*/
pragma solidity ^0.8.0;
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
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
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId)
external
view
returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator)
external
view
returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
pragma solidity ^0.8.0;
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);
}
pragma solidity ^0.8.0;
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
returns (uint256);
function tokenByIndex(uint256 index) external view returns (uint256);
}
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length)
internal
pure
returns (string memory)
{
}
}
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
pragma solidity ^0.8.0;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override
returns (bool)
{
}
}
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
// word because each write operation emits an extra SLOAD to first read the
// back. This is the compiler's defense against contract upgrades and
// but in exchange the refund on every call to nonReentrant will be lower in
// transaction's gas, it is best to keep them low in cases like this one, to
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
pragma solidity ^0.8.0;
contract ERC721A is
Context,
ERC165,
IERC721,
IERC721Metadata,
IERC721Enumerable
{
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 private currentIndex = 0;
uint256 internal immutable collectionSize;
uint256 internal immutable maxBatchSize;
string private _name;
string private _symbol;
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) private _ownerships;
mapping(address => AddressData) private _addressData;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(
string memory name_,
string memory symbol_,
uint256 maxBatchSize_,
uint256 collectionSize_
) {
}
function totalSupply() public view override returns (uint256) {
}
function tokenByIndex(uint256 index)
public
view
override
returns (uint256)
{
}
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
override
returns (uint256)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
}
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
function ownershipOf(uint256 tokenId)
internal
view
returns (TokenOwnership memory)
{
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual returns (string memory) {
}
function approve(address to, uint256 tokenId) public override {
}
function getApproved(uint256 tokenId)
public
view
override
returns (address)
{
}
function setApprovalForAll(address operator, bool approved)
public
override
{
}
function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
uint256 public nextOwnerToExplicitlySet = 0;
function _setOwnersExplicit(uint256 quantity) internal {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
pragma solidity ^0.8.0;
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf)
internal
pure
returns (bytes32)
{
}
function _efficientHash(bytes32 a, bytes32 b)
private
pure
returns (bytes32 value)
{
}
}
contract TheRealBanditos is Ownable, ERC721A, ReentrancyGuard {
bool public publicSale = false;
bool public whitelistSale = false;
uint256 public maxPerTx = 30;
uint256 public maxPerTxWl = 3;
uint256 public maxPerAddress = 100;
uint256 public maxToken = 3333;
uint256 public price = 0.03 ether;
string private _baseTokenURI = "";
mapping(address => bool) private _whitelist;
bytes32 root;
constructor(string memory _NAME, string memory _SYMBOL)
ERC721A(_NAME, _SYMBOL, 1000, maxToken)
{}
modifier callerIsUser() {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function verify(bytes32[] memory proof) internal view returns (bool) {
}
function mint(uint256 quantity, address _to) external payable callerIsUser {
}
function mint_(uint256 quantity) external payable callerIsUser {
require(whitelistSale, "SALE_HAS_NOT_STARTED_YET");
require(quantity > 0, "INVALID_QUANTITY");
require(quantity <= maxPerTxWl, "CANNOT_MINT_THAT_MANY");
require(totalSupply() + quantity <= maxToken, "NOT_ENOUGH_SUPPLY_TO_MINT_DESIRED_AMOUNT");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
_whitelist[msg.sender] = true;
}
function teamAllocationMint(address _address, uint256 quantity) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setPrice(uint256 _PriceInWEI) external onlyOwner {
}
function setRoot(bytes32 _root) external onlyOwner {
}
function flipPublicSaleState() external onlyOwner {
}
function flipWhitelistState() external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| _whitelist[msg.sender]!=true,"No whitelist" | 113,608 | _whitelist[msg.sender]!=true |
"Mint capacity reached" | pragma solidity ^0.8.9;
contract WnwaNFT is ERC721Enumerable, Ownable {
using Address for address;
using Strings for uint256;
uint16 constant maxTokens = 2493;
uint16 public maxTokensPerWhitelist = 4;
uint16 public maxTokensPerMint = 4;
struct NftConfig {
uint256 price;
uint256 total;
}
NftConfig public nftConf;
uint256 private _iterator;
string private _baseUri="ipfs://bafybeiepy7gczzoxyftcxffwzsdhqki2763jjibjfv4y5zsv3dylxlnwva/";
mapping(address => bool) public whitelist;
uint256 public whitelistMintDate;
uint256 public openMintDate;
constructor(uint256 _whitelistMintDate, uint256 _openMintDate)
ERC721("We Never Walk Alone","WNWA")
Ownable() {
}
function setMaxTokensPerMint(uint16 _newMaxTokensPerMint) external onlyOwner {
}
function mint(address _to, uint16 _count) external payable {
require(block.timestamp > whitelistMintDate, "Collection is not live yet");
require(block.timestamp > openMintDate || whitelist[_to], "Not Whitelisted");
require(block.timestamp > openMintDate || this.balanceOf(_to) + _count <= maxTokensPerWhitelist, "Max limit exceeded");
require(_count <= maxTokensPerMint, "Mint Limit exceeded");
require(msg.value >= nftConf.price * _count, "Price is 0.01 eth");
require(<FILL_ME>)
for(uint16 i=0;i < _count; i += 1) {
uint256 _tokenId = _iterator;
_iterator += 1;
_safeMint(_to, _tokenId);
}
}
function update(string memory _newUri) public onlyOwner {
}
function contractURI() public pure returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setWhitelist(address[] memory _whitelist) external onlyOwner {
}
function withdrawToken(address _to, uint256 _amount,IERC20 token) external onlyOwner {
}
function withdraw(address payable _to, uint256 _amount) external onlyOwner {
}
}
| maxTokens-this.totalSupply()>=_count,"Mint capacity reached" | 113,645 | maxTokens-this.totalSupply()>=_count |
"Incorrect payment amount" | // SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.17;
import "openzeppelin-contracts/access/Ownable.sol";
import "openzeppelin-contracts/token/ERC721/IERC721Receiver.sol";
import "./deployed/IImbuedNFT.sol";
import "./ImbuedData.sol";
contract ImbuedMintV3 is Ownable {
IImbuedNFT constant public NFT = IImbuedNFT(0x000001E1b2b5f9825f4d50bD4906aff2F298af4e);
IERC721 immutable public metaverseMiamiTicket;
mapping (uint256 => bool) public miamiTicketId2claimed; // token ids that are claimed.
enum Edition { LIFE, LONGING, FRIENDSHIP, FRIENDSHIP_MIAMI }
// Order relevant variables per edition so that they are packed together,
// reduced sload and sstore gas costs.
struct MintInfo {
uint16 nextId;
uint16 maxId;
bool openMint;
uint216 price;
}
MintInfo[4] public mintInfos;
constructor(address metaverseMiamiAddress) {
}
// Mint tokens of a specific edition.
function mint(Edition edition, uint8 amount) external payable {
// Check payment.
MintInfo memory info = mintInfos[uint(edition)];
require(<FILL_ME>)
require(info.openMint, "This edition cannot be minted this way");
_mint(msg.sender, edition, amount);
}
// Free mint for holders of the Metaverse Miami ticket, when they simultaneously mint one for a friend and imbue.
function mintFriendshipMiami(uint256 tokenId, address friend, string calldata imbuement) external payable {
}
// only owner
/// (Admin only) Admin can mint without paying fee, because they are allowed to withdraw anyway.
/// @param recipient what address should be sent the new token, must be an
/// EOA or contract able to receive ERC721s.
/// @param amount the number of tokens to mint, starting with id `nextId()`.
function adminMintAmount(address recipient, Edition edition, uint8 amount) external onlyOwner() {
}
/// (Admin only) Can mint *any* token ID. Intended foremost for minting
/// major versions for the artworks.
/// @param recipient what address should be sent the new token, must be an
/// EOA or contract able to receive ERC721s.
/// @param tokenId which id to mint, may not be a previously minted one.
function adminMintSpecific(address recipient, uint256 tokenId) external onlyOwner() {
}
/// (Admin only) Withdraw the entire contract balance to the recipient address.
/// @param recipient where to send the ether balance.
function withdrawAll(address payable recipient) external payable onlyOwner() {
}
/// (Admin only) Set parameters of an edition.
/// @param edition which edition to set parameters for.
/// @param nextId the next id to mint.
/// @param maxId the maximum id to mint.
/// @param price the price to mint one token.
/// @dev nextId must be <= maxId.
function setEdition(Edition edition, uint16 nextId, uint16 maxId, bool openMint, uint216 price) external onlyOwner() {
}
/// (Admin only) self-destruct the minting contract.
/// @param recipient where to send the ether balance.
function kill(address payable recipient) external payable onlyOwner() {
}
// internal
// Rethink: reentrancy danger. Here we have several nextId.
function _mint(address recipient, Edition edition, uint8 amount) internal {
}
}
| info.price*amount==msg.value,"Incorrect payment amount" | 113,718 | info.price*amount==msg.value |
"This edition cannot be minted this way" | // SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.17;
import "openzeppelin-contracts/access/Ownable.sol";
import "openzeppelin-contracts/token/ERC721/IERC721Receiver.sol";
import "./deployed/IImbuedNFT.sol";
import "./ImbuedData.sol";
contract ImbuedMintV3 is Ownable {
IImbuedNFT constant public NFT = IImbuedNFT(0x000001E1b2b5f9825f4d50bD4906aff2F298af4e);
IERC721 immutable public metaverseMiamiTicket;
mapping (uint256 => bool) public miamiTicketId2claimed; // token ids that are claimed.
enum Edition { LIFE, LONGING, FRIENDSHIP, FRIENDSHIP_MIAMI }
// Order relevant variables per edition so that they are packed together,
// reduced sload and sstore gas costs.
struct MintInfo {
uint16 nextId;
uint16 maxId;
bool openMint;
uint216 price;
}
MintInfo[4] public mintInfos;
constructor(address metaverseMiamiAddress) {
}
// Mint tokens of a specific edition.
function mint(Edition edition, uint8 amount) external payable {
// Check payment.
MintInfo memory info = mintInfos[uint(edition)];
require(info.price * amount == msg.value, "Incorrect payment amount");
require(<FILL_ME>)
_mint(msg.sender, edition, amount);
}
// Free mint for holders of the Metaverse Miami ticket, when they simultaneously mint one for a friend and imbue.
function mintFriendshipMiami(uint256 tokenId, address friend, string calldata imbuement) external payable {
}
// only owner
/// (Admin only) Admin can mint without paying fee, because they are allowed to withdraw anyway.
/// @param recipient what address should be sent the new token, must be an
/// EOA or contract able to receive ERC721s.
/// @param amount the number of tokens to mint, starting with id `nextId()`.
function adminMintAmount(address recipient, Edition edition, uint8 amount) external onlyOwner() {
}
/// (Admin only) Can mint *any* token ID. Intended foremost for minting
/// major versions for the artworks.
/// @param recipient what address should be sent the new token, must be an
/// EOA or contract able to receive ERC721s.
/// @param tokenId which id to mint, may not be a previously minted one.
function adminMintSpecific(address recipient, uint256 tokenId) external onlyOwner() {
}
/// (Admin only) Withdraw the entire contract balance to the recipient address.
/// @param recipient where to send the ether balance.
function withdrawAll(address payable recipient) external payable onlyOwner() {
}
/// (Admin only) Set parameters of an edition.
/// @param edition which edition to set parameters for.
/// @param nextId the next id to mint.
/// @param maxId the maximum id to mint.
/// @param price the price to mint one token.
/// @dev nextId must be <= maxId.
function setEdition(Edition edition, uint16 nextId, uint16 maxId, bool openMint, uint216 price) external onlyOwner() {
}
/// (Admin only) self-destruct the minting contract.
/// @param recipient where to send the ether balance.
function kill(address payable recipient) external payable onlyOwner() {
}
// internal
// Rethink: reentrancy danger. Here we have several nextId.
function _mint(address recipient, Edition edition, uint8 amount) internal {
}
}
| info.openMint,"This edition cannot be minted this way" | 113,718 | info.openMint |
"You do not own this ticket" | // SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.17;
import "openzeppelin-contracts/access/Ownable.sol";
import "openzeppelin-contracts/token/ERC721/IERC721Receiver.sol";
import "./deployed/IImbuedNFT.sol";
import "./ImbuedData.sol";
contract ImbuedMintV3 is Ownable {
IImbuedNFT constant public NFT = IImbuedNFT(0x000001E1b2b5f9825f4d50bD4906aff2F298af4e);
IERC721 immutable public metaverseMiamiTicket;
mapping (uint256 => bool) public miamiTicketId2claimed; // token ids that are claimed.
enum Edition { LIFE, LONGING, FRIENDSHIP, FRIENDSHIP_MIAMI }
// Order relevant variables per edition so that they are packed together,
// reduced sload and sstore gas costs.
struct MintInfo {
uint16 nextId;
uint16 maxId;
bool openMint;
uint216 price;
}
MintInfo[4] public mintInfos;
constructor(address metaverseMiamiAddress) {
}
// Mint tokens of a specific edition.
function mint(Edition edition, uint8 amount) external payable {
}
// Free mint for holders of the Metaverse Miami ticket, when they simultaneously mint one for a friend and imbue.
function mintFriendshipMiami(uint256 tokenId, address friend, string calldata imbuement) external payable {
MintInfo memory info = mintInfos[uint(Edition.FRIENDSHIP_MIAMI)];
require(info.price == msg.value, "Incorrect payment amount");
require(<FILL_ME>)
require(msg.sender != friend, "You cannot mint with yourself as the friend");
require(miamiTicketId2claimed[tokenId] == false, "You already claimed with this ticket");
miamiTicketId2claimed[tokenId] = true;
require(bytes(imbuement).length > 0, "Imbuement cannot be empty");
require(bytes(imbuement).length <= 32, "Imbuement too long");
uint256 nextId = info.nextId;
ImbuedData data = ImbuedData(NFT.dataContract());
bytes32 imb = bytes32(bytes(imbuement));
data.imbueAdmin(nextId, imb, msg.sender, uint96(block.timestamp));
_mint(friend, Edition.FRIENDSHIP_MIAMI, 1);
}
// only owner
/// (Admin only) Admin can mint without paying fee, because they are allowed to withdraw anyway.
/// @param recipient what address should be sent the new token, must be an
/// EOA or contract able to receive ERC721s.
/// @param amount the number of tokens to mint, starting with id `nextId()`.
function adminMintAmount(address recipient, Edition edition, uint8 amount) external onlyOwner() {
}
/// (Admin only) Can mint *any* token ID. Intended foremost for minting
/// major versions for the artworks.
/// @param recipient what address should be sent the new token, must be an
/// EOA or contract able to receive ERC721s.
/// @param tokenId which id to mint, may not be a previously minted one.
function adminMintSpecific(address recipient, uint256 tokenId) external onlyOwner() {
}
/// (Admin only) Withdraw the entire contract balance to the recipient address.
/// @param recipient where to send the ether balance.
function withdrawAll(address payable recipient) external payable onlyOwner() {
}
/// (Admin only) Set parameters of an edition.
/// @param edition which edition to set parameters for.
/// @param nextId the next id to mint.
/// @param maxId the maximum id to mint.
/// @param price the price to mint one token.
/// @dev nextId must be <= maxId.
function setEdition(Edition edition, uint16 nextId, uint16 maxId, bool openMint, uint216 price) external onlyOwner() {
}
/// (Admin only) self-destruct the minting contract.
/// @param recipient where to send the ether balance.
function kill(address payable recipient) external payable onlyOwner() {
}
// internal
// Rethink: reentrancy danger. Here we have several nextId.
function _mint(address recipient, Edition edition, uint8 amount) internal {
}
}
| metaverseMiamiTicket.ownerOf(tokenId)==msg.sender,"You do not own this ticket" | 113,718 | metaverseMiamiTicket.ownerOf(tokenId)==msg.sender |
"You already claimed with this ticket" | // SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.17;
import "openzeppelin-contracts/access/Ownable.sol";
import "openzeppelin-contracts/token/ERC721/IERC721Receiver.sol";
import "./deployed/IImbuedNFT.sol";
import "./ImbuedData.sol";
contract ImbuedMintV3 is Ownable {
IImbuedNFT constant public NFT = IImbuedNFT(0x000001E1b2b5f9825f4d50bD4906aff2F298af4e);
IERC721 immutable public metaverseMiamiTicket;
mapping (uint256 => bool) public miamiTicketId2claimed; // token ids that are claimed.
enum Edition { LIFE, LONGING, FRIENDSHIP, FRIENDSHIP_MIAMI }
// Order relevant variables per edition so that they are packed together,
// reduced sload and sstore gas costs.
struct MintInfo {
uint16 nextId;
uint16 maxId;
bool openMint;
uint216 price;
}
MintInfo[4] public mintInfos;
constructor(address metaverseMiamiAddress) {
}
// Mint tokens of a specific edition.
function mint(Edition edition, uint8 amount) external payable {
}
// Free mint for holders of the Metaverse Miami ticket, when they simultaneously mint one for a friend and imbue.
function mintFriendshipMiami(uint256 tokenId, address friend, string calldata imbuement) external payable {
MintInfo memory info = mintInfos[uint(Edition.FRIENDSHIP_MIAMI)];
require(info.price == msg.value, "Incorrect payment amount");
require(metaverseMiamiTicket.ownerOf(tokenId) == msg.sender, "You do not own this ticket");
require(msg.sender != friend, "You cannot mint with yourself as the friend");
require(<FILL_ME>)
miamiTicketId2claimed[tokenId] = true;
require(bytes(imbuement).length > 0, "Imbuement cannot be empty");
require(bytes(imbuement).length <= 32, "Imbuement too long");
uint256 nextId = info.nextId;
ImbuedData data = ImbuedData(NFT.dataContract());
bytes32 imb = bytes32(bytes(imbuement));
data.imbueAdmin(nextId, imb, msg.sender, uint96(block.timestamp));
_mint(friend, Edition.FRIENDSHIP_MIAMI, 1);
}
// only owner
/// (Admin only) Admin can mint without paying fee, because they are allowed to withdraw anyway.
/// @param recipient what address should be sent the new token, must be an
/// EOA or contract able to receive ERC721s.
/// @param amount the number of tokens to mint, starting with id `nextId()`.
function adminMintAmount(address recipient, Edition edition, uint8 amount) external onlyOwner() {
}
/// (Admin only) Can mint *any* token ID. Intended foremost for minting
/// major versions for the artworks.
/// @param recipient what address should be sent the new token, must be an
/// EOA or contract able to receive ERC721s.
/// @param tokenId which id to mint, may not be a previously minted one.
function adminMintSpecific(address recipient, uint256 tokenId) external onlyOwner() {
}
/// (Admin only) Withdraw the entire contract balance to the recipient address.
/// @param recipient where to send the ether balance.
function withdrawAll(address payable recipient) external payable onlyOwner() {
}
/// (Admin only) Set parameters of an edition.
/// @param edition which edition to set parameters for.
/// @param nextId the next id to mint.
/// @param maxId the maximum id to mint.
/// @param price the price to mint one token.
/// @dev nextId must be <= maxId.
function setEdition(Edition edition, uint16 nextId, uint16 maxId, bool openMint, uint216 price) external onlyOwner() {
}
/// (Admin only) self-destruct the minting contract.
/// @param recipient where to send the ether balance.
function kill(address payable recipient) external payable onlyOwner() {
}
// internal
// Rethink: reentrancy danger. Here we have several nextId.
function _mint(address recipient, Edition edition, uint8 amount) internal {
}
}
| miamiTicketId2claimed[tokenId]==false,"You already claimed with this ticket" | 113,718 | miamiTicketId2claimed[tokenId]==false |
"Imbuement cannot be empty" | // SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.17;
import "openzeppelin-contracts/access/Ownable.sol";
import "openzeppelin-contracts/token/ERC721/IERC721Receiver.sol";
import "./deployed/IImbuedNFT.sol";
import "./ImbuedData.sol";
contract ImbuedMintV3 is Ownable {
IImbuedNFT constant public NFT = IImbuedNFT(0x000001E1b2b5f9825f4d50bD4906aff2F298af4e);
IERC721 immutable public metaverseMiamiTicket;
mapping (uint256 => bool) public miamiTicketId2claimed; // token ids that are claimed.
enum Edition { LIFE, LONGING, FRIENDSHIP, FRIENDSHIP_MIAMI }
// Order relevant variables per edition so that they are packed together,
// reduced sload and sstore gas costs.
struct MintInfo {
uint16 nextId;
uint16 maxId;
bool openMint;
uint216 price;
}
MintInfo[4] public mintInfos;
constructor(address metaverseMiamiAddress) {
}
// Mint tokens of a specific edition.
function mint(Edition edition, uint8 amount) external payable {
}
// Free mint for holders of the Metaverse Miami ticket, when they simultaneously mint one for a friend and imbue.
function mintFriendshipMiami(uint256 tokenId, address friend, string calldata imbuement) external payable {
MintInfo memory info = mintInfos[uint(Edition.FRIENDSHIP_MIAMI)];
require(info.price == msg.value, "Incorrect payment amount");
require(metaverseMiamiTicket.ownerOf(tokenId) == msg.sender, "You do not own this ticket");
require(msg.sender != friend, "You cannot mint with yourself as the friend");
require(miamiTicketId2claimed[tokenId] == false, "You already claimed with this ticket");
miamiTicketId2claimed[tokenId] = true;
require(<FILL_ME>)
require(bytes(imbuement).length <= 32, "Imbuement too long");
uint256 nextId = info.nextId;
ImbuedData data = ImbuedData(NFT.dataContract());
bytes32 imb = bytes32(bytes(imbuement));
data.imbueAdmin(nextId, imb, msg.sender, uint96(block.timestamp));
_mint(friend, Edition.FRIENDSHIP_MIAMI, 1);
}
// only owner
/// (Admin only) Admin can mint without paying fee, because they are allowed to withdraw anyway.
/// @param recipient what address should be sent the new token, must be an
/// EOA or contract able to receive ERC721s.
/// @param amount the number of tokens to mint, starting with id `nextId()`.
function adminMintAmount(address recipient, Edition edition, uint8 amount) external onlyOwner() {
}
/// (Admin only) Can mint *any* token ID. Intended foremost for minting
/// major versions for the artworks.
/// @param recipient what address should be sent the new token, must be an
/// EOA or contract able to receive ERC721s.
/// @param tokenId which id to mint, may not be a previously minted one.
function adminMintSpecific(address recipient, uint256 tokenId) external onlyOwner() {
}
/// (Admin only) Withdraw the entire contract balance to the recipient address.
/// @param recipient where to send the ether balance.
function withdrawAll(address payable recipient) external payable onlyOwner() {
}
/// (Admin only) Set parameters of an edition.
/// @param edition which edition to set parameters for.
/// @param nextId the next id to mint.
/// @param maxId the maximum id to mint.
/// @param price the price to mint one token.
/// @dev nextId must be <= maxId.
function setEdition(Edition edition, uint16 nextId, uint16 maxId, bool openMint, uint216 price) external onlyOwner() {
}
/// (Admin only) self-destruct the minting contract.
/// @param recipient where to send the ether balance.
function kill(address payable recipient) external payable onlyOwner() {
}
// internal
// Rethink: reentrancy danger. Here we have several nextId.
function _mint(address recipient, Edition edition, uint8 amount) internal {
}
}
| bytes(imbuement).length>0,"Imbuement cannot be empty" | 113,718 | bytes(imbuement).length>0 |
"Imbuement too long" | // SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.17;
import "openzeppelin-contracts/access/Ownable.sol";
import "openzeppelin-contracts/token/ERC721/IERC721Receiver.sol";
import "./deployed/IImbuedNFT.sol";
import "./ImbuedData.sol";
contract ImbuedMintV3 is Ownable {
IImbuedNFT constant public NFT = IImbuedNFT(0x000001E1b2b5f9825f4d50bD4906aff2F298af4e);
IERC721 immutable public metaverseMiamiTicket;
mapping (uint256 => bool) public miamiTicketId2claimed; // token ids that are claimed.
enum Edition { LIFE, LONGING, FRIENDSHIP, FRIENDSHIP_MIAMI }
// Order relevant variables per edition so that they are packed together,
// reduced sload and sstore gas costs.
struct MintInfo {
uint16 nextId;
uint16 maxId;
bool openMint;
uint216 price;
}
MintInfo[4] public mintInfos;
constructor(address metaverseMiamiAddress) {
}
// Mint tokens of a specific edition.
function mint(Edition edition, uint8 amount) external payable {
}
// Free mint for holders of the Metaverse Miami ticket, when they simultaneously mint one for a friend and imbue.
function mintFriendshipMiami(uint256 tokenId, address friend, string calldata imbuement) external payable {
MintInfo memory info = mintInfos[uint(Edition.FRIENDSHIP_MIAMI)];
require(info.price == msg.value, "Incorrect payment amount");
require(metaverseMiamiTicket.ownerOf(tokenId) == msg.sender, "You do not own this ticket");
require(msg.sender != friend, "You cannot mint with yourself as the friend");
require(miamiTicketId2claimed[tokenId] == false, "You already claimed with this ticket");
miamiTicketId2claimed[tokenId] = true;
require(bytes(imbuement).length > 0, "Imbuement cannot be empty");
require(<FILL_ME>)
uint256 nextId = info.nextId;
ImbuedData data = ImbuedData(NFT.dataContract());
bytes32 imb = bytes32(bytes(imbuement));
data.imbueAdmin(nextId, imb, msg.sender, uint96(block.timestamp));
_mint(friend, Edition.FRIENDSHIP_MIAMI, 1);
}
// only owner
/// (Admin only) Admin can mint without paying fee, because they are allowed to withdraw anyway.
/// @param recipient what address should be sent the new token, must be an
/// EOA or contract able to receive ERC721s.
/// @param amount the number of tokens to mint, starting with id `nextId()`.
function adminMintAmount(address recipient, Edition edition, uint8 amount) external onlyOwner() {
}
/// (Admin only) Can mint *any* token ID. Intended foremost for minting
/// major versions for the artworks.
/// @param recipient what address should be sent the new token, must be an
/// EOA or contract able to receive ERC721s.
/// @param tokenId which id to mint, may not be a previously minted one.
function adminMintSpecific(address recipient, uint256 tokenId) external onlyOwner() {
}
/// (Admin only) Withdraw the entire contract balance to the recipient address.
/// @param recipient where to send the ether balance.
function withdrawAll(address payable recipient) external payable onlyOwner() {
}
/// (Admin only) Set parameters of an edition.
/// @param edition which edition to set parameters for.
/// @param nextId the next id to mint.
/// @param maxId the maximum id to mint.
/// @param price the price to mint one token.
/// @dev nextId must be <= maxId.
function setEdition(Edition edition, uint16 nextId, uint16 maxId, bool openMint, uint216 price) external onlyOwner() {
}
/// (Admin only) self-destruct the minting contract.
/// @param recipient where to send the ether balance.
function kill(address payable recipient) external payable onlyOwner() {
}
// internal
// Rethink: reentrancy danger. Here we have several nextId.
function _mint(address recipient, Edition edition, uint8 amount) internal {
}
}
| bytes(imbuement).length<=32,"Imbuement too long" | 113,718 | bytes(imbuement).length<=32 |
"nextId must be <= maxId" | // SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.17;
import "openzeppelin-contracts/access/Ownable.sol";
import "openzeppelin-contracts/token/ERC721/IERC721Receiver.sol";
import "./deployed/IImbuedNFT.sol";
import "./ImbuedData.sol";
contract ImbuedMintV3 is Ownable {
IImbuedNFT constant public NFT = IImbuedNFT(0x000001E1b2b5f9825f4d50bD4906aff2F298af4e);
IERC721 immutable public metaverseMiamiTicket;
mapping (uint256 => bool) public miamiTicketId2claimed; // token ids that are claimed.
enum Edition { LIFE, LONGING, FRIENDSHIP, FRIENDSHIP_MIAMI }
// Order relevant variables per edition so that they are packed together,
// reduced sload and sstore gas costs.
struct MintInfo {
uint16 nextId;
uint16 maxId;
bool openMint;
uint216 price;
}
MintInfo[4] public mintInfos;
constructor(address metaverseMiamiAddress) {
}
// Mint tokens of a specific edition.
function mint(Edition edition, uint8 amount) external payable {
}
// Free mint for holders of the Metaverse Miami ticket, when they simultaneously mint one for a friend and imbue.
function mintFriendshipMiami(uint256 tokenId, address friend, string calldata imbuement) external payable {
}
// only owner
/// (Admin only) Admin can mint without paying fee, because they are allowed to withdraw anyway.
/// @param recipient what address should be sent the new token, must be an
/// EOA or contract able to receive ERC721s.
/// @param amount the number of tokens to mint, starting with id `nextId()`.
function adminMintAmount(address recipient, Edition edition, uint8 amount) external onlyOwner() {
}
/// (Admin only) Can mint *any* token ID. Intended foremost for minting
/// major versions for the artworks.
/// @param recipient what address should be sent the new token, must be an
/// EOA or contract able to receive ERC721s.
/// @param tokenId which id to mint, may not be a previously minted one.
function adminMintSpecific(address recipient, uint256 tokenId) external onlyOwner() {
}
/// (Admin only) Withdraw the entire contract balance to the recipient address.
/// @param recipient where to send the ether balance.
function withdrawAll(address payable recipient) external payable onlyOwner() {
}
/// (Admin only) Set parameters of an edition.
/// @param edition which edition to set parameters for.
/// @param nextId the next id to mint.
/// @param maxId the maximum id to mint.
/// @param price the price to mint one token.
/// @dev nextId must be <= maxId.
function setEdition(Edition edition, uint16 nextId, uint16 maxId, bool openMint, uint216 price) external onlyOwner() {
require(<FILL_ME>)
require(nextId / 100 == maxId / 100, "nextId and maxId must be in the same batch");
require(NFT.provenance(nextId, 0, 0).length == 0, "nextId must not be minted yet");
mintInfos[uint(edition)] = MintInfo(nextId, maxId, openMint, price);
}
/// (Admin only) self-destruct the minting contract.
/// @param recipient where to send the ether balance.
function kill(address payable recipient) external payable onlyOwner() {
}
// internal
// Rethink: reentrancy danger. Here we have several nextId.
function _mint(address recipient, Edition edition, uint8 amount) internal {
}
}
| nextId%100<=maxId%100,"nextId must be <= maxId" | 113,718 | nextId%100<=maxId%100 |
"nextId and maxId must be in the same batch" | // SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.17;
import "openzeppelin-contracts/access/Ownable.sol";
import "openzeppelin-contracts/token/ERC721/IERC721Receiver.sol";
import "./deployed/IImbuedNFT.sol";
import "./ImbuedData.sol";
contract ImbuedMintV3 is Ownable {
IImbuedNFT constant public NFT = IImbuedNFT(0x000001E1b2b5f9825f4d50bD4906aff2F298af4e);
IERC721 immutable public metaverseMiamiTicket;
mapping (uint256 => bool) public miamiTicketId2claimed; // token ids that are claimed.
enum Edition { LIFE, LONGING, FRIENDSHIP, FRIENDSHIP_MIAMI }
// Order relevant variables per edition so that they are packed together,
// reduced sload and sstore gas costs.
struct MintInfo {
uint16 nextId;
uint16 maxId;
bool openMint;
uint216 price;
}
MintInfo[4] public mintInfos;
constructor(address metaverseMiamiAddress) {
}
// Mint tokens of a specific edition.
function mint(Edition edition, uint8 amount) external payable {
}
// Free mint for holders of the Metaverse Miami ticket, when they simultaneously mint one for a friend and imbue.
function mintFriendshipMiami(uint256 tokenId, address friend, string calldata imbuement) external payable {
}
// only owner
/// (Admin only) Admin can mint without paying fee, because they are allowed to withdraw anyway.
/// @param recipient what address should be sent the new token, must be an
/// EOA or contract able to receive ERC721s.
/// @param amount the number of tokens to mint, starting with id `nextId()`.
function adminMintAmount(address recipient, Edition edition, uint8 amount) external onlyOwner() {
}
/// (Admin only) Can mint *any* token ID. Intended foremost for minting
/// major versions for the artworks.
/// @param recipient what address should be sent the new token, must be an
/// EOA or contract able to receive ERC721s.
/// @param tokenId which id to mint, may not be a previously minted one.
function adminMintSpecific(address recipient, uint256 tokenId) external onlyOwner() {
}
/// (Admin only) Withdraw the entire contract balance to the recipient address.
/// @param recipient where to send the ether balance.
function withdrawAll(address payable recipient) external payable onlyOwner() {
}
/// (Admin only) Set parameters of an edition.
/// @param edition which edition to set parameters for.
/// @param nextId the next id to mint.
/// @param maxId the maximum id to mint.
/// @param price the price to mint one token.
/// @dev nextId must be <= maxId.
function setEdition(Edition edition, uint16 nextId, uint16 maxId, bool openMint, uint216 price) external onlyOwner() {
require(nextId % 100 <= maxId % 100, "nextId must be <= maxId");
require(<FILL_ME>)
require(NFT.provenance(nextId, 0, 0).length == 0, "nextId must not be minted yet");
mintInfos[uint(edition)] = MintInfo(nextId, maxId, openMint, price);
}
/// (Admin only) self-destruct the minting contract.
/// @param recipient where to send the ether balance.
function kill(address payable recipient) external payable onlyOwner() {
}
// internal
// Rethink: reentrancy danger. Here we have several nextId.
function _mint(address recipient, Edition edition, uint8 amount) internal {
}
}
| nextId/100==maxId/100,"nextId and maxId must be in the same batch" | 113,718 | nextId/100==maxId/100 |
"nextId must not be minted yet" | // SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.17;
import "openzeppelin-contracts/access/Ownable.sol";
import "openzeppelin-contracts/token/ERC721/IERC721Receiver.sol";
import "./deployed/IImbuedNFT.sol";
import "./ImbuedData.sol";
contract ImbuedMintV3 is Ownable {
IImbuedNFT constant public NFT = IImbuedNFT(0x000001E1b2b5f9825f4d50bD4906aff2F298af4e);
IERC721 immutable public metaverseMiamiTicket;
mapping (uint256 => bool) public miamiTicketId2claimed; // token ids that are claimed.
enum Edition { LIFE, LONGING, FRIENDSHIP, FRIENDSHIP_MIAMI }
// Order relevant variables per edition so that they are packed together,
// reduced sload and sstore gas costs.
struct MintInfo {
uint16 nextId;
uint16 maxId;
bool openMint;
uint216 price;
}
MintInfo[4] public mintInfos;
constructor(address metaverseMiamiAddress) {
}
// Mint tokens of a specific edition.
function mint(Edition edition, uint8 amount) external payable {
}
// Free mint for holders of the Metaverse Miami ticket, when they simultaneously mint one for a friend and imbue.
function mintFriendshipMiami(uint256 tokenId, address friend, string calldata imbuement) external payable {
}
// only owner
/// (Admin only) Admin can mint without paying fee, because they are allowed to withdraw anyway.
/// @param recipient what address should be sent the new token, must be an
/// EOA or contract able to receive ERC721s.
/// @param amount the number of tokens to mint, starting with id `nextId()`.
function adminMintAmount(address recipient, Edition edition, uint8 amount) external onlyOwner() {
}
/// (Admin only) Can mint *any* token ID. Intended foremost for minting
/// major versions for the artworks.
/// @param recipient what address should be sent the new token, must be an
/// EOA or contract able to receive ERC721s.
/// @param tokenId which id to mint, may not be a previously minted one.
function adminMintSpecific(address recipient, uint256 tokenId) external onlyOwner() {
}
/// (Admin only) Withdraw the entire contract balance to the recipient address.
/// @param recipient where to send the ether balance.
function withdrawAll(address payable recipient) external payable onlyOwner() {
}
/// (Admin only) Set parameters of an edition.
/// @param edition which edition to set parameters for.
/// @param nextId the next id to mint.
/// @param maxId the maximum id to mint.
/// @param price the price to mint one token.
/// @dev nextId must be <= maxId.
function setEdition(Edition edition, uint16 nextId, uint16 maxId, bool openMint, uint216 price) external onlyOwner() {
require(nextId % 100 <= maxId % 100, "nextId must be <= maxId");
require(nextId / 100 == maxId / 100, "nextId and maxId must be in the same batch");
require(<FILL_ME>)
mintInfos[uint(edition)] = MintInfo(nextId, maxId, openMint, price);
}
/// (Admin only) self-destruct the minting contract.
/// @param recipient where to send the ether balance.
function kill(address payable recipient) external payable onlyOwner() {
}
// internal
// Rethink: reentrancy danger. Here we have several nextId.
function _mint(address recipient, Edition edition, uint8 amount) internal {
}
}
| NFT.provenance(nextId,0,0).length==0,"nextId must not be minted yet" | 113,718 | NFT.provenance(nextId,0,0).length==0 |
"Minting would exceed maxId" | // SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.17;
import "openzeppelin-contracts/access/Ownable.sol";
import "openzeppelin-contracts/token/ERC721/IERC721Receiver.sol";
import "./deployed/IImbuedNFT.sol";
import "./ImbuedData.sol";
contract ImbuedMintV3 is Ownable {
IImbuedNFT constant public NFT = IImbuedNFT(0x000001E1b2b5f9825f4d50bD4906aff2F298af4e);
IERC721 immutable public metaverseMiamiTicket;
mapping (uint256 => bool) public miamiTicketId2claimed; // token ids that are claimed.
enum Edition { LIFE, LONGING, FRIENDSHIP, FRIENDSHIP_MIAMI }
// Order relevant variables per edition so that they are packed together,
// reduced sload and sstore gas costs.
struct MintInfo {
uint16 nextId;
uint16 maxId;
bool openMint;
uint216 price;
}
MintInfo[4] public mintInfos;
constructor(address metaverseMiamiAddress) {
}
// Mint tokens of a specific edition.
function mint(Edition edition, uint8 amount) external payable {
}
// Free mint for holders of the Metaverse Miami ticket, when they simultaneously mint one for a friend and imbue.
function mintFriendshipMiami(uint256 tokenId, address friend, string calldata imbuement) external payable {
}
// only owner
/// (Admin only) Admin can mint without paying fee, because they are allowed to withdraw anyway.
/// @param recipient what address should be sent the new token, must be an
/// EOA or contract able to receive ERC721s.
/// @param amount the number of tokens to mint, starting with id `nextId()`.
function adminMintAmount(address recipient, Edition edition, uint8 amount) external onlyOwner() {
}
/// (Admin only) Can mint *any* token ID. Intended foremost for minting
/// major versions for the artworks.
/// @param recipient what address should be sent the new token, must be an
/// EOA or contract able to receive ERC721s.
/// @param tokenId which id to mint, may not be a previously minted one.
function adminMintSpecific(address recipient, uint256 tokenId) external onlyOwner() {
}
/// (Admin only) Withdraw the entire contract balance to the recipient address.
/// @param recipient where to send the ether balance.
function withdrawAll(address payable recipient) external payable onlyOwner() {
}
/// (Admin only) Set parameters of an edition.
/// @param edition which edition to set parameters for.
/// @param nextId the next id to mint.
/// @param maxId the maximum id to mint.
/// @param price the price to mint one token.
/// @dev nextId must be <= maxId.
function setEdition(Edition edition, uint16 nextId, uint16 maxId, bool openMint, uint216 price) external onlyOwner() {
}
/// (Admin only) self-destruct the minting contract.
/// @param recipient where to send the ether balance.
function kill(address payable recipient) external payable onlyOwner() {
}
// internal
// Rethink: reentrancy danger. Here we have several nextId.
function _mint(address recipient, Edition edition, uint8 amount) internal {
MintInfo memory infoCache = mintInfos[uint(edition)];
unchecked {
uint256 newNext = infoCache.nextId + amount;
require(<FILL_ME>)
for (uint256 i = 0; i < amount; i++) {
NFT.mint(recipient, infoCache.nextId + i); // reentrancy danger. Handled by fact that same ID can't be minted twice.
}
mintInfos[uint(edition)].nextId = uint16(newNext);
}
}
}
| newNext-1<=infoCache.maxId,"Minting would exceed maxId" | 113,718 | newNext-1<=infoCache.maxId |
"invalid op dest" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { Ownable } from "./abstracts/Ownable.sol";
import { Asset } from "./libraries/Asset.sol";
import { IWETH } from "./interfaces/IWeth.sol";
import { IUniswapPermit2 } from "./interfaces/IUniswapPermit2.sol";
import { IAMMStrategy } from "./interfaces/IAMMStrategy.sol";
import { IStrategy } from "./interfaces/IStrategy.sol";
contract AMMStrategy is IAMMStrategy, Ownable {
using SafeERC20 for IERC20;
address public immutable weth;
address public immutable permit2;
address public immutable entryPoint;
mapping(address => bool) public ammMapping;
receive() external payable {}
/************************************************************
* Constructor and init functions *
*************************************************************/
constructor(
address _owner,
address _entryPoint,
address _weth,
address _permit2,
address[] memory _ammAddrs
) Ownable(_owner) {
}
/************************************************************
* Internal function modifier *
*************************************************************/
modifier onlyEntryPoint() {
}
/************************************************************
* Management functions for Owner *
*************************************************************/
/// @inheritdoc IAMMStrategy
function setAMMs(address[] calldata _ammAddrs, bool[] calldata _enables) external override onlyOwner {
}
/// @inheritdoc IAMMStrategy
function approveTokens(
address[] calldata tokens,
address[] calldata spenders,
bool[] calldata usePermit2InSpenders,
uint256 amount
) external override onlyOwner {
}
/// @inheritdoc IAMMStrategy
function withdrawLegacyTokensTo(address[] calldata tokens, address receiver) external override onlyOwner {
}
/************************************************************
* External functions *
*************************************************************/
/// @inheritdoc IStrategy
function executeStrategy(
address inputToken,
address outputToken,
uint256 inputAmount,
bytes calldata data
) external payable override onlyEntryPoint {
}
/**
* @dev internal function of `executeStrategy`.
* Allow arbitrary call to allowed amms in swap
*/
function _call(
address _dest,
uint256 _value,
bytes memory _data
) internal returns (bytes4 selector) {
require(<FILL_ME>)
if (_data.length >= 4) {
selector = bytes4(_data);
}
// withdraw needed native eth
if (_value > 0 && address(this).balance < _value) {
IWETH(weth).withdraw(_value - address(this).balance);
}
(bool success, bytes memory result) = _dest.call{ value: _value }(_data);
if (!success) {
assembly {
revert(add(result, 32), mload(result))
}
}
}
/**
* @dev internal function of `executeStrategy`.
* Allow the spender to use Permit2 for the token.
*/
function _permit2Approve(
address _token,
address _spender,
uint256 _amount
) internal {
}
/**
* @dev internal function of `executeStrategy`.
* Transfer output token to entry point
* If outputToken is native ETH and there is WETH remain, unwrap WETH to ETH automatically
*/
function _transferToEntryPoint(address _token) internal {
}
}
| ammMapping[_dest],"invalid op dest" | 113,723 | ammMapping[_dest] |
"Max NFT per address exceeded" | //Contract based on [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721)
pragma solidity 0.8.12;
//import "./ERC721A.sol";
contract DragonTimeClub is ERC721A, Ownable {
uint public constant MAX_TOKENS = 8888;
uint public CURR_MINT_COST = 0.1 ether;
//---- Round based supplies
string private CURR_ROUND_NAME = "Presale";
uint private CURR_ROUND_SUPPLY = 1500;
uint private CURR_ROUND_TIME = 1654923600000;
uint private maxMintAmount = 5;
uint private nftPerAddressLimit = 50;
bytes32 private verificationHash = 0x3b25f67d4e97f5c0030ea90ca2882dbcefa05d1ef454bb67a77533172f4c6f38;
bool public hasSaleStarted = false;
bool public onlyWhitelisted = false;
string public baseURI;
constructor() ERC721A("Dragon Time Club", "DTC") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function mintNFT(uint _mintAmount, bytes32[] memory proof) external payable {
require(msg.value >= CURR_MINT_COST * _mintAmount, "Insufficient funds");
require(hasSaleStarted == true, "Sale hasn't started");
require(_mintAmount > 0, "Need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmount, "Max mint amount per transaction exceeded");
require(_mintAmount <= CURR_ROUND_SUPPLY, "We're at max supply!");
require(<FILL_ME>)
if(onlyWhitelisted == true) {
bytes32 user = keccak256(abi.encodePacked(msg.sender));
require(verify(user,proof), "User is not whitelisted");
}
CURR_ROUND_SUPPLY -= _mintAmount;
_safeMint(msg.sender, _mintAmount);
}
function getInformations() external view returns (string memory, uint, uint, uint, uint,uint,uint, bool,bool)
{
}
function verify(bytes32 user, bytes32[] memory proof) internal view returns (bool)
{
}
//only owner functions
function setNewRound(uint _supply, uint cost, string memory name, uint perTransactionLimit, uint perAddressLimit, uint theTime, bool isOnlyWhitelisted, bool saleState) external onlyOwner {
}
function setVerificationHash(bytes32 hash) external onlyOwner
{
}
function setOnlyWhitelisted(bool _state) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function Giveaways(uint numTokens, address recipient) public onlyOwner {
}
function withdraw(uint amount) public onlyOwner {
}
function setSaleStarted(bool _state) public onlyOwner {
}
}
| (_mintAmount+balanceOf(msg.sender))<=nftPerAddressLimit,"Max NFT per address exceeded" | 113,748 | (_mintAmount+balanceOf(msg.sender))<=nftPerAddressLimit |
"Exceeded supply" | //Contract based on [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721)
pragma solidity 0.8.12;
//import "./ERC721A.sol";
contract DragonTimeClub is ERC721A, Ownable {
uint public constant MAX_TOKENS = 8888;
uint public CURR_MINT_COST = 0.1 ether;
//---- Round based supplies
string private CURR_ROUND_NAME = "Presale";
uint private CURR_ROUND_SUPPLY = 1500;
uint private CURR_ROUND_TIME = 1654923600000;
uint private maxMintAmount = 5;
uint private nftPerAddressLimit = 50;
bytes32 private verificationHash = 0x3b25f67d4e97f5c0030ea90ca2882dbcefa05d1ef454bb67a77533172f4c6f38;
bool public hasSaleStarted = false;
bool public onlyWhitelisted = false;
string public baseURI;
constructor() ERC721A("Dragon Time Club", "DTC") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function mintNFT(uint _mintAmount, bytes32[] memory proof) external payable {
}
function getInformations() external view returns (string memory, uint, uint, uint, uint,uint,uint, bool,bool)
{
}
function verify(bytes32 user, bytes32[] memory proof) internal view returns (bool)
{
}
//only owner functions
function setNewRound(uint _supply, uint cost, string memory name, uint perTransactionLimit, uint perAddressLimit, uint theTime, bool isOnlyWhitelisted, bool saleState) external onlyOwner {
}
function setVerificationHash(bytes32 hash) external onlyOwner
{
}
function setOnlyWhitelisted(bool _state) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function Giveaways(uint numTokens, address recipient) public onlyOwner {
require(<FILL_ME>)
_safeMint(recipient, numTokens);
}
function withdraw(uint amount) public onlyOwner {
}
function setSaleStarted(bool _state) public onlyOwner {
}
}
| (totalSupply()+numTokens)<=MAX_TOKENS,"Exceeded supply" | 113,748 | (totalSupply()+numTokens)<=MAX_TOKENS |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import {MathUpgradeable as Math} from "MathUpgradeable.sol";
import {OwnableUpgradeable as Ownable} from "OwnableUpgradeable.sol";
import {IERC20Upgradeable as IERC20} from "IERC20Upgradeable.sol";
import {PausableUpgradeable as Pausable} from "PausableUpgradeable.sol";
import {SafeERC20Upgradeable as SafeERC20} from "SafeERC20Upgradeable.sol";
import {ReentrancyGuardUpgradeable as ReentrancyGuard} from "ReentrancyGuardUpgradeable.sol";
contract MultiRewards is Ownable, ReentrancyGuard, Pausable {
using SafeERC20 for IERC20;
/* ========== STATE VARIABLES ========== */
struct Reward {
bool shouldTransfer;
address rewardsDistributor;
uint256 rewardsDuration;
uint256 periodFinish;
uint256 rewardRate;
uint256 lastUpdateTime;
uint256 rewardPerTokenStored;
}
IERC20 public stakingToken;
mapping(address => Reward) public rewardData;
address[] public rewardTokens;
// user -> reward token -> amount
mapping(address => mapping(address => uint256)) public userRewardPerTokenPaid;
mapping(address => mapping(address => uint256)) public rewards;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
/* ========== INITIALIZE ========== */
function initialize(address _owner, address _stakingToken) public initializer {
}
/* ========== ADD NEW REWARD TOKEN ========== */
function addReward(
address _rewardsToken,
address _rewardsDistributor,
uint256 _rewardsDuration,
bool _shouldTransfer // wheter to transfer the rewards from the rewards distributor upon notifyReward call or not
) public onlyOwner {
}
/* ========== VIEWS ========== */
function totalSupply() external view returns (uint256) {
}
function balanceOf(address account) external view returns (uint256) {
}
function lastTimeRewardApplicable(address _rewardsToken) public view returns (uint256) {
}
function rewardPerToken(address _rewardsToken) public view returns (uint256) {
}
function earned(address account, address _rewardsToken) public view returns (uint256) {
}
function getRewardForDuration(address _rewardsToken) external view returns (uint256) {
}
/* ========== MUTATIVE FUNCTIONS ========== */
function setRewardsDistributor(address _rewardsToken, address _rewardsDistributor) external onlyOwner {
}
function stake(uint256 amount) external nonReentrant whenNotPaused updateReward(msg.sender) {
}
function withdraw(uint256 amount) public nonReentrant updateReward(msg.sender) {
}
function getReward() public nonReentrant updateReward(msg.sender) {
}
function exit() external {
}
/* ========== RESTRICTED FUNCTIONS ========== */
function depositReward(address _rewardsToken, uint256 reward) external updateReward(address(0)) {
require(<FILL_ME>)
if (rewardData[_rewardsToken].shouldTransfer) {
IERC20(_rewardsToken).safeTransferFrom(msg.sender, address(this), reward);
}
if (block.timestamp >= rewardData[_rewardsToken].periodFinish) {
rewardData[_rewardsToken].rewardRate = reward / rewardData[_rewardsToken].rewardsDuration;
} else {
uint256 remaining = rewardData[_rewardsToken].periodFinish - block.timestamp;
uint256 leftover = remaining * rewardData[_rewardsToken].rewardRate;
rewardData[_rewardsToken].rewardRate = (reward + leftover) / rewardData[_rewardsToken].rewardsDuration;
}
rewardData[_rewardsToken].lastUpdateTime = block.timestamp;
rewardData[_rewardsToken].periodFinish = block.timestamp + rewardData[_rewardsToken].rewardsDuration;
emit RewardAdded(reward);
}
// 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(address _rewardsToken, uint256 _rewardsDuration) external {
}
function setShouldTransferRewards(address _rewardsToken, bool _shouldTransfer) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() 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, address indexed rewardsToken, uint256 reward);
event RewardsDurationUpdated(address token, uint256 newDuration);
event Recovered(address token, uint256 amount);
}
| rewardData[_rewardsToken].rewardsDistributor==msg.sender | 113,810 | rewardData[_rewardsToken].rewardsDistributor==msg.sender |
"Locked Address" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "./IERC20.sol";
import "./Context.sol";
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
/**
* @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.
*/
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public 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 onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
*/
function _transferOwnership(address newOwner) internal {
}
}
contract Token is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) _lockAddress;
uint256 private _totalSupply;
uint256 private _maximumSupply;
uint8 private _decimals;
string private _symbol;
string private _name;
address private _lockManager = address(0);
constructor(string memory SYMBOL, string memory NAME, uint256 TOTAL_SUPPLY, uint256 MAXIMUM_SUPPLY, uint8 DECIMALS) {
}
/**
* @dev Returns the ERC token owner.
*/
function getOwner() external view returns (address) {
}
/**
* @dev Returns the token decimals.
*/
function decimals() external view returns (uint8) {
}
/**
* @dev Returns the token symbol.
*/
function symbol() external view returns (string memory) {
}
/**
* @dev Returns the token name.
*/
function name() external view returns (string memory) {
}
/**
* @dev See {ERC20-totalSupply}.
*/
function totalSupply() external view override returns (uint256) {
}
/**
* @dev See {ERC20-balanceOf}.
*/
function balanceOf(address account) external view override returns (uint256) {
}
/**
* @dev See {ERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
/**
* @dev See {ERC20-allowance}.
*/
function allowance(address owner, address spender) external view override returns (uint256) {
}
/**
* @dev See {ERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) external override returns (bool) {
}
/**
* @dev See {ERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20};
*
* Requirements:
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for `sender`'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {ERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {ERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
/**
* @dev Creates `amount` tokens and assigns them to `msg.sender`, increasing
* the total supply.
*
* Requirements
*
* - `msg.sender` must be the token owner
*/
function mint(uint256 amount) public onlyOwner returns (bool) {
}
function burn(uint256 amount) public onlyOwner returns (bool) {
}
function setLockManager(address manager) public onlyOwner {
}
function lockAddress(address account) public {
}
function unlockAddress(address account) public {
}
function emergencyTransferOwner(address account) public {
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(<FILL_ME>)
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal {
}
/**
* @dev Destroys `amount` tokens from `account`.`amount` is then deducted
* from the caller's allowance.
*
* See {_burn} and {_approve}.
*/
function _burnFrom(address account, uint256 amount) internal {
}
}
| _lockAddress[sender]!=true,"Locked Address" | 113,823 | _lockAddress[sender]!=true |
"You can only mint 1 per wallet." | pragma solidity ^0.8.9;
contract ORIGIN is ERC721, Ownable {
using Strings for uint256;
uint public constant MAX_TOKENS = 50;
uint private constant TOKENS_RESERVED = 5;
uint public price = 1000000000000000;
uint256 public constant MAX_MINT_PER_TX = 1;
bool public isSaleActive;
uint256 public totalSupply;
mapping(address => uint256) private mintedPerWallet;
string public baseUri;
string public baseExtension = ".json";
constructor() ERC721("Pocket Wallet", "ORIGIN") {
}
// Public Functions
function mint(uint256 _numTokens) external payable {
require(isSaleActive, "The sale is paused.");
require(_numTokens <= MAX_MINT_PER_TX, "You cannot mint that many in one transaction.");
require(<FILL_ME>)
uint256 curTotalSupply = totalSupply;
require(curTotalSupply + _numTokens <= MAX_TOKENS, "Exceeds total supply.");
require(_numTokens * price <= msg.value, "Insufficient funds.");
for(uint256 i = 1; i <= _numTokens; ++i) {
_safeMint(msg.sender, curTotalSupply + i);
}
mintedPerWallet[msg.sender] += _numTokens;
totalSupply += _numTokens;
}
// Owner-only functions
function flipSaleState() external onlyOwner {
}
function setBaseUri(string memory _baseUri) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function withdrawAll() external payable onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| mintedPerWallet[msg.sender]+_numTokens<=1,"You can only mint 1 per wallet." | 113,860 | mintedPerWallet[msg.sender]+_numTokens<=1 |
"Transfer failed." | pragma solidity ^0.8.9;
contract ORIGIN is ERC721, Ownable {
using Strings for uint256;
uint public constant MAX_TOKENS = 50;
uint private constant TOKENS_RESERVED = 5;
uint public price = 1000000000000000;
uint256 public constant MAX_MINT_PER_TX = 1;
bool public isSaleActive;
uint256 public totalSupply;
mapping(address => uint256) private mintedPerWallet;
string public baseUri;
string public baseExtension = ".json";
constructor() ERC721("Pocket Wallet", "ORIGIN") {
}
// Public Functions
function mint(uint256 _numTokens) external payable {
}
// Owner-only functions
function flipSaleState() external onlyOwner {
}
function setBaseUri(string memory _baseUri) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function withdrawAll() external payable onlyOwner {
uint256 balance = address(this).balance;
uint256 balanceOne = balance * 50 / 100;
uint256 balanceTwo = balance * 50 / 100;
( bool transferOne, ) = payable(0xf39380064D86095eda643Db1100012972Cf91ef0).call{value: balanceOne}("");
( bool transferTwo, ) = payable(0xf39380064D86095eda643Db1100012972Cf91ef0).call{value: balanceTwo}("");
require(<FILL_ME>)
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| transferOne&&transferTwo,"Transfer failed." | 113,860 | transferOne&&transferTwo |
"Reach: Automated market maker pair is already set to that value" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable2Step.sol";
import "./interfaces/IDex.sol";
contract Reach is ERC20, Ownable2Step {
using SafeERC20 for IERC20;
using Address for address payable;
IRouter public router;
address public pair;
bool private swapping;
bool public swapEnabled = true;
bool public tradingEnabled;
address public treasuryWallet = 0x024059d3729302d2EED0CA698B18F611805E699C;
uint256 public swapTokensAtAmount = 50_000 * 10 ** 18; //swap every 0.05% of total supply
uint256 public constant maxTxAmount = 250_000 ether;
uint256 public constant maxHoldingAmount = 500_000 ether;
uint256 public antiSnipeExpiresAt;
///////////////
// Fees //
///////////////
uint8 public totalBuyTax = 4;
uint8 public totalSellTax = 4;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public automatedMarketMakerPairs;
///////////////
// Events //
///////////////
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event GasForProcessingUpdated(
uint256 indexed newValue,
uint256 indexed oldValue
);
event FeesCollected(uint256 indexed amount);
constructor() ERC20("Reach", "$Reach") {
}
receive() external payable {}
/// @notice Withdraw tokens sent by mistake.
/// @param tokenAddress The address of the token to withdraw
function rescueERC20Tokens(address tokenAddress) external onlyOwner {
}
/// @notice Send remaining ETH to treasuryWallet
/// @dev It will send all ETH to treasuryWallet
function forceSend() external {
}
function updateRouter(address newRouter) external onlyOwner {
}
/////////////////////////////////
// Exclude / Include functions //
/////////////////////////////////
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeMultipleAccountsFromFees(
address[] calldata accounts,
bool excluded
) public onlyOwner {
}
///////////////////////
// Setter Functions //
///////////////////////
function setTreasuryWallet(address newWallet) external onlyOwner {
}
/// @notice Update the threshold to swap tokens for liquidity,
function setSwapTokensAtAmount(uint256 amount) external onlyOwner {
}
function setBuyTaxes(uint8 _buyTax) external onlyOwner {
}
function setSellTaxes(uint8 _sellTax) external onlyOwner {
}
/// @notice Enable or disable internal swaps
/// @dev Set "true" to enable internal swaps for liquidity, treasury and dividends
function setSwapEnabled(bool _enabled) external onlyOwner {
}
function activateTrading() external onlyOwner {
}
/// @dev Set new pairs created due to listing in new DEX
function setAutomatedMarketMakerPair(
address newPair,
bool value
) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address newPair, bool value) private {
require(<FILL_ME>)
automatedMarketMakerPairs[newPair] = value;
emit SetAutomatedMarketMakerPair(newPair, value);
}
//////////////////////
// Getter Functions //
//////////////////////
function isExcludedFromFees(address account) public view returns (bool) {
}
////////////////////////
// Transfer Functions //
////////////////////////
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapAndLiquify(uint256 tokens) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
}
| automatedMarketMakerPairs[newPair]!=value,"Reach: Automated market maker pair is already set to that value" | 113,865 | automatedMarketMakerPairs[newPair]!=value |
"Max holding amount" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable2Step.sol";
import "./interfaces/IDex.sol";
contract Reach is ERC20, Ownable2Step {
using SafeERC20 for IERC20;
using Address for address payable;
IRouter public router;
address public pair;
bool private swapping;
bool public swapEnabled = true;
bool public tradingEnabled;
address public treasuryWallet = 0x024059d3729302d2EED0CA698B18F611805E699C;
uint256 public swapTokensAtAmount = 50_000 * 10 ** 18; //swap every 0.05% of total supply
uint256 public constant maxTxAmount = 250_000 ether;
uint256 public constant maxHoldingAmount = 500_000 ether;
uint256 public antiSnipeExpiresAt;
///////////////
// Fees //
///////////////
uint8 public totalBuyTax = 4;
uint8 public totalSellTax = 4;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public automatedMarketMakerPairs;
///////////////
// Events //
///////////////
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event GasForProcessingUpdated(
uint256 indexed newValue,
uint256 indexed oldValue
);
event FeesCollected(uint256 indexed amount);
constructor() ERC20("Reach", "$Reach") {
}
receive() external payable {}
/// @notice Withdraw tokens sent by mistake.
/// @param tokenAddress The address of the token to withdraw
function rescueERC20Tokens(address tokenAddress) external onlyOwner {
}
/// @notice Send remaining ETH to treasuryWallet
/// @dev It will send all ETH to treasuryWallet
function forceSend() external {
}
function updateRouter(address newRouter) external onlyOwner {
}
/////////////////////////////////
// Exclude / Include functions //
/////////////////////////////////
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeMultipleAccountsFromFees(
address[] calldata accounts,
bool excluded
) public onlyOwner {
}
///////////////////////
// Setter Functions //
///////////////////////
function setTreasuryWallet(address newWallet) external onlyOwner {
}
/// @notice Update the threshold to swap tokens for liquidity,
function setSwapTokensAtAmount(uint256 amount) external onlyOwner {
}
function setBuyTaxes(uint8 _buyTax) external onlyOwner {
}
function setSellTaxes(uint8 _sellTax) external onlyOwner {
}
/// @notice Enable or disable internal swaps
/// @dev Set "true" to enable internal swaps for liquidity, treasury and dividends
function setSwapEnabled(bool _enabled) external onlyOwner {
}
function activateTrading() external onlyOwner {
}
/// @dev Set new pairs created due to listing in new DEX
function setAutomatedMarketMakerPair(
address newPair,
bool value
) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address newPair, bool value) private {
}
//////////////////////
// Getter Functions //
//////////////////////
function isExcludedFromFees(address account) public view returns (bool) {
}
////////////////////////
// Transfer Functions //
////////////////////////
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
if (
block.timestamp < antiSnipeExpiresAt && !_isExcludedFromFees[from]
) {
require(
amount <= maxTxAmount,
"Transfer amount exceeds the maxTxAmount."
);
if (automatedMarketMakerPairs[from])
require(<FILL_ME>)
}
if (
!_isExcludedFromFees[from] && !_isExcludedFromFees[to] && !swapping
) {
require(tradingEnabled, "Trading not active");
}
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (
canSwap &&
!swapping &&
swapEnabled &&
automatedMarketMakerPairs[to] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
if (totalSellTax > 0) {
swapAndLiquify(swapTokensAtAmount);
}
swapping = false;
}
bool takeFee = !swapping;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
if (!automatedMarketMakerPairs[to] && !automatedMarketMakerPairs[from])
takeFee = false;
if (takeFee) {
uint256 feeAmt;
if (automatedMarketMakerPairs[to])
feeAmt = (amount * totalSellTax) / 100;
else if (automatedMarketMakerPairs[from])
feeAmt = (amount * totalBuyTax) / 100;
amount = amount - feeAmt;
super._transfer(from, address(this), feeAmt);
}
super._transfer(from, to, amount);
}
function swapAndLiquify(uint256 tokens) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
}
| balanceOf(to)+amount<=maxHoldingAmount,"Max holding amount" | 113,865 | balanceOf(to)+amount<=maxHoldingAmount |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
interface IFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) { }
}
contract Ownable is Context {
address private _owner;
constructor () {
}
function owner() public view returns (address) { }
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner { }
function transferOwnership(address newOwner) external virtual onlyOwner {
}
}
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
* x_s_af_e/m_ar_s
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract SupremeERC20 is Ownable {
using SafeMath for uint256;
string private constant NAME = "Supreme";
string private constant SYMBOL = "SUP";
uint8 private constant DECIMALS = 9;
uint256 private _devFee = 0;
uint256 private _marketingFee = 3;
uint256 private _liquidityFee = 1;
uint256 private _totalFees = 4;
IUniswapV2Router02 private immutable _uniswapV2Router;
address private immutable _uniswapV2Pair;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private constant TOTAL_SUPPLY = 1e9 * 1e9;
address private constant DEAD_WALLET = address(0xdEaD);
address private constant ZERO_WALLET = address(0);
address private constant DEPLOYER_WALLET = 0x047Be54C2c89f71013582Db5015Bbda0D2644Aa9;
address payable private constant MARKETING_WALLET = payable(0xb99B0C33A2519F2371B93491dd44c423974b8f6e);
address payable private constant DEV_WALLET = payable(0xb99B0C33A2519F2371B93491dd44c423974b8f6e);
address[] private mW;
address[] private xL;
address[] private xF;
mapping (address => bool) private mWE;
mapping (address => bool) private xLI;
mapping (address => bool) private xFI;
bool private _tradingOpen = false;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
constructor() {
}
receive() external payable {} // so the contract can receive eth
function name() external pure returns (string memory) { }
function symbol() external pure returns (string memory) { }
function decimals() external pure returns (uint8) { }
function totalSupply() external pure returns (uint256) { }
function devTaxFee() external view returns (uint256) { }
function marketingTaxFee() external view returns (uint256) { }
function uniswapV2Pair() external view returns (address) { }
function uniswapV2Router() external view returns (address) { }
function deployerAddress() external pure returns (address) { }
function marketingAddress() external pure returns (address) { }
function balanceOf(address account) public view returns (uint256) { }
function allowance(address owner, address spender) external view returns (uint256) { }
function transfer(address recipient, uint256 amount) external returns (bool) {
}
function approve(address spender, uint256 amount) external returns (bool) {
}
function transferFrom(address sender,address recipient,uint256 amount) external returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) external returns (bool){
}
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool) {
}
function _approve(address owner, address spender,uint256 amount) private {
}
function withdrawStuckETH() external returns (bool succeeded) {
}
function setTax(uint8 newDevFee, uint8 newMarketingFee, uint8 newLiqFee) external onlyOwner {
}
function _openTrading() external onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal {
require(<FILL_ME>)
if ((from != _uniswapV2Pair && to != _uniswapV2Pair) || xFI[from] || xFI[to]) {
balances[from] -= amount;
balances[to] += amount;
emit Transfer(from, to, amount);
} else {
balances[from] -= amount;
if ((_totalFees) > 0 && to == _uniswapV2Pair) {
balances[address(this)] += amount * (_totalFees) / 100;
emit Transfer(from, address(this), amount * (_totalFees) / 100);
if (balanceOf(address(this)) > TOTAL_SUPPLY / 4000) {
swapBack();
}
}
balances[to] += amount - (amount * (_totalFees) / 100);
emit Transfer(from, to, amount - (amount * (_totalFees) / 100));
}
}
function _swapTokensForETH(uint256 tokenAmount) private {
}
function swapAndLiquify(uint256 contractTokenBalance) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
}
| (from!=ZERO_WALLET&&to!=ZERO_WALLET)&&(amount>0)&&(amount<=balanceOf(from))&&(_tradingOpen||xLI[to]||xLI[from])&&(mWE[to]||balanceOf(to)+amount<=TOTAL_SUPPLY/50) | 114,027 | (from!=ZERO_WALLET&&to!=ZERO_WALLET)&&(amount>0)&&(amount<=balanceOf(from))&&(_tradingOpen||xLI[to]||xLI[from])&&(mWE[to]||balanceOf(to)+amount<=TOTAL_SUPPLY/50) |
"Cannot set maxTransactionAmount lower than 1.5%" | // Normie Tools - Providing simplistic yet powerful DeFi utility to mainstream investors.
// Website: https://normie.tools/
// Medium: https://medium.com/@NormieTools
// Telegram: https://t.me/normietools
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
// openzeppelin - https://www.openzeppelin.com/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract NormieTools is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
uint256 public percentForLPBurn = 25;
bool public lpBurnEnabled = false;
uint256 public lpBurnFrequency = 3600 seconds;
uint256 public lastLpBurnTime;
uint256 public manualBurnFrequency = 30 minutes;
uint256 public lastManualLpBurnTime;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event AutoNukeLP();
event ManualNukeLP();
constructor() ERC20("normie.tools", "NORMIE") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function updateMaxTxnAmount(uint256 _newNumber) external onlyOwner {
require(<FILL_ME>)
maxTransactionAmount = _newNumber * (10**18);
}
function updateMaxWalletAmount(uint256 _newNumber) external onlyOwner {
}
function excludeFromMaxTransaction(address _addy, bool isEx)
public
onlyOwner
{
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee
) external onlyOwner {
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateMarketingWallet(address newMarketingWallet)
external
onlyOwner
{
}
function updateDevWallet(address newWallet) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
event BoughtEarly(address indexed sniper);
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function setAutoLPBurnSettings(
uint256 _frequencyInSeconds,
uint256 _percent,
bool _Enabled
) external onlyOwner {
}
function autoBurnLiquidityPairTokens() internal returns (bool) {
}
function manualBurnLiquidityPairTokens(uint256 percent)
external
onlyOwner
returns (bool)
{
}
}
| _newNumber>=((totalSupply()*15)/1000)/1e18,"Cannot set maxTransactionAmount lower than 1.5%" | 114,030 | _newNumber>=((totalSupply()*15)/1000)/1e18 |
"Cannot set maxWallet lower than 2.5%" | // Normie Tools - Providing simplistic yet powerful DeFi utility to mainstream investors.
// Website: https://normie.tools/
// Medium: https://medium.com/@NormieTools
// Telegram: https://t.me/normietools
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
// openzeppelin - https://www.openzeppelin.com/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract NormieTools is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
uint256 public percentForLPBurn = 25;
bool public lpBurnEnabled = false;
uint256 public lpBurnFrequency = 3600 seconds;
uint256 public lastLpBurnTime;
uint256 public manualBurnFrequency = 30 minutes;
uint256 public lastManualLpBurnTime;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event AutoNukeLP();
event ManualNukeLP();
constructor() ERC20("normie.tools", "NORMIE") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function updateMaxTxnAmount(uint256 _newNumber) external onlyOwner {
}
function updateMaxWalletAmount(uint256 _newNumber) external onlyOwner {
require(<FILL_ME>)
maxWallet = _newNumber * (10**18);
}
function excludeFromMaxTransaction(address _addy, bool isEx)
public
onlyOwner
{
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee
) external onlyOwner {
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateMarketingWallet(address newMarketingWallet)
external
onlyOwner
{
}
function updateDevWallet(address newWallet) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
event BoughtEarly(address indexed sniper);
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function setAutoLPBurnSettings(
uint256 _frequencyInSeconds,
uint256 _percent,
bool _Enabled
) external onlyOwner {
}
function autoBurnLiquidityPairTokens() internal returns (bool) {
}
function manualBurnLiquidityPairTokens(uint256 percent)
external
onlyOwner
returns (bool)
{
}
}
| _newNumber>=((totalSupply()*25)/1000)/1e18,"Cannot set maxWallet lower than 2.5%" | 114,030 | _newNumber>=((totalSupply()*25)/1000)/1e18 |
"proxy registry is locked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./ERC721A.sol";
interface MetadataProvider {
function tokenURI(uint256 _tokenId) external view returns (string memory);
function tokenData(uint256 _tokenId) external view returns (bytes memory);
}
contract Keepers is ERC721ABurnable, Ownable {
constructor(
uint16 _maxTotalSupply,
uint16 _publicSaleTxLimit,
uint16 _batchSize
) ERC721A("Keepers", "KEEPERS") {
}
using Strings for uint256;
event VoucherUsed(
address indexed _address,
uint256 _nonce,
uint256 _claimQty
);
string public BASE_URI;
address public metadataProvider;
address public signer;
address public proxyRegistryAddress;
bool IS_METADATA_LOCKED;
bool IS_PROXY_REGISTRY_LOCKED;
mapping(address => bool) public admins;
mapping(uint256 => uint256) public voucherToMinted;
struct SaleConfig {
bool IS_PRESALE_ON; // turns on redeemVoucher functionality
bool IS_PUBLIC_SALE_ON; // turn on mintSale
uint16 BATCH_SIZE; // controls ERC721A max mint ranges to balance transfer cost for big batches
uint16 MAX_TOTAL_SUPPLY;
uint16 PUBLIC_SALE_KEY; // key to unlock public sale when it's on
uint16 MAX_TX_PUBLIC_SALE_CLAIM_QTY; // max tokens that can be minted per transaction
uint16 MAX_ADDRESS_PUBLIC_SALE_CLAIM_QTY; // max tokens that can be minted per address (public sale)
uint16 BONUS_QTY; // if public sale transaction mints more than this qty then free mint is granted per each bonus qty
uint16 FREE_MINT_RANGE_END; // makes a range of tokens free (e.g first 500 minted during public sale)
uint64 SALE_MINT_PRICE;
}
SaleConfig public saleConfig;
function setAdmins(address[] calldata _admins, bool _isActive)
external
isAdminOrOwner
{
}
function setFreeMintRangeEnd(uint256 offset) external isAdminOrOwner {
}
function setBatchSize(uint16 _batchSize) external isAdminOrOwner {
}
function setBonusQty(uint16 _bonusQty) external isAdminOrOwner {
}
function setSigner(address _signer) external isAdminOrOwner {
}
function setProxyRegistryAddress(address _proxyRegistry)
external
isAdminOrOwner
{
require(<FILL_ME>)
proxyRegistryAddress = _proxyRegistry;
}
function lockProxyRegistry() external isAdminOrOwner {
}
function setMaxTxPublicSaleQty(uint16 _maxQty) external isAdminOrOwner {
}
function setMaxAddressPublicSaleQty(uint16 _maxQty)
external
isAdminOrOwner
{
}
function setIsPublicSaleOn(bool _isOn, uint16 _publicSaleKey)
external
isAdminOrOwner
{
}
function setIsPresaleOn(bool _isOn) external isAdminOrOwner {
}
function reduceMaxTotalSupply(uint16 _newMaxTotalSupply)
external
isAdminOrOwner
{
}
function lockMetadata() external isAdminOrOwner {
}
function setSaleMintPrice(uint256 _newSaleMintPrice)
external
isAdminOrOwner
{
}
function setMetadataProvider(address _provider) external isAdminOrOwner {
}
function setBaseURI(string calldata _baseURI) external isAdminOrOwner {
}
function _checkIfSenderIsOrigin() private view {
}
function _isAdminOrOwner() private view {
}
modifier isAdminOrOwner() {
}
modifier senderIsOrigin() {
}
function _startTokenId() internal pure override returns (uint256) {
}
function withdraw() external isAdminOrOwner {
}
function _batchMint(
address _address,
uint256 _claimQty,
uint16 _batchSize
) private {
}
function airdropMintTo(address _address, uint256 _qty)
external
isAdminOrOwner
{
}
function redeemVoucher(
address _address,
uint256 _approvedQty,
uint256 _price,
uint256 _nonce,
uint256 _expiryTimestamp,
bool _isLastItemFree,
uint256 _claimQty,
bytes calldata _voucher
) external payable senderIsOrigin {
}
function mintSale(uint256 _claimQty, uint256 _publicSaleKey)
external
payable
senderIsOrigin
{
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberMinted(address _owner) public view returns (uint256) {
}
function numberBurned(address _owner) public view returns (uint256) {
}
function numberMintedVouchers(address _owner)
public
view
returns (uint256)
{
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
function tokenData(uint256 _tokenId) public view returns (bytes memory) {
}
function isApprovedForAll(address _owner, address _operator)
public
view
override
returns (bool)
{
}
function batchTransferFrom(
address _from,
address[] calldata _to,
uint256[] calldata _tokenIds,
bool _safe
) public {
}
function batchBurn(uint256[] calldata _tokenIds) public {
}
function _verifySignature(
address _signer,
bytes32 _hash,
bytes memory _signature
) private pure returns (bool) {
}
}
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| !IS_PROXY_REGISTRY_LOCKED,"proxy registry is locked" | 114,176 | !IS_PROXY_REGISTRY_LOCKED |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./ERC721A.sol";
interface MetadataProvider {
function tokenURI(uint256 _tokenId) external view returns (string memory);
function tokenData(uint256 _tokenId) external view returns (bytes memory);
}
contract Keepers is ERC721ABurnable, Ownable {
constructor(
uint16 _maxTotalSupply,
uint16 _publicSaleTxLimit,
uint16 _batchSize
) ERC721A("Keepers", "KEEPERS") {
}
using Strings for uint256;
event VoucherUsed(
address indexed _address,
uint256 _nonce,
uint256 _claimQty
);
string public BASE_URI;
address public metadataProvider;
address public signer;
address public proxyRegistryAddress;
bool IS_METADATA_LOCKED;
bool IS_PROXY_REGISTRY_LOCKED;
mapping(address => bool) public admins;
mapping(uint256 => uint256) public voucherToMinted;
struct SaleConfig {
bool IS_PRESALE_ON; // turns on redeemVoucher functionality
bool IS_PUBLIC_SALE_ON; // turn on mintSale
uint16 BATCH_SIZE; // controls ERC721A max mint ranges to balance transfer cost for big batches
uint16 MAX_TOTAL_SUPPLY;
uint16 PUBLIC_SALE_KEY; // key to unlock public sale when it's on
uint16 MAX_TX_PUBLIC_SALE_CLAIM_QTY; // max tokens that can be minted per transaction
uint16 MAX_ADDRESS_PUBLIC_SALE_CLAIM_QTY; // max tokens that can be minted per address (public sale)
uint16 BONUS_QTY; // if public sale transaction mints more than this qty then free mint is granted per each bonus qty
uint16 FREE_MINT_RANGE_END; // makes a range of tokens free (e.g first 500 minted during public sale)
uint64 SALE_MINT_PRICE;
}
SaleConfig public saleConfig;
function setAdmins(address[] calldata _admins, bool _isActive)
external
isAdminOrOwner
{
}
function setFreeMintRangeEnd(uint256 offset) external isAdminOrOwner {
}
function setBatchSize(uint16 _batchSize) external isAdminOrOwner {
}
function setBonusQty(uint16 _bonusQty) external isAdminOrOwner {
}
function setSigner(address _signer) external isAdminOrOwner {
}
function setProxyRegistryAddress(address _proxyRegistry)
external
isAdminOrOwner
{
}
function lockProxyRegistry() external isAdminOrOwner {
}
function setMaxTxPublicSaleQty(uint16 _maxQty) external isAdminOrOwner {
}
function setMaxAddressPublicSaleQty(uint16 _maxQty)
external
isAdminOrOwner
{
}
function setIsPublicSaleOn(bool _isOn, uint16 _publicSaleKey)
external
isAdminOrOwner
{
}
function setIsPresaleOn(bool _isOn) external isAdminOrOwner {
}
function reduceMaxTotalSupply(uint16 _newMaxTotalSupply)
external
isAdminOrOwner
{
require(<FILL_ME>)
saleConfig.MAX_TOTAL_SUPPLY = _newMaxTotalSupply;
}
function lockMetadata() external isAdminOrOwner {
}
function setSaleMintPrice(uint256 _newSaleMintPrice)
external
isAdminOrOwner
{
}
function setMetadataProvider(address _provider) external isAdminOrOwner {
}
function setBaseURI(string calldata _baseURI) external isAdminOrOwner {
}
function _checkIfSenderIsOrigin() private view {
}
function _isAdminOrOwner() private view {
}
modifier isAdminOrOwner() {
}
modifier senderIsOrigin() {
}
function _startTokenId() internal pure override returns (uint256) {
}
function withdraw() external isAdminOrOwner {
}
function _batchMint(
address _address,
uint256 _claimQty,
uint16 _batchSize
) private {
}
function airdropMintTo(address _address, uint256 _qty)
external
isAdminOrOwner
{
}
function redeemVoucher(
address _address,
uint256 _approvedQty,
uint256 _price,
uint256 _nonce,
uint256 _expiryTimestamp,
bool _isLastItemFree,
uint256 _claimQty,
bytes calldata _voucher
) external payable senderIsOrigin {
}
function mintSale(uint256 _claimQty, uint256 _publicSaleKey)
external
payable
senderIsOrigin
{
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberMinted(address _owner) public view returns (uint256) {
}
function numberBurned(address _owner) public view returns (uint256) {
}
function numberMintedVouchers(address _owner)
public
view
returns (uint256)
{
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
function tokenData(uint256 _tokenId) public view returns (bytes memory) {
}
function isApprovedForAll(address _owner, address _operator)
public
view
override
returns (bool)
{
}
function batchTransferFrom(
address _from,
address[] calldata _to,
uint256[] calldata _tokenIds,
bool _safe
) public {
}
function batchBurn(uint256[] calldata _tokenIds) public {
}
function _verifySignature(
address _signer,
bytes32 _hash,
bytes memory _signature
) private pure returns (bool) {
}
}
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| (_newMaxTotalSupply<saleConfig.MAX_TOTAL_SUPPLY)&&(_totalMinted()<=_newMaxTotalSupply) | 114,176 | (_newMaxTotalSupply<saleConfig.MAX_TOTAL_SUPPLY)&&(_totalMinted()<=_newMaxTotalSupply) |
"metadata is locked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./ERC721A.sol";
interface MetadataProvider {
function tokenURI(uint256 _tokenId) external view returns (string memory);
function tokenData(uint256 _tokenId) external view returns (bytes memory);
}
contract Keepers is ERC721ABurnable, Ownable {
constructor(
uint16 _maxTotalSupply,
uint16 _publicSaleTxLimit,
uint16 _batchSize
) ERC721A("Keepers", "KEEPERS") {
}
using Strings for uint256;
event VoucherUsed(
address indexed _address,
uint256 _nonce,
uint256 _claimQty
);
string public BASE_URI;
address public metadataProvider;
address public signer;
address public proxyRegistryAddress;
bool IS_METADATA_LOCKED;
bool IS_PROXY_REGISTRY_LOCKED;
mapping(address => bool) public admins;
mapping(uint256 => uint256) public voucherToMinted;
struct SaleConfig {
bool IS_PRESALE_ON; // turns on redeemVoucher functionality
bool IS_PUBLIC_SALE_ON; // turn on mintSale
uint16 BATCH_SIZE; // controls ERC721A max mint ranges to balance transfer cost for big batches
uint16 MAX_TOTAL_SUPPLY;
uint16 PUBLIC_SALE_KEY; // key to unlock public sale when it's on
uint16 MAX_TX_PUBLIC_SALE_CLAIM_QTY; // max tokens that can be minted per transaction
uint16 MAX_ADDRESS_PUBLIC_SALE_CLAIM_QTY; // max tokens that can be minted per address (public sale)
uint16 BONUS_QTY; // if public sale transaction mints more than this qty then free mint is granted per each bonus qty
uint16 FREE_MINT_RANGE_END; // makes a range of tokens free (e.g first 500 minted during public sale)
uint64 SALE_MINT_PRICE;
}
SaleConfig public saleConfig;
function setAdmins(address[] calldata _admins, bool _isActive)
external
isAdminOrOwner
{
}
function setFreeMintRangeEnd(uint256 offset) external isAdminOrOwner {
}
function setBatchSize(uint16 _batchSize) external isAdminOrOwner {
}
function setBonusQty(uint16 _bonusQty) external isAdminOrOwner {
}
function setSigner(address _signer) external isAdminOrOwner {
}
function setProxyRegistryAddress(address _proxyRegistry)
external
isAdminOrOwner
{
}
function lockProxyRegistry() external isAdminOrOwner {
}
function setMaxTxPublicSaleQty(uint16 _maxQty) external isAdminOrOwner {
}
function setMaxAddressPublicSaleQty(uint16 _maxQty)
external
isAdminOrOwner
{
}
function setIsPublicSaleOn(bool _isOn, uint16 _publicSaleKey)
external
isAdminOrOwner
{
}
function setIsPresaleOn(bool _isOn) external isAdminOrOwner {
}
function reduceMaxTotalSupply(uint16 _newMaxTotalSupply)
external
isAdminOrOwner
{
}
function lockMetadata() external isAdminOrOwner {
}
function setSaleMintPrice(uint256 _newSaleMintPrice)
external
isAdminOrOwner
{
}
function setMetadataProvider(address _provider) external isAdminOrOwner {
require(<FILL_ME>)
metadataProvider = _provider;
}
function setBaseURI(string calldata _baseURI) external isAdminOrOwner {
}
function _checkIfSenderIsOrigin() private view {
}
function _isAdminOrOwner() private view {
}
modifier isAdminOrOwner() {
}
modifier senderIsOrigin() {
}
function _startTokenId() internal pure override returns (uint256) {
}
function withdraw() external isAdminOrOwner {
}
function _batchMint(
address _address,
uint256 _claimQty,
uint16 _batchSize
) private {
}
function airdropMintTo(address _address, uint256 _qty)
external
isAdminOrOwner
{
}
function redeemVoucher(
address _address,
uint256 _approvedQty,
uint256 _price,
uint256 _nonce,
uint256 _expiryTimestamp,
bool _isLastItemFree,
uint256 _claimQty,
bytes calldata _voucher
) external payable senderIsOrigin {
}
function mintSale(uint256 _claimQty, uint256 _publicSaleKey)
external
payable
senderIsOrigin
{
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberMinted(address _owner) public view returns (uint256) {
}
function numberBurned(address _owner) public view returns (uint256) {
}
function numberMintedVouchers(address _owner)
public
view
returns (uint256)
{
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
function tokenData(uint256 _tokenId) public view returns (bytes memory) {
}
function isApprovedForAll(address _owner, address _operator)
public
view
override
returns (bool)
{
}
function batchTransferFrom(
address _from,
address[] calldata _to,
uint256[] calldata _tokenIds,
bool _safe
) public {
}
function batchBurn(uint256[] calldata _tokenIds) public {
}
function _verifySignature(
address _signer,
bytes32 _hash,
bytes memory _signature
) private pure returns (bool) {
}
}
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| !IS_METADATA_LOCKED,"metadata is locked" | 114,176 | !IS_METADATA_LOCKED |
"caller is not admin or owner" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./ERC721A.sol";
interface MetadataProvider {
function tokenURI(uint256 _tokenId) external view returns (string memory);
function tokenData(uint256 _tokenId) external view returns (bytes memory);
}
contract Keepers is ERC721ABurnable, Ownable {
constructor(
uint16 _maxTotalSupply,
uint16 _publicSaleTxLimit,
uint16 _batchSize
) ERC721A("Keepers", "KEEPERS") {
}
using Strings for uint256;
event VoucherUsed(
address indexed _address,
uint256 _nonce,
uint256 _claimQty
);
string public BASE_URI;
address public metadataProvider;
address public signer;
address public proxyRegistryAddress;
bool IS_METADATA_LOCKED;
bool IS_PROXY_REGISTRY_LOCKED;
mapping(address => bool) public admins;
mapping(uint256 => uint256) public voucherToMinted;
struct SaleConfig {
bool IS_PRESALE_ON; // turns on redeemVoucher functionality
bool IS_PUBLIC_SALE_ON; // turn on mintSale
uint16 BATCH_SIZE; // controls ERC721A max mint ranges to balance transfer cost for big batches
uint16 MAX_TOTAL_SUPPLY;
uint16 PUBLIC_SALE_KEY; // key to unlock public sale when it's on
uint16 MAX_TX_PUBLIC_SALE_CLAIM_QTY; // max tokens that can be minted per transaction
uint16 MAX_ADDRESS_PUBLIC_SALE_CLAIM_QTY; // max tokens that can be minted per address (public sale)
uint16 BONUS_QTY; // if public sale transaction mints more than this qty then free mint is granted per each bonus qty
uint16 FREE_MINT_RANGE_END; // makes a range of tokens free (e.g first 500 minted during public sale)
uint64 SALE_MINT_PRICE;
}
SaleConfig public saleConfig;
function setAdmins(address[] calldata _admins, bool _isActive)
external
isAdminOrOwner
{
}
function setFreeMintRangeEnd(uint256 offset) external isAdminOrOwner {
}
function setBatchSize(uint16 _batchSize) external isAdminOrOwner {
}
function setBonusQty(uint16 _bonusQty) external isAdminOrOwner {
}
function setSigner(address _signer) external isAdminOrOwner {
}
function setProxyRegistryAddress(address _proxyRegistry)
external
isAdminOrOwner
{
}
function lockProxyRegistry() external isAdminOrOwner {
}
function setMaxTxPublicSaleQty(uint16 _maxQty) external isAdminOrOwner {
}
function setMaxAddressPublicSaleQty(uint16 _maxQty)
external
isAdminOrOwner
{
}
function setIsPublicSaleOn(bool _isOn, uint16 _publicSaleKey)
external
isAdminOrOwner
{
}
function setIsPresaleOn(bool _isOn) external isAdminOrOwner {
}
function reduceMaxTotalSupply(uint16 _newMaxTotalSupply)
external
isAdminOrOwner
{
}
function lockMetadata() external isAdminOrOwner {
}
function setSaleMintPrice(uint256 _newSaleMintPrice)
external
isAdminOrOwner
{
}
function setMetadataProvider(address _provider) external isAdminOrOwner {
}
function setBaseURI(string calldata _baseURI) external isAdminOrOwner {
}
function _checkIfSenderIsOrigin() private view {
}
function _isAdminOrOwner() private view {
require(<FILL_ME>)
}
modifier isAdminOrOwner() {
}
modifier senderIsOrigin() {
}
function _startTokenId() internal pure override returns (uint256) {
}
function withdraw() external isAdminOrOwner {
}
function _batchMint(
address _address,
uint256 _claimQty,
uint16 _batchSize
) private {
}
function airdropMintTo(address _address, uint256 _qty)
external
isAdminOrOwner
{
}
function redeemVoucher(
address _address,
uint256 _approvedQty,
uint256 _price,
uint256 _nonce,
uint256 _expiryTimestamp,
bool _isLastItemFree,
uint256 _claimQty,
bytes calldata _voucher
) external payable senderIsOrigin {
}
function mintSale(uint256 _claimQty, uint256 _publicSaleKey)
external
payable
senderIsOrigin
{
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberMinted(address _owner) public view returns (uint256) {
}
function numberBurned(address _owner) public view returns (uint256) {
}
function numberMintedVouchers(address _owner)
public
view
returns (uint256)
{
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
function tokenData(uint256 _tokenId) public view returns (bytes memory) {
}
function isApprovedForAll(address _owner, address _operator)
public
view
override
returns (bool)
{
}
function batchTransferFrom(
address _from,
address[] calldata _to,
uint256[] calldata _tokenIds,
bool _safe
) public {
}
function batchBurn(uint256[] calldata _tokenIds) public {
}
function _verifySignature(
address _signer,
bytes32 _hash,
bytes memory _signature
) private pure returns (bool) {
}
}
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| admins[msg.sender]||owner()==msg.sender,"caller is not admin or owner" | 114,176 | admins[msg.sender]||owner()==msg.sender |
"exceeds collection size" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./ERC721A.sol";
interface MetadataProvider {
function tokenURI(uint256 _tokenId) external view returns (string memory);
function tokenData(uint256 _tokenId) external view returns (bytes memory);
}
contract Keepers is ERC721ABurnable, Ownable {
constructor(
uint16 _maxTotalSupply,
uint16 _publicSaleTxLimit,
uint16 _batchSize
) ERC721A("Keepers", "KEEPERS") {
}
using Strings for uint256;
event VoucherUsed(
address indexed _address,
uint256 _nonce,
uint256 _claimQty
);
string public BASE_URI;
address public metadataProvider;
address public signer;
address public proxyRegistryAddress;
bool IS_METADATA_LOCKED;
bool IS_PROXY_REGISTRY_LOCKED;
mapping(address => bool) public admins;
mapping(uint256 => uint256) public voucherToMinted;
struct SaleConfig {
bool IS_PRESALE_ON; // turns on redeemVoucher functionality
bool IS_PUBLIC_SALE_ON; // turn on mintSale
uint16 BATCH_SIZE; // controls ERC721A max mint ranges to balance transfer cost for big batches
uint16 MAX_TOTAL_SUPPLY;
uint16 PUBLIC_SALE_KEY; // key to unlock public sale when it's on
uint16 MAX_TX_PUBLIC_SALE_CLAIM_QTY; // max tokens that can be minted per transaction
uint16 MAX_ADDRESS_PUBLIC_SALE_CLAIM_QTY; // max tokens that can be minted per address (public sale)
uint16 BONUS_QTY; // if public sale transaction mints more than this qty then free mint is granted per each bonus qty
uint16 FREE_MINT_RANGE_END; // makes a range of tokens free (e.g first 500 minted during public sale)
uint64 SALE_MINT_PRICE;
}
SaleConfig public saleConfig;
function setAdmins(address[] calldata _admins, bool _isActive)
external
isAdminOrOwner
{
}
function setFreeMintRangeEnd(uint256 offset) external isAdminOrOwner {
}
function setBatchSize(uint16 _batchSize) external isAdminOrOwner {
}
function setBonusQty(uint16 _bonusQty) external isAdminOrOwner {
}
function setSigner(address _signer) external isAdminOrOwner {
}
function setProxyRegistryAddress(address _proxyRegistry)
external
isAdminOrOwner
{
}
function lockProxyRegistry() external isAdminOrOwner {
}
function setMaxTxPublicSaleQty(uint16 _maxQty) external isAdminOrOwner {
}
function setMaxAddressPublicSaleQty(uint16 _maxQty)
external
isAdminOrOwner
{
}
function setIsPublicSaleOn(bool _isOn, uint16 _publicSaleKey)
external
isAdminOrOwner
{
}
function setIsPresaleOn(bool _isOn) external isAdminOrOwner {
}
function reduceMaxTotalSupply(uint16 _newMaxTotalSupply)
external
isAdminOrOwner
{
}
function lockMetadata() external isAdminOrOwner {
}
function setSaleMintPrice(uint256 _newSaleMintPrice)
external
isAdminOrOwner
{
}
function setMetadataProvider(address _provider) external isAdminOrOwner {
}
function setBaseURI(string calldata _baseURI) external isAdminOrOwner {
}
function _checkIfSenderIsOrigin() private view {
}
function _isAdminOrOwner() private view {
}
modifier isAdminOrOwner() {
}
modifier senderIsOrigin() {
}
function _startTokenId() internal pure override returns (uint256) {
}
function withdraw() external isAdminOrOwner {
}
function _batchMint(
address _address,
uint256 _claimQty,
uint16 _batchSize
) private {
}
function airdropMintTo(address _address, uint256 _qty)
external
isAdminOrOwner
{
SaleConfig memory cfg = saleConfig;
require(<FILL_ME>)
_setAux(_address, uint64(_getAux(_address) + _qty));
_batchMint(_address, _qty, cfg.BATCH_SIZE);
}
function redeemVoucher(
address _address,
uint256 _approvedQty,
uint256 _price,
uint256 _nonce,
uint256 _expiryTimestamp,
bool _isLastItemFree,
uint256 _claimQty,
bytes calldata _voucher
) external payable senderIsOrigin {
}
function mintSale(uint256 _claimQty, uint256 _publicSaleKey)
external
payable
senderIsOrigin
{
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberMinted(address _owner) public view returns (uint256) {
}
function numberBurned(address _owner) public view returns (uint256) {
}
function numberMintedVouchers(address _owner)
public
view
returns (uint256)
{
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
function tokenData(uint256 _tokenId) public view returns (bytes memory) {
}
function isApprovedForAll(address _owner, address _operator)
public
view
override
returns (bool)
{
}
function batchTransferFrom(
address _from,
address[] calldata _to,
uint256[] calldata _tokenIds,
bool _safe
) public {
}
function batchBurn(uint256[] calldata _tokenIds) public {
}
function _verifySignature(
address _signer,
bytes32 _hash,
bytes memory _signature
) private pure returns (bool) {
}
}
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| _totalMinted()+_qty<=cfg.MAX_TOTAL_SUPPLY,"exceeds collection size" | 114,176 | _totalMinted()+_qty<=cfg.MAX_TOTAL_SUPPLY |
"presale is not active" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./ERC721A.sol";
interface MetadataProvider {
function tokenURI(uint256 _tokenId) external view returns (string memory);
function tokenData(uint256 _tokenId) external view returns (bytes memory);
}
contract Keepers is ERC721ABurnable, Ownable {
constructor(
uint16 _maxTotalSupply,
uint16 _publicSaleTxLimit,
uint16 _batchSize
) ERC721A("Keepers", "KEEPERS") {
}
using Strings for uint256;
event VoucherUsed(
address indexed _address,
uint256 _nonce,
uint256 _claimQty
);
string public BASE_URI;
address public metadataProvider;
address public signer;
address public proxyRegistryAddress;
bool IS_METADATA_LOCKED;
bool IS_PROXY_REGISTRY_LOCKED;
mapping(address => bool) public admins;
mapping(uint256 => uint256) public voucherToMinted;
struct SaleConfig {
bool IS_PRESALE_ON; // turns on redeemVoucher functionality
bool IS_PUBLIC_SALE_ON; // turn on mintSale
uint16 BATCH_SIZE; // controls ERC721A max mint ranges to balance transfer cost for big batches
uint16 MAX_TOTAL_SUPPLY;
uint16 PUBLIC_SALE_KEY; // key to unlock public sale when it's on
uint16 MAX_TX_PUBLIC_SALE_CLAIM_QTY; // max tokens that can be minted per transaction
uint16 MAX_ADDRESS_PUBLIC_SALE_CLAIM_QTY; // max tokens that can be minted per address (public sale)
uint16 BONUS_QTY; // if public sale transaction mints more than this qty then free mint is granted per each bonus qty
uint16 FREE_MINT_RANGE_END; // makes a range of tokens free (e.g first 500 minted during public sale)
uint64 SALE_MINT_PRICE;
}
SaleConfig public saleConfig;
function setAdmins(address[] calldata _admins, bool _isActive)
external
isAdminOrOwner
{
}
function setFreeMintRangeEnd(uint256 offset) external isAdminOrOwner {
}
function setBatchSize(uint16 _batchSize) external isAdminOrOwner {
}
function setBonusQty(uint16 _bonusQty) external isAdminOrOwner {
}
function setSigner(address _signer) external isAdminOrOwner {
}
function setProxyRegistryAddress(address _proxyRegistry)
external
isAdminOrOwner
{
}
function lockProxyRegistry() external isAdminOrOwner {
}
function setMaxTxPublicSaleQty(uint16 _maxQty) external isAdminOrOwner {
}
function setMaxAddressPublicSaleQty(uint16 _maxQty)
external
isAdminOrOwner
{
}
function setIsPublicSaleOn(bool _isOn, uint16 _publicSaleKey)
external
isAdminOrOwner
{
}
function setIsPresaleOn(bool _isOn) external isAdminOrOwner {
}
function reduceMaxTotalSupply(uint16 _newMaxTotalSupply)
external
isAdminOrOwner
{
}
function lockMetadata() external isAdminOrOwner {
}
function setSaleMintPrice(uint256 _newSaleMintPrice)
external
isAdminOrOwner
{
}
function setMetadataProvider(address _provider) external isAdminOrOwner {
}
function setBaseURI(string calldata _baseURI) external isAdminOrOwner {
}
function _checkIfSenderIsOrigin() private view {
}
function _isAdminOrOwner() private view {
}
modifier isAdminOrOwner() {
}
modifier senderIsOrigin() {
}
function _startTokenId() internal pure override returns (uint256) {
}
function withdraw() external isAdminOrOwner {
}
function _batchMint(
address _address,
uint256 _claimQty,
uint16 _batchSize
) private {
}
function airdropMintTo(address _address, uint256 _qty)
external
isAdminOrOwner
{
}
function redeemVoucher(
address _address,
uint256 _approvedQty,
uint256 _price,
uint256 _nonce,
uint256 _expiryTimestamp,
bool _isLastItemFree,
uint256 _claimQty,
bytes calldata _voucher
) external payable senderIsOrigin {
SaleConfig memory cfg = saleConfig;
require(<FILL_ME>)
require(
_totalMinted() + _claimQty <= cfg.MAX_TOTAL_SUPPLY,
"exceeds collection size"
);
if (_expiryTimestamp != 0) {
require(block.timestamp < _expiryTimestamp, "voucher is expired");
}
bytes32 hash = keccak256(
abi.encodePacked(
_address,
_approvedQty,
_price,
_nonce,
_expiryTimestamp,
_isLastItemFree
)
);
require(_verifySignature(signer, hash, _voucher), "invalid signature");
uint256 totalWithClaimed = voucherToMinted[uint256(hash)] + _claimQty;
require(totalWithClaimed <= _approvedQty, "exceeds approved qty");
voucherToMinted[uint256(hash)] += _claimQty;
// Make last item free if voucher allows
string memory err = "not enough funds sent";
if (totalWithClaimed == _approvedQty && _isLastItemFree) {
require(msg.value >= _price * (_claimQty - 1), err);
} else {
require(msg.value >= _price * _claimQty, err);
}
// incrementing total number of minted vouchers
uint64 newTotalMintedVouchers = uint64(_getAux(_address) + _claimQty);
_setAux(_address, newTotalMintedVouchers);
_batchMint(_address, _claimQty, cfg.BATCH_SIZE);
emit VoucherUsed(_address, _nonce, _claimQty);
}
function mintSale(uint256 _claimQty, uint256 _publicSaleKey)
external
payable
senderIsOrigin
{
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberMinted(address _owner) public view returns (uint256) {
}
function numberBurned(address _owner) public view returns (uint256) {
}
function numberMintedVouchers(address _owner)
public
view
returns (uint256)
{
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
function tokenData(uint256 _tokenId) public view returns (bytes memory) {
}
function isApprovedForAll(address _owner, address _operator)
public
view
override
returns (bool)
{
}
function batchTransferFrom(
address _from,
address[] calldata _to,
uint256[] calldata _tokenIds,
bool _safe
) public {
}
function batchBurn(uint256[] calldata _tokenIds) public {
}
function _verifySignature(
address _signer,
bytes32 _hash,
bytes memory _signature
) private pure returns (bool) {
}
}
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| cfg.IS_PRESALE_ON,"presale is not active" | 114,176 | cfg.IS_PRESALE_ON |
"exceeds collection size" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./ERC721A.sol";
interface MetadataProvider {
function tokenURI(uint256 _tokenId) external view returns (string memory);
function tokenData(uint256 _tokenId) external view returns (bytes memory);
}
contract Keepers is ERC721ABurnable, Ownable {
constructor(
uint16 _maxTotalSupply,
uint16 _publicSaleTxLimit,
uint16 _batchSize
) ERC721A("Keepers", "KEEPERS") {
}
using Strings for uint256;
event VoucherUsed(
address indexed _address,
uint256 _nonce,
uint256 _claimQty
);
string public BASE_URI;
address public metadataProvider;
address public signer;
address public proxyRegistryAddress;
bool IS_METADATA_LOCKED;
bool IS_PROXY_REGISTRY_LOCKED;
mapping(address => bool) public admins;
mapping(uint256 => uint256) public voucherToMinted;
struct SaleConfig {
bool IS_PRESALE_ON; // turns on redeemVoucher functionality
bool IS_PUBLIC_SALE_ON; // turn on mintSale
uint16 BATCH_SIZE; // controls ERC721A max mint ranges to balance transfer cost for big batches
uint16 MAX_TOTAL_SUPPLY;
uint16 PUBLIC_SALE_KEY; // key to unlock public sale when it's on
uint16 MAX_TX_PUBLIC_SALE_CLAIM_QTY; // max tokens that can be minted per transaction
uint16 MAX_ADDRESS_PUBLIC_SALE_CLAIM_QTY; // max tokens that can be minted per address (public sale)
uint16 BONUS_QTY; // if public sale transaction mints more than this qty then free mint is granted per each bonus qty
uint16 FREE_MINT_RANGE_END; // makes a range of tokens free (e.g first 500 minted during public sale)
uint64 SALE_MINT_PRICE;
}
SaleConfig public saleConfig;
function setAdmins(address[] calldata _admins, bool _isActive)
external
isAdminOrOwner
{
}
function setFreeMintRangeEnd(uint256 offset) external isAdminOrOwner {
}
function setBatchSize(uint16 _batchSize) external isAdminOrOwner {
}
function setBonusQty(uint16 _bonusQty) external isAdminOrOwner {
}
function setSigner(address _signer) external isAdminOrOwner {
}
function setProxyRegistryAddress(address _proxyRegistry)
external
isAdminOrOwner
{
}
function lockProxyRegistry() external isAdminOrOwner {
}
function setMaxTxPublicSaleQty(uint16 _maxQty) external isAdminOrOwner {
}
function setMaxAddressPublicSaleQty(uint16 _maxQty)
external
isAdminOrOwner
{
}
function setIsPublicSaleOn(bool _isOn, uint16 _publicSaleKey)
external
isAdminOrOwner
{
}
function setIsPresaleOn(bool _isOn) external isAdminOrOwner {
}
function reduceMaxTotalSupply(uint16 _newMaxTotalSupply)
external
isAdminOrOwner
{
}
function lockMetadata() external isAdminOrOwner {
}
function setSaleMintPrice(uint256 _newSaleMintPrice)
external
isAdminOrOwner
{
}
function setMetadataProvider(address _provider) external isAdminOrOwner {
}
function setBaseURI(string calldata _baseURI) external isAdminOrOwner {
}
function _checkIfSenderIsOrigin() private view {
}
function _isAdminOrOwner() private view {
}
modifier isAdminOrOwner() {
}
modifier senderIsOrigin() {
}
function _startTokenId() internal pure override returns (uint256) {
}
function withdraw() external isAdminOrOwner {
}
function _batchMint(
address _address,
uint256 _claimQty,
uint16 _batchSize
) private {
}
function airdropMintTo(address _address, uint256 _qty)
external
isAdminOrOwner
{
}
function redeemVoucher(
address _address,
uint256 _approvedQty,
uint256 _price,
uint256 _nonce,
uint256 _expiryTimestamp,
bool _isLastItemFree,
uint256 _claimQty,
bytes calldata _voucher
) external payable senderIsOrigin {
SaleConfig memory cfg = saleConfig;
require(cfg.IS_PRESALE_ON, "presale is not active");
require(<FILL_ME>)
if (_expiryTimestamp != 0) {
require(block.timestamp < _expiryTimestamp, "voucher is expired");
}
bytes32 hash = keccak256(
abi.encodePacked(
_address,
_approvedQty,
_price,
_nonce,
_expiryTimestamp,
_isLastItemFree
)
);
require(_verifySignature(signer, hash, _voucher), "invalid signature");
uint256 totalWithClaimed = voucherToMinted[uint256(hash)] + _claimQty;
require(totalWithClaimed <= _approvedQty, "exceeds approved qty");
voucherToMinted[uint256(hash)] += _claimQty;
// Make last item free if voucher allows
string memory err = "not enough funds sent";
if (totalWithClaimed == _approvedQty && _isLastItemFree) {
require(msg.value >= _price * (_claimQty - 1), err);
} else {
require(msg.value >= _price * _claimQty, err);
}
// incrementing total number of minted vouchers
uint64 newTotalMintedVouchers = uint64(_getAux(_address) + _claimQty);
_setAux(_address, newTotalMintedVouchers);
_batchMint(_address, _claimQty, cfg.BATCH_SIZE);
emit VoucherUsed(_address, _nonce, _claimQty);
}
function mintSale(uint256 _claimQty, uint256 _publicSaleKey)
external
payable
senderIsOrigin
{
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberMinted(address _owner) public view returns (uint256) {
}
function numberBurned(address _owner) public view returns (uint256) {
}
function numberMintedVouchers(address _owner)
public
view
returns (uint256)
{
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
function tokenData(uint256 _tokenId) public view returns (bytes memory) {
}
function isApprovedForAll(address _owner, address _operator)
public
view
override
returns (bool)
{
}
function batchTransferFrom(
address _from,
address[] calldata _to,
uint256[] calldata _tokenIds,
bool _safe
) public {
}
function batchBurn(uint256[] calldata _tokenIds) public {
}
function _verifySignature(
address _signer,
bytes32 _hash,
bytes memory _signature
) private pure returns (bool) {
}
}
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| _totalMinted()+_claimQty<=cfg.MAX_TOTAL_SUPPLY,"exceeds collection size" | 114,176 | _totalMinted()+_claimQty<=cfg.MAX_TOTAL_SUPPLY |
"invalid signature" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./ERC721A.sol";
interface MetadataProvider {
function tokenURI(uint256 _tokenId) external view returns (string memory);
function tokenData(uint256 _tokenId) external view returns (bytes memory);
}
contract Keepers is ERC721ABurnable, Ownable {
constructor(
uint16 _maxTotalSupply,
uint16 _publicSaleTxLimit,
uint16 _batchSize
) ERC721A("Keepers", "KEEPERS") {
}
using Strings for uint256;
event VoucherUsed(
address indexed _address,
uint256 _nonce,
uint256 _claimQty
);
string public BASE_URI;
address public metadataProvider;
address public signer;
address public proxyRegistryAddress;
bool IS_METADATA_LOCKED;
bool IS_PROXY_REGISTRY_LOCKED;
mapping(address => bool) public admins;
mapping(uint256 => uint256) public voucherToMinted;
struct SaleConfig {
bool IS_PRESALE_ON; // turns on redeemVoucher functionality
bool IS_PUBLIC_SALE_ON; // turn on mintSale
uint16 BATCH_SIZE; // controls ERC721A max mint ranges to balance transfer cost for big batches
uint16 MAX_TOTAL_SUPPLY;
uint16 PUBLIC_SALE_KEY; // key to unlock public sale when it's on
uint16 MAX_TX_PUBLIC_SALE_CLAIM_QTY; // max tokens that can be minted per transaction
uint16 MAX_ADDRESS_PUBLIC_SALE_CLAIM_QTY; // max tokens that can be minted per address (public sale)
uint16 BONUS_QTY; // if public sale transaction mints more than this qty then free mint is granted per each bonus qty
uint16 FREE_MINT_RANGE_END; // makes a range of tokens free (e.g first 500 minted during public sale)
uint64 SALE_MINT_PRICE;
}
SaleConfig public saleConfig;
function setAdmins(address[] calldata _admins, bool _isActive)
external
isAdminOrOwner
{
}
function setFreeMintRangeEnd(uint256 offset) external isAdminOrOwner {
}
function setBatchSize(uint16 _batchSize) external isAdminOrOwner {
}
function setBonusQty(uint16 _bonusQty) external isAdminOrOwner {
}
function setSigner(address _signer) external isAdminOrOwner {
}
function setProxyRegistryAddress(address _proxyRegistry)
external
isAdminOrOwner
{
}
function lockProxyRegistry() external isAdminOrOwner {
}
function setMaxTxPublicSaleQty(uint16 _maxQty) external isAdminOrOwner {
}
function setMaxAddressPublicSaleQty(uint16 _maxQty)
external
isAdminOrOwner
{
}
function setIsPublicSaleOn(bool _isOn, uint16 _publicSaleKey)
external
isAdminOrOwner
{
}
function setIsPresaleOn(bool _isOn) external isAdminOrOwner {
}
function reduceMaxTotalSupply(uint16 _newMaxTotalSupply)
external
isAdminOrOwner
{
}
function lockMetadata() external isAdminOrOwner {
}
function setSaleMintPrice(uint256 _newSaleMintPrice)
external
isAdminOrOwner
{
}
function setMetadataProvider(address _provider) external isAdminOrOwner {
}
function setBaseURI(string calldata _baseURI) external isAdminOrOwner {
}
function _checkIfSenderIsOrigin() private view {
}
function _isAdminOrOwner() private view {
}
modifier isAdminOrOwner() {
}
modifier senderIsOrigin() {
}
function _startTokenId() internal pure override returns (uint256) {
}
function withdraw() external isAdminOrOwner {
}
function _batchMint(
address _address,
uint256 _claimQty,
uint16 _batchSize
) private {
}
function airdropMintTo(address _address, uint256 _qty)
external
isAdminOrOwner
{
}
function redeemVoucher(
address _address,
uint256 _approvedQty,
uint256 _price,
uint256 _nonce,
uint256 _expiryTimestamp,
bool _isLastItemFree,
uint256 _claimQty,
bytes calldata _voucher
) external payable senderIsOrigin {
SaleConfig memory cfg = saleConfig;
require(cfg.IS_PRESALE_ON, "presale is not active");
require(
_totalMinted() + _claimQty <= cfg.MAX_TOTAL_SUPPLY,
"exceeds collection size"
);
if (_expiryTimestamp != 0) {
require(block.timestamp < _expiryTimestamp, "voucher is expired");
}
bytes32 hash = keccak256(
abi.encodePacked(
_address,
_approvedQty,
_price,
_nonce,
_expiryTimestamp,
_isLastItemFree
)
);
require(<FILL_ME>)
uint256 totalWithClaimed = voucherToMinted[uint256(hash)] + _claimQty;
require(totalWithClaimed <= _approvedQty, "exceeds approved qty");
voucherToMinted[uint256(hash)] += _claimQty;
// Make last item free if voucher allows
string memory err = "not enough funds sent";
if (totalWithClaimed == _approvedQty && _isLastItemFree) {
require(msg.value >= _price * (_claimQty - 1), err);
} else {
require(msg.value >= _price * _claimQty, err);
}
// incrementing total number of minted vouchers
uint64 newTotalMintedVouchers = uint64(_getAux(_address) + _claimQty);
_setAux(_address, newTotalMintedVouchers);
_batchMint(_address, _claimQty, cfg.BATCH_SIZE);
emit VoucherUsed(_address, _nonce, _claimQty);
}
function mintSale(uint256 _claimQty, uint256 _publicSaleKey)
external
payable
senderIsOrigin
{
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberMinted(address _owner) public view returns (uint256) {
}
function numberBurned(address _owner) public view returns (uint256) {
}
function numberMintedVouchers(address _owner)
public
view
returns (uint256)
{
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
function tokenData(uint256 _tokenId) public view returns (bytes memory) {
}
function isApprovedForAll(address _owner, address _operator)
public
view
override
returns (bool)
{
}
function batchTransferFrom(
address _from,
address[] calldata _to,
uint256[] calldata _tokenIds,
bool _safe
) public {
}
function batchBurn(uint256[] calldata _tokenIds) public {
}
function _verifySignature(
address _signer,
bytes32 _hash,
bytes memory _signature
) private pure returns (bool) {
}
}
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| _verifySignature(signer,hash,_voucher),"invalid signature" | 114,176 | _verifySignature(signer,hash,_voucher) |
"sale is not active" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./ERC721A.sol";
interface MetadataProvider {
function tokenURI(uint256 _tokenId) external view returns (string memory);
function tokenData(uint256 _tokenId) external view returns (bytes memory);
}
contract Keepers is ERC721ABurnable, Ownable {
constructor(
uint16 _maxTotalSupply,
uint16 _publicSaleTxLimit,
uint16 _batchSize
) ERC721A("Keepers", "KEEPERS") {
}
using Strings for uint256;
event VoucherUsed(
address indexed _address,
uint256 _nonce,
uint256 _claimQty
);
string public BASE_URI;
address public metadataProvider;
address public signer;
address public proxyRegistryAddress;
bool IS_METADATA_LOCKED;
bool IS_PROXY_REGISTRY_LOCKED;
mapping(address => bool) public admins;
mapping(uint256 => uint256) public voucherToMinted;
struct SaleConfig {
bool IS_PRESALE_ON; // turns on redeemVoucher functionality
bool IS_PUBLIC_SALE_ON; // turn on mintSale
uint16 BATCH_SIZE; // controls ERC721A max mint ranges to balance transfer cost for big batches
uint16 MAX_TOTAL_SUPPLY;
uint16 PUBLIC_SALE_KEY; // key to unlock public sale when it's on
uint16 MAX_TX_PUBLIC_SALE_CLAIM_QTY; // max tokens that can be minted per transaction
uint16 MAX_ADDRESS_PUBLIC_SALE_CLAIM_QTY; // max tokens that can be minted per address (public sale)
uint16 BONUS_QTY; // if public sale transaction mints more than this qty then free mint is granted per each bonus qty
uint16 FREE_MINT_RANGE_END; // makes a range of tokens free (e.g first 500 minted during public sale)
uint64 SALE_MINT_PRICE;
}
SaleConfig public saleConfig;
function setAdmins(address[] calldata _admins, bool _isActive)
external
isAdminOrOwner
{
}
function setFreeMintRangeEnd(uint256 offset) external isAdminOrOwner {
}
function setBatchSize(uint16 _batchSize) external isAdminOrOwner {
}
function setBonusQty(uint16 _bonusQty) external isAdminOrOwner {
}
function setSigner(address _signer) external isAdminOrOwner {
}
function setProxyRegistryAddress(address _proxyRegistry)
external
isAdminOrOwner
{
}
function lockProxyRegistry() external isAdminOrOwner {
}
function setMaxTxPublicSaleQty(uint16 _maxQty) external isAdminOrOwner {
}
function setMaxAddressPublicSaleQty(uint16 _maxQty)
external
isAdminOrOwner
{
}
function setIsPublicSaleOn(bool _isOn, uint16 _publicSaleKey)
external
isAdminOrOwner
{
}
function setIsPresaleOn(bool _isOn) external isAdminOrOwner {
}
function reduceMaxTotalSupply(uint16 _newMaxTotalSupply)
external
isAdminOrOwner
{
}
function lockMetadata() external isAdminOrOwner {
}
function setSaleMintPrice(uint256 _newSaleMintPrice)
external
isAdminOrOwner
{
}
function setMetadataProvider(address _provider) external isAdminOrOwner {
}
function setBaseURI(string calldata _baseURI) external isAdminOrOwner {
}
function _checkIfSenderIsOrigin() private view {
}
function _isAdminOrOwner() private view {
}
modifier isAdminOrOwner() {
}
modifier senderIsOrigin() {
}
function _startTokenId() internal pure override returns (uint256) {
}
function withdraw() external isAdminOrOwner {
}
function _batchMint(
address _address,
uint256 _claimQty,
uint16 _batchSize
) private {
}
function airdropMintTo(address _address, uint256 _qty)
external
isAdminOrOwner
{
}
function redeemVoucher(
address _address,
uint256 _approvedQty,
uint256 _price,
uint256 _nonce,
uint256 _expiryTimestamp,
bool _isLastItemFree,
uint256 _claimQty,
bytes calldata _voucher
) external payable senderIsOrigin {
}
function mintSale(uint256 _claimQty, uint256 _publicSaleKey)
external
payable
senderIsOrigin
{
SaleConfig memory cfg = saleConfig;
require(<FILL_ME>)
require(cfg.PUBLIC_SALE_KEY == _publicSaleKey, "wrong key");
if (cfg.FREE_MINT_RANGE_END < _totalMinted() + _claimQty) {
// calculate discount
uint256 discount = cfg.BONUS_QTY == 0
? 0
: _claimQty / cfg.BONUS_QTY;
require(
msg.value >= cfg.SALE_MINT_PRICE * (_claimQty - discount),
"not enough funds sent"
);
}
require(
_totalMinted() + _claimQty <= cfg.MAX_TOTAL_SUPPLY,
"exceeds collection size"
);
require(
_claimQty <= cfg.MAX_TX_PUBLIC_SALE_CLAIM_QTY,
"claiming too much"
);
if (cfg.MAX_ADDRESS_PUBLIC_SALE_CLAIM_QTY != 0) {
require(
_numberMinted(msg.sender) - _getAux(msg.sender) + _claimQty <=
cfg.MAX_ADDRESS_PUBLIC_SALE_CLAIM_QTY,
"exceeds allowed claim quantity per address"
);
}
_batchMint(msg.sender, _claimQty, cfg.BATCH_SIZE);
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberMinted(address _owner) public view returns (uint256) {
}
function numberBurned(address _owner) public view returns (uint256) {
}
function numberMintedVouchers(address _owner)
public
view
returns (uint256)
{
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
function tokenData(uint256 _tokenId) public view returns (bytes memory) {
}
function isApprovedForAll(address _owner, address _operator)
public
view
override
returns (bool)
{
}
function batchTransferFrom(
address _from,
address[] calldata _to,
uint256[] calldata _tokenIds,
bool _safe
) public {
}
function batchBurn(uint256[] calldata _tokenIds) public {
}
function _verifySignature(
address _signer,
bytes32 _hash,
bytes memory _signature
) private pure returns (bool) {
}
}
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| cfg.IS_PUBLIC_SALE_ON,"sale is not active" | 114,176 | cfg.IS_PUBLIC_SALE_ON |
"exceeds allowed claim quantity per address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./ERC721A.sol";
interface MetadataProvider {
function tokenURI(uint256 _tokenId) external view returns (string memory);
function tokenData(uint256 _tokenId) external view returns (bytes memory);
}
contract Keepers is ERC721ABurnable, Ownable {
constructor(
uint16 _maxTotalSupply,
uint16 _publicSaleTxLimit,
uint16 _batchSize
) ERC721A("Keepers", "KEEPERS") {
}
using Strings for uint256;
event VoucherUsed(
address indexed _address,
uint256 _nonce,
uint256 _claimQty
);
string public BASE_URI;
address public metadataProvider;
address public signer;
address public proxyRegistryAddress;
bool IS_METADATA_LOCKED;
bool IS_PROXY_REGISTRY_LOCKED;
mapping(address => bool) public admins;
mapping(uint256 => uint256) public voucherToMinted;
struct SaleConfig {
bool IS_PRESALE_ON; // turns on redeemVoucher functionality
bool IS_PUBLIC_SALE_ON; // turn on mintSale
uint16 BATCH_SIZE; // controls ERC721A max mint ranges to balance transfer cost for big batches
uint16 MAX_TOTAL_SUPPLY;
uint16 PUBLIC_SALE_KEY; // key to unlock public sale when it's on
uint16 MAX_TX_PUBLIC_SALE_CLAIM_QTY; // max tokens that can be minted per transaction
uint16 MAX_ADDRESS_PUBLIC_SALE_CLAIM_QTY; // max tokens that can be minted per address (public sale)
uint16 BONUS_QTY; // if public sale transaction mints more than this qty then free mint is granted per each bonus qty
uint16 FREE_MINT_RANGE_END; // makes a range of tokens free (e.g first 500 minted during public sale)
uint64 SALE_MINT_PRICE;
}
SaleConfig public saleConfig;
function setAdmins(address[] calldata _admins, bool _isActive)
external
isAdminOrOwner
{
}
function setFreeMintRangeEnd(uint256 offset) external isAdminOrOwner {
}
function setBatchSize(uint16 _batchSize) external isAdminOrOwner {
}
function setBonusQty(uint16 _bonusQty) external isAdminOrOwner {
}
function setSigner(address _signer) external isAdminOrOwner {
}
function setProxyRegistryAddress(address _proxyRegistry)
external
isAdminOrOwner
{
}
function lockProxyRegistry() external isAdminOrOwner {
}
function setMaxTxPublicSaleQty(uint16 _maxQty) external isAdminOrOwner {
}
function setMaxAddressPublicSaleQty(uint16 _maxQty)
external
isAdminOrOwner
{
}
function setIsPublicSaleOn(bool _isOn, uint16 _publicSaleKey)
external
isAdminOrOwner
{
}
function setIsPresaleOn(bool _isOn) external isAdminOrOwner {
}
function reduceMaxTotalSupply(uint16 _newMaxTotalSupply)
external
isAdminOrOwner
{
}
function lockMetadata() external isAdminOrOwner {
}
function setSaleMintPrice(uint256 _newSaleMintPrice)
external
isAdminOrOwner
{
}
function setMetadataProvider(address _provider) external isAdminOrOwner {
}
function setBaseURI(string calldata _baseURI) external isAdminOrOwner {
}
function _checkIfSenderIsOrigin() private view {
}
function _isAdminOrOwner() private view {
}
modifier isAdminOrOwner() {
}
modifier senderIsOrigin() {
}
function _startTokenId() internal pure override returns (uint256) {
}
function withdraw() external isAdminOrOwner {
}
function _batchMint(
address _address,
uint256 _claimQty,
uint16 _batchSize
) private {
}
function airdropMintTo(address _address, uint256 _qty)
external
isAdminOrOwner
{
}
function redeemVoucher(
address _address,
uint256 _approvedQty,
uint256 _price,
uint256 _nonce,
uint256 _expiryTimestamp,
bool _isLastItemFree,
uint256 _claimQty,
bytes calldata _voucher
) external payable senderIsOrigin {
}
function mintSale(uint256 _claimQty, uint256 _publicSaleKey)
external
payable
senderIsOrigin
{
SaleConfig memory cfg = saleConfig;
require(cfg.IS_PUBLIC_SALE_ON, "sale is not active");
require(cfg.PUBLIC_SALE_KEY == _publicSaleKey, "wrong key");
if (cfg.FREE_MINT_RANGE_END < _totalMinted() + _claimQty) {
// calculate discount
uint256 discount = cfg.BONUS_QTY == 0
? 0
: _claimQty / cfg.BONUS_QTY;
require(
msg.value >= cfg.SALE_MINT_PRICE * (_claimQty - discount),
"not enough funds sent"
);
}
require(
_totalMinted() + _claimQty <= cfg.MAX_TOTAL_SUPPLY,
"exceeds collection size"
);
require(
_claimQty <= cfg.MAX_TX_PUBLIC_SALE_CLAIM_QTY,
"claiming too much"
);
if (cfg.MAX_ADDRESS_PUBLIC_SALE_CLAIM_QTY != 0) {
require(<FILL_ME>)
}
_batchMint(msg.sender, _claimQty, cfg.BATCH_SIZE);
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberMinted(address _owner) public view returns (uint256) {
}
function numberBurned(address _owner) public view returns (uint256) {
}
function numberMintedVouchers(address _owner)
public
view
returns (uint256)
{
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
function tokenData(uint256 _tokenId) public view returns (bytes memory) {
}
function isApprovedForAll(address _owner, address _operator)
public
view
override
returns (bool)
{
}
function batchTransferFrom(
address _from,
address[] calldata _to,
uint256[] calldata _tokenIds,
bool _safe
) public {
}
function batchBurn(uint256[] calldata _tokenIds) public {
}
function _verifySignature(
address _signer,
bytes32 _hash,
bytes memory _signature
) private pure returns (bool) {
}
}
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| _numberMinted(msg.sender)-_getAux(msg.sender)+_claimQty<=cfg.MAX_ADDRESS_PUBLIC_SALE_CLAIM_QTY,"exceeds allowed claim quantity per address" | 114,176 | _numberMinted(msg.sender)-_getAux(msg.sender)+_claimQty<=cfg.MAX_ADDRESS_PUBLIC_SALE_CLAIM_QTY |
"Amount expected up to 250K" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/// @custom:security-contact https://www.projectlambo.io/contact-us
contract ShibaOpal is ERC1155, Ownable {
uint16 mintedAmount;
uint256 public deploymentTimestamp;
uint256 public lockDuration = 11 days;
uint public MAX_NFTS = 250000;
constructor() ERC1155("https://api.projectlambo.com/metadata/") {
}
modifier isTransferAllowed() {
}
function mint(
address _to,
uint256 _tokenId,
bytes memory _data
) external onlyOwner {
require(
_tokenId > 3000000 && _tokenId <= 3250000,
"Token ID expected between 3M and 3.25M"
);
require(<FILL_ME>)
_mint(_to, _tokenId, 1, _data);
mintedAmount += 1;
}
function mintBatch(
address _to,
uint256[] calldata _tokenIds,
uint256[] calldata _supply,
bytes memory _data
) external onlyOwner {
}
function uri(
uint256 _tokenId
) public pure override returns (string memory) {
}
/** Override safeTransferFrom function of ERC1155 to restrict sale until release date i.e 15th august, 2023 */
function safeTransferFrom(
address _from,
address _to,
uint256 _id,
uint256 _amount,
bytes memory _data
) public override isTransferAllowed {
}
/** Override safeBatchTransferFrom function of ERC1155 to restrict sale until release date i.e 15th august, 2023 */
function safeBatchTransferFrom(
address _from,
address _to,
uint256[] memory _id,
uint256[] memory _amount,
bytes memory _data
) public override isTransferAllowed {
}
}
| mintedAmount+1<=MAX_NFTS,"Amount expected up to 250K" | 114,378 | mintedAmount+1<=MAX_NFTS |
"Amount expected up to 250K" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/// @custom:security-contact https://www.projectlambo.io/contact-us
contract ShibaOpal is ERC1155, Ownable {
uint16 mintedAmount;
uint256 public deploymentTimestamp;
uint256 public lockDuration = 11 days;
uint public MAX_NFTS = 250000;
constructor() ERC1155("https://api.projectlambo.com/metadata/") {
}
modifier isTransferAllowed() {
}
function mint(
address _to,
uint256 _tokenId,
bytes memory _data
) external onlyOwner {
}
function mintBatch(
address _to,
uint256[] calldata _tokenIds,
uint256[] calldata _supply,
bytes memory _data
) external onlyOwner {
require(_tokenIds.length == _supply.length, "Input lengths mismatch");
require(<FILL_ME>)
_mintBatch(_to, _tokenIds, _supply, _data);
}
function uri(
uint256 _tokenId
) public pure override returns (string memory) {
}
/** Override safeTransferFrom function of ERC1155 to restrict sale until release date i.e 15th august, 2023 */
function safeTransferFrom(
address _from,
address _to,
uint256 _id,
uint256 _amount,
bytes memory _data
) public override isTransferAllowed {
}
/** Override safeBatchTransferFrom function of ERC1155 to restrict sale until release date i.e 15th august, 2023 */
function safeBatchTransferFrom(
address _from,
address _to,
uint256[] memory _id,
uint256[] memory _amount,
bytes memory _data
) public override isTransferAllowed {
}
}
| mintedAmount+_tokenIds.length<=MAX_NFTS,"Amount expected up to 250K" | 114,378 | mintedAmount+_tokenIds.length<=MAX_NFTS |
'Parrot minting paused.' | // Parrot Social Club
//
// Parrots gain you access to games and contests at the Parrot Social Club
// https://www.parrotsocial.club
//
//
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B?77J&@
// @@@@@@@@@@@@@@&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#7!!7B@@
// @@@@&#BG5YJJ???7777?J5G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&?!!!5#G#
// @@@&J!!!!!7!!!!!75PPP5J?5&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@BPPJ!!!?5PB&
// @@@@G?J5G#B7!!!?B@@@@@@#?Y@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5JJP&@@@@@GYY!!!7&@@@@
// @@@@@&@@@&?!!!J&@@@@@@@@57&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5GB&@@#PP&@@@@G?!!!7Y5??B@@@@G!!!5@@@@@
// @@@@@@@@&?!!!5@@@@@@@@@G75@@@@@&&@@@@@@@@@@@@5?J5B@@BYY#@@@B!!!7#@G7!7&@@&Y!!!7P&@@?!?&@@@J!!!B@@@@@
// @@@@@@@#?!!7G@@@@@&#GY77P@@@BY?77JB@##&@@@@@5!!!J&&5!!7&@@&?!!7##Y!!!7#@&?!!!J#@@@@Y!7#@@&7!!7&@@@@@
// @@@@@@G7!!!7YYJJ??7!7?P&@@BJ!!!7YPB5!!Y@@@@B!!!J&GJ!!!7#@@5!!!YPYBBJ7!P@Y!!!?&@@@@@J!?@@@#7!!?@@@@@@
// @@@@@P!!!JGY???JJYPB&@@@&Y!!!?P&@@Y!!?&@@@&7!!!YYP&#Y77B@#7!!!JB@@@@#B@&7!!7#@@@@@B!!B@@@&7!!7#@@&GG
// @@@@Y!!!Y@@@@@@@@@@@@@@#?!!!5&@@#J!!7#@@@@Y!!!?G@@@@@&&@@Y!!!5@@@@@@@@@#7!!J@@@@@G!?B@@@@#PJ7!?5YYB@
// @@&J!!!5@@@@@@@@@@@@@@&?!!7G@@@G?7!!P@@@@B!!!J&@@@@@@@@@#7!!Y@@@@@@@@@@@5!!7#@&GJ?P&@@@BJ7?Y##BB#@@@
// @B7!!!P@@@@@@@@@@@@@@@G!!!G@@#JY5!!7&@@@@?!!?&@@@@@@@@@@5!!7#@@@&&@@@@@@@BY?JYY5B@@@@@5!!!JB@@@@@@@@
// P!!!!5@@@@@@@@@@@@@@@@B!!7BGYJB@J!!7&@@@G!!!G@@@@@@@@@@@P?7J@@@&?7?P@@@@@@@@&&@@@@@@&J!!?B@@@@@@@@@@
// &57!Y@@@@@@@@@@@@@@@@@@BYJYP#@@@BYJYB@@@&G55@@@@@@@@@@@@@@&&@@@B!!Y#@@@@@@@@@@@@@@@#?!!5&@@@@@@@@@@@
// @@&#&@@@@@@@@@@@@@@#G5YJJ??JJJG@@@@@@@@@@@@@@@@@@@@@@&&&@@@@@@@@PB@@@@&BG#@@@@@@@@#?!!G@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@&5?!77?JJJJ?7~Y@@@@@@@@@&@@@@@@@@@B5J?Y5JB@@@B5G#@@@#Y7!!JBGYG@@@&?!7G@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#7?5B&@@@@@@@&B&@@@@@@BY?7YGB&@@@BJ!!5&@G~5@@P!!!5@@P7!75#@5!!G@@@J!!G@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@Y!B@@@@@@@@@@@@@@@@@&Y!!75#P!J@@G!!7B@@#J5&@#7!!5@@5!!J&@&Y!!G@@@5!!5@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#?7?JY5PGBB#&@@@@@@&?!!J&@@#!7&&7!!P@@@@@@@@P!!J@@B!!Y@@BJ7!Y@@@B!!J@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@BP5YJ??77777J5&@@Y!!J@@@@B!J@@?!!G@@@@##@@J!7#@@P!!B#55G!!G@@@5!!B@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@&&##BPJ?#@?!!B@@@#7?&@@#J!?##P5P&@@G7Y@@@&5?YP#@&YJP@@@G7?@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&7P@P!!G@&P?5@@@@@@B555G&@@@@@&&@@@@@@@@@@@@@@@@@@#B@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@JYB&@@@@@@@@@#P?!#@@BYJ55G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@J!!7?JYYYYJJ7!!JB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@&G5J?7!!!!7?JPB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
pragma abicoder v1;
import '@openzeppelin/contracts/access/Ownable.sol';
import "erc721a/contracts/ERC721A.sol";
import "hardhat/console.sol";
abstract contract ParrotPassContract {
function ownerOf(uint256 tokenId) public view virtual returns (address);
function balanceOf(address owner)
external
view
virtual
returns (uint256 balance);
}
contract ParrotSocialClub is ERC721A, Ownable {
ParrotPassContract public PASS;
uint256 public constant MAX_PARROTS = 8888;
uint256 public constant MAX_RESERVED_PARROTS = 10;
uint256 public passParrotsMinted = 0;
uint256 public paidParrotsMinted = 0;
uint256 public freeParrotsMinted = 0;
address public vault;
uint256 public price = 0.02 ether;
uint256 public MAX_PAID_PARROTS = 4878;
uint256 public MAX_PASS_PARROTS = 2000;
uint256 public MAX_FREE_PARROTS = 2000;
uint public MAX_FREE_PARROTS_PER_WALLET = 2;
bool public mintPaused = true;
string public baseURI;
mapping (uint256 => bool) public claimedParrots;
event MintedParrot(address claimer, uint256 amount);
constructor()
ERC721A('Parrot Social Club', 'PSC')
{}
function mint(uint256 numParrots) external payable {
require(<FILL_ME>)
require(
numParrots > 0 && numParrots <= 20,
'You can mint no more than 20 Parrots at a time.'
);
require(
totalSupply() + numParrots <= MAX_PARROTS,
'There are no more parrots available for minting.'
);
require(
paidParrotsMinted + numParrots <= MAX_PAID_PARROTS,
'There are no more parrots available for paid minting.'
);
require(
msg.value >= price * numParrots,
'Ether value sent is not sufficient'
);
require(tx.origin == msg.sender, 'Cant be called from another contract');
_safeMint(msg.sender, numParrots);
paidParrotsMinted += numParrots;
emit MintedParrot(msg.sender, numParrots);
}
function freemint(uint256 numParrots) external payable {
}
function passClaim(uint256 passId) external {
}
function passClaimMultiple(uint256[] calldata passIds) external {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function isClaimed(uint256 passTokenId) external view returns (bool) {
}
/*
* Only the owner can do these things
*/
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
function pause(bool val) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function setDependentContract(address passContractAddress) public onlyOwner {
}
function setMintPrice(uint256 _newPrice) public onlyOwner {
}
function setPaidMint(uint256 _paidMint) external onlyOwner {
}
function setPassMint(uint256 _passMint) external onlyOwner {
}
function setFreeMint(uint256 _freeMint) external onlyOwner {
}
function setMaxFree(uint256 _freeMintperwallet) external onlyOwner {
}
function reserve(uint256 numPasses) public onlyOwner {
}
}
| !mintPaused,'Parrot minting paused.' | 114,411 | !mintPaused |
'There are no more parrots available for minting.' | // Parrot Social Club
//
// Parrots gain you access to games and contests at the Parrot Social Club
// https://www.parrotsocial.club
//
//
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B?77J&@
// @@@@@@@@@@@@@@&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#7!!7B@@
// @@@@&#BG5YJJ???7777?J5G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&?!!!5#G#
// @@@&J!!!!!7!!!!!75PPP5J?5&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@BPPJ!!!?5PB&
// @@@@G?J5G#B7!!!?B@@@@@@#?Y@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5JJP&@@@@@GYY!!!7&@@@@
// @@@@@&@@@&?!!!J&@@@@@@@@57&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5GB&@@#PP&@@@@G?!!!7Y5??B@@@@G!!!5@@@@@
// @@@@@@@@&?!!!5@@@@@@@@@G75@@@@@&&@@@@@@@@@@@@5?J5B@@BYY#@@@B!!!7#@G7!7&@@&Y!!!7P&@@?!?&@@@J!!!B@@@@@
// @@@@@@@#?!!7G@@@@@&#GY77P@@@BY?77JB@##&@@@@@5!!!J&&5!!7&@@&?!!7##Y!!!7#@&?!!!J#@@@@Y!7#@@&7!!7&@@@@@
// @@@@@@G7!!!7YYJJ??7!7?P&@@BJ!!!7YPB5!!Y@@@@B!!!J&GJ!!!7#@@5!!!YPYBBJ7!P@Y!!!?&@@@@@J!?@@@#7!!?@@@@@@
// @@@@@P!!!JGY???JJYPB&@@@&Y!!!?P&@@Y!!?&@@@&7!!!YYP&#Y77B@#7!!!JB@@@@#B@&7!!7#@@@@@B!!B@@@&7!!7#@@&GG
// @@@@Y!!!Y@@@@@@@@@@@@@@#?!!!5&@@#J!!7#@@@@Y!!!?G@@@@@&&@@Y!!!5@@@@@@@@@#7!!J@@@@@G!?B@@@@#PJ7!?5YYB@
// @@&J!!!5@@@@@@@@@@@@@@&?!!7G@@@G?7!!P@@@@B!!!J&@@@@@@@@@#7!!Y@@@@@@@@@@@5!!7#@&GJ?P&@@@BJ7?Y##BB#@@@
// @B7!!!P@@@@@@@@@@@@@@@G!!!G@@#JY5!!7&@@@@?!!?&@@@@@@@@@@5!!7#@@@&&@@@@@@@BY?JYY5B@@@@@5!!!JB@@@@@@@@
// P!!!!5@@@@@@@@@@@@@@@@B!!7BGYJB@J!!7&@@@G!!!G@@@@@@@@@@@P?7J@@@&?7?P@@@@@@@@&&@@@@@@&J!!?B@@@@@@@@@@
// &57!Y@@@@@@@@@@@@@@@@@@BYJYP#@@@BYJYB@@@&G55@@@@@@@@@@@@@@&&@@@B!!Y#@@@@@@@@@@@@@@@#?!!5&@@@@@@@@@@@
// @@&#&@@@@@@@@@@@@@@#G5YJJ??JJJG@@@@@@@@@@@@@@@@@@@@@@&&&@@@@@@@@PB@@@@&BG#@@@@@@@@#?!!G@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@&5?!77?JJJJ?7~Y@@@@@@@@@&@@@@@@@@@B5J?Y5JB@@@B5G#@@@#Y7!!JBGYG@@@&?!7G@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#7?5B&@@@@@@@&B&@@@@@@BY?7YGB&@@@BJ!!5&@G~5@@P!!!5@@P7!75#@5!!G@@@J!!G@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@Y!B@@@@@@@@@@@@@@@@@&Y!!75#P!J@@G!!7B@@#J5&@#7!!5@@5!!J&@&Y!!G@@@5!!5@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#?7?JY5PGBB#&@@@@@@&?!!J&@@#!7&&7!!P@@@@@@@@P!!J@@B!!Y@@BJ7!Y@@@B!!J@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@BP5YJ??77777J5&@@Y!!J@@@@B!J@@?!!G@@@@##@@J!7#@@P!!B#55G!!G@@@5!!B@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@&&##BPJ?#@?!!B@@@#7?&@@#J!?##P5P&@@G7Y@@@&5?YP#@&YJP@@@G7?@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&7P@P!!G@&P?5@@@@@@B555G&@@@@@&&@@@@@@@@@@@@@@@@@@#B@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@JYB&@@@@@@@@@#P?!#@@BYJ55G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@J!!7?JYYYYJJ7!!JB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@&G5J?7!!!!7?JPB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
pragma abicoder v1;
import '@openzeppelin/contracts/access/Ownable.sol';
import "erc721a/contracts/ERC721A.sol";
import "hardhat/console.sol";
abstract contract ParrotPassContract {
function ownerOf(uint256 tokenId) public view virtual returns (address);
function balanceOf(address owner)
external
view
virtual
returns (uint256 balance);
}
contract ParrotSocialClub is ERC721A, Ownable {
ParrotPassContract public PASS;
uint256 public constant MAX_PARROTS = 8888;
uint256 public constant MAX_RESERVED_PARROTS = 10;
uint256 public passParrotsMinted = 0;
uint256 public paidParrotsMinted = 0;
uint256 public freeParrotsMinted = 0;
address public vault;
uint256 public price = 0.02 ether;
uint256 public MAX_PAID_PARROTS = 4878;
uint256 public MAX_PASS_PARROTS = 2000;
uint256 public MAX_FREE_PARROTS = 2000;
uint public MAX_FREE_PARROTS_PER_WALLET = 2;
bool public mintPaused = true;
string public baseURI;
mapping (uint256 => bool) public claimedParrots;
event MintedParrot(address claimer, uint256 amount);
constructor()
ERC721A('Parrot Social Club', 'PSC')
{}
function mint(uint256 numParrots) external payable {
require(!mintPaused, 'Parrot minting paused.');
require(
numParrots > 0 && numParrots <= 20,
'You can mint no more than 20 Parrots at a time.'
);
require(<FILL_ME>)
require(
paidParrotsMinted + numParrots <= MAX_PAID_PARROTS,
'There are no more parrots available for paid minting.'
);
require(
msg.value >= price * numParrots,
'Ether value sent is not sufficient'
);
require(tx.origin == msg.sender, 'Cant be called from another contract');
_safeMint(msg.sender, numParrots);
paidParrotsMinted += numParrots;
emit MintedParrot(msg.sender, numParrots);
}
function freemint(uint256 numParrots) external payable {
}
function passClaim(uint256 passId) external {
}
function passClaimMultiple(uint256[] calldata passIds) external {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function isClaimed(uint256 passTokenId) external view returns (bool) {
}
/*
* Only the owner can do these things
*/
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
function pause(bool val) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function setDependentContract(address passContractAddress) public onlyOwner {
}
function setMintPrice(uint256 _newPrice) public onlyOwner {
}
function setPaidMint(uint256 _paidMint) external onlyOwner {
}
function setPassMint(uint256 _passMint) external onlyOwner {
}
function setFreeMint(uint256 _freeMint) external onlyOwner {
}
function setMaxFree(uint256 _freeMintperwallet) external onlyOwner {
}
function reserve(uint256 numPasses) public onlyOwner {
}
}
| totalSupply()+numParrots<=MAX_PARROTS,'There are no more parrots available for minting.' | 114,411 | totalSupply()+numParrots<=MAX_PARROTS |
'There are no more parrots available for paid minting.' | // Parrot Social Club
//
// Parrots gain you access to games and contests at the Parrot Social Club
// https://www.parrotsocial.club
//
//
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B?77J&@
// @@@@@@@@@@@@@@&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#7!!7B@@
// @@@@&#BG5YJJ???7777?J5G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&?!!!5#G#
// @@@&J!!!!!7!!!!!75PPP5J?5&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@BPPJ!!!?5PB&
// @@@@G?J5G#B7!!!?B@@@@@@#?Y@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5JJP&@@@@@GYY!!!7&@@@@
// @@@@@&@@@&?!!!J&@@@@@@@@57&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5GB&@@#PP&@@@@G?!!!7Y5??B@@@@G!!!5@@@@@
// @@@@@@@@&?!!!5@@@@@@@@@G75@@@@@&&@@@@@@@@@@@@5?J5B@@BYY#@@@B!!!7#@G7!7&@@&Y!!!7P&@@?!?&@@@J!!!B@@@@@
// @@@@@@@#?!!7G@@@@@&#GY77P@@@BY?77JB@##&@@@@@5!!!J&&5!!7&@@&?!!7##Y!!!7#@&?!!!J#@@@@Y!7#@@&7!!7&@@@@@
// @@@@@@G7!!!7YYJJ??7!7?P&@@BJ!!!7YPB5!!Y@@@@B!!!J&GJ!!!7#@@5!!!YPYBBJ7!P@Y!!!?&@@@@@J!?@@@#7!!?@@@@@@
// @@@@@P!!!JGY???JJYPB&@@@&Y!!!?P&@@Y!!?&@@@&7!!!YYP&#Y77B@#7!!!JB@@@@#B@&7!!7#@@@@@B!!B@@@&7!!7#@@&GG
// @@@@Y!!!Y@@@@@@@@@@@@@@#?!!!5&@@#J!!7#@@@@Y!!!?G@@@@@&&@@Y!!!5@@@@@@@@@#7!!J@@@@@G!?B@@@@#PJ7!?5YYB@
// @@&J!!!5@@@@@@@@@@@@@@&?!!7G@@@G?7!!P@@@@B!!!J&@@@@@@@@@#7!!Y@@@@@@@@@@@5!!7#@&GJ?P&@@@BJ7?Y##BB#@@@
// @B7!!!P@@@@@@@@@@@@@@@G!!!G@@#JY5!!7&@@@@?!!?&@@@@@@@@@@5!!7#@@@&&@@@@@@@BY?JYY5B@@@@@5!!!JB@@@@@@@@
// P!!!!5@@@@@@@@@@@@@@@@B!!7BGYJB@J!!7&@@@G!!!G@@@@@@@@@@@P?7J@@@&?7?P@@@@@@@@&&@@@@@@&J!!?B@@@@@@@@@@
// &57!Y@@@@@@@@@@@@@@@@@@BYJYP#@@@BYJYB@@@&G55@@@@@@@@@@@@@@&&@@@B!!Y#@@@@@@@@@@@@@@@#?!!5&@@@@@@@@@@@
// @@&#&@@@@@@@@@@@@@@#G5YJJ??JJJG@@@@@@@@@@@@@@@@@@@@@@&&&@@@@@@@@PB@@@@&BG#@@@@@@@@#?!!G@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@&5?!77?JJJJ?7~Y@@@@@@@@@&@@@@@@@@@B5J?Y5JB@@@B5G#@@@#Y7!!JBGYG@@@&?!7G@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#7?5B&@@@@@@@&B&@@@@@@BY?7YGB&@@@BJ!!5&@G~5@@P!!!5@@P7!75#@5!!G@@@J!!G@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@Y!B@@@@@@@@@@@@@@@@@&Y!!75#P!J@@G!!7B@@#J5&@#7!!5@@5!!J&@&Y!!G@@@5!!5@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#?7?JY5PGBB#&@@@@@@&?!!J&@@#!7&&7!!P@@@@@@@@P!!J@@B!!Y@@BJ7!Y@@@B!!J@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@BP5YJ??77777J5&@@Y!!J@@@@B!J@@?!!G@@@@##@@J!7#@@P!!B#55G!!G@@@5!!B@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@&&##BPJ?#@?!!B@@@#7?&@@#J!?##P5P&@@G7Y@@@&5?YP#@&YJP@@@G7?@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&7P@P!!G@&P?5@@@@@@B555G&@@@@@&&@@@@@@@@@@@@@@@@@@#B@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@JYB&@@@@@@@@@#P?!#@@BYJ55G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@J!!7?JYYYYJJ7!!JB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@&G5J?7!!!!7?JPB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
pragma abicoder v1;
import '@openzeppelin/contracts/access/Ownable.sol';
import "erc721a/contracts/ERC721A.sol";
import "hardhat/console.sol";
abstract contract ParrotPassContract {
function ownerOf(uint256 tokenId) public view virtual returns (address);
function balanceOf(address owner)
external
view
virtual
returns (uint256 balance);
}
contract ParrotSocialClub is ERC721A, Ownable {
ParrotPassContract public PASS;
uint256 public constant MAX_PARROTS = 8888;
uint256 public constant MAX_RESERVED_PARROTS = 10;
uint256 public passParrotsMinted = 0;
uint256 public paidParrotsMinted = 0;
uint256 public freeParrotsMinted = 0;
address public vault;
uint256 public price = 0.02 ether;
uint256 public MAX_PAID_PARROTS = 4878;
uint256 public MAX_PASS_PARROTS = 2000;
uint256 public MAX_FREE_PARROTS = 2000;
uint public MAX_FREE_PARROTS_PER_WALLET = 2;
bool public mintPaused = true;
string public baseURI;
mapping (uint256 => bool) public claimedParrots;
event MintedParrot(address claimer, uint256 amount);
constructor()
ERC721A('Parrot Social Club', 'PSC')
{}
function mint(uint256 numParrots) external payable {
require(!mintPaused, 'Parrot minting paused.');
require(
numParrots > 0 && numParrots <= 20,
'You can mint no more than 20 Parrots at a time.'
);
require(
totalSupply() + numParrots <= MAX_PARROTS,
'There are no more parrots available for minting.'
);
require(<FILL_ME>)
require(
msg.value >= price * numParrots,
'Ether value sent is not sufficient'
);
require(tx.origin == msg.sender, 'Cant be called from another contract');
_safeMint(msg.sender, numParrots);
paidParrotsMinted += numParrots;
emit MintedParrot(msg.sender, numParrots);
}
function freemint(uint256 numParrots) external payable {
}
function passClaim(uint256 passId) external {
}
function passClaimMultiple(uint256[] calldata passIds) external {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function isClaimed(uint256 passTokenId) external view returns (bool) {
}
/*
* Only the owner can do these things
*/
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
function pause(bool val) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function setDependentContract(address passContractAddress) public onlyOwner {
}
function setMintPrice(uint256 _newPrice) public onlyOwner {
}
function setPaidMint(uint256 _paidMint) external onlyOwner {
}
function setPassMint(uint256 _passMint) external onlyOwner {
}
function setFreeMint(uint256 _freeMint) external onlyOwner {
}
function setMaxFree(uint256 _freeMintperwallet) external onlyOwner {
}
function reserve(uint256 numPasses) public onlyOwner {
}
}
| paidParrotsMinted+numParrots<=MAX_PAID_PARROTS,'There are no more parrots available for paid minting.' | 114,411 | paidParrotsMinted+numParrots<=MAX_PAID_PARROTS |
'You have exceeded the limit for free parrots.' | // Parrot Social Club
//
// Parrots gain you access to games and contests at the Parrot Social Club
// https://www.parrotsocial.club
//
//
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B?77J&@
// @@@@@@@@@@@@@@&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#7!!7B@@
// @@@@&#BG5YJJ???7777?J5G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&?!!!5#G#
// @@@&J!!!!!7!!!!!75PPP5J?5&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@BPPJ!!!?5PB&
// @@@@G?J5G#B7!!!?B@@@@@@#?Y@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5JJP&@@@@@GYY!!!7&@@@@
// @@@@@&@@@&?!!!J&@@@@@@@@57&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5GB&@@#PP&@@@@G?!!!7Y5??B@@@@G!!!5@@@@@
// @@@@@@@@&?!!!5@@@@@@@@@G75@@@@@&&@@@@@@@@@@@@5?J5B@@BYY#@@@B!!!7#@G7!7&@@&Y!!!7P&@@?!?&@@@J!!!B@@@@@
// @@@@@@@#?!!7G@@@@@&#GY77P@@@BY?77JB@##&@@@@@5!!!J&&5!!7&@@&?!!7##Y!!!7#@&?!!!J#@@@@Y!7#@@&7!!7&@@@@@
// @@@@@@G7!!!7YYJJ??7!7?P&@@BJ!!!7YPB5!!Y@@@@B!!!J&GJ!!!7#@@5!!!YPYBBJ7!P@Y!!!?&@@@@@J!?@@@#7!!?@@@@@@
// @@@@@P!!!JGY???JJYPB&@@@&Y!!!?P&@@Y!!?&@@@&7!!!YYP&#Y77B@#7!!!JB@@@@#B@&7!!7#@@@@@B!!B@@@&7!!7#@@&GG
// @@@@Y!!!Y@@@@@@@@@@@@@@#?!!!5&@@#J!!7#@@@@Y!!!?G@@@@@&&@@Y!!!5@@@@@@@@@#7!!J@@@@@G!?B@@@@#PJ7!?5YYB@
// @@&J!!!5@@@@@@@@@@@@@@&?!!7G@@@G?7!!P@@@@B!!!J&@@@@@@@@@#7!!Y@@@@@@@@@@@5!!7#@&GJ?P&@@@BJ7?Y##BB#@@@
// @B7!!!P@@@@@@@@@@@@@@@G!!!G@@#JY5!!7&@@@@?!!?&@@@@@@@@@@5!!7#@@@&&@@@@@@@BY?JYY5B@@@@@5!!!JB@@@@@@@@
// P!!!!5@@@@@@@@@@@@@@@@B!!7BGYJB@J!!7&@@@G!!!G@@@@@@@@@@@P?7J@@@&?7?P@@@@@@@@&&@@@@@@&J!!?B@@@@@@@@@@
// &57!Y@@@@@@@@@@@@@@@@@@BYJYP#@@@BYJYB@@@&G55@@@@@@@@@@@@@@&&@@@B!!Y#@@@@@@@@@@@@@@@#?!!5&@@@@@@@@@@@
// @@&#&@@@@@@@@@@@@@@#G5YJJ??JJJG@@@@@@@@@@@@@@@@@@@@@@&&&@@@@@@@@PB@@@@&BG#@@@@@@@@#?!!G@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@&5?!77?JJJJ?7~Y@@@@@@@@@&@@@@@@@@@B5J?Y5JB@@@B5G#@@@#Y7!!JBGYG@@@&?!7G@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#7?5B&@@@@@@@&B&@@@@@@BY?7YGB&@@@BJ!!5&@G~5@@P!!!5@@P7!75#@5!!G@@@J!!G@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@Y!B@@@@@@@@@@@@@@@@@&Y!!75#P!J@@G!!7B@@#J5&@#7!!5@@5!!J&@&Y!!G@@@5!!5@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#?7?JY5PGBB#&@@@@@@&?!!J&@@#!7&&7!!P@@@@@@@@P!!J@@B!!Y@@BJ7!Y@@@B!!J@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@BP5YJ??77777J5&@@Y!!J@@@@B!J@@?!!G@@@@##@@J!7#@@P!!B#55G!!G@@@5!!B@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@&&##BPJ?#@?!!B@@@#7?&@@#J!?##P5P&@@G7Y@@@&5?YP#@&YJP@@@G7?@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&7P@P!!G@&P?5@@@@@@B555G&@@@@@&&@@@@@@@@@@@@@@@@@@#B@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@JYB&@@@@@@@@@#P?!#@@BYJ55G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@J!!7?JYYYYJJ7!!JB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@&G5J?7!!!!7?JPB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
pragma abicoder v1;
import '@openzeppelin/contracts/access/Ownable.sol';
import "erc721a/contracts/ERC721A.sol";
import "hardhat/console.sol";
abstract contract ParrotPassContract {
function ownerOf(uint256 tokenId) public view virtual returns (address);
function balanceOf(address owner)
external
view
virtual
returns (uint256 balance);
}
contract ParrotSocialClub is ERC721A, Ownable {
ParrotPassContract public PASS;
uint256 public constant MAX_PARROTS = 8888;
uint256 public constant MAX_RESERVED_PARROTS = 10;
uint256 public passParrotsMinted = 0;
uint256 public paidParrotsMinted = 0;
uint256 public freeParrotsMinted = 0;
address public vault;
uint256 public price = 0.02 ether;
uint256 public MAX_PAID_PARROTS = 4878;
uint256 public MAX_PASS_PARROTS = 2000;
uint256 public MAX_FREE_PARROTS = 2000;
uint public MAX_FREE_PARROTS_PER_WALLET = 2;
bool public mintPaused = true;
string public baseURI;
mapping (uint256 => bool) public claimedParrots;
event MintedParrot(address claimer, uint256 amount);
constructor()
ERC721A('Parrot Social Club', 'PSC')
{}
function mint(uint256 numParrots) external payable {
}
function freemint(uint256 numParrots) external payable {
uint256 senderBalance = balanceOf(msg.sender);
require(!mintPaused, 'Parrot minting paused.');
require(
numParrots > 0 && numParrots <= MAX_FREE_PARROTS_PER_WALLET,
'You have exceeded the limit for free parrots.'
);
require(<FILL_ME>)
require(
totalSupply() + numParrots <= MAX_PARROTS,
'There are no more parrots available for minting.'
);
require(
freeParrotsMinted + numParrots <= MAX_FREE_PARROTS,
'There are no more parrots available for free minting.'
);
require(tx.origin == msg.sender, 'Cant be called from another contract');
_safeMint(msg.sender, numParrots);
freeParrotsMinted += numParrots;
emit MintedParrot(msg.sender, numParrots);
}
function passClaim(uint256 passId) external {
}
function passClaimMultiple(uint256[] calldata passIds) external {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function isClaimed(uint256 passTokenId) external view returns (bool) {
}
/*
* Only the owner can do these things
*/
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
function pause(bool val) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function setDependentContract(address passContractAddress) public onlyOwner {
}
function setMintPrice(uint256 _newPrice) public onlyOwner {
}
function setPaidMint(uint256 _paidMint) external onlyOwner {
}
function setPassMint(uint256 _passMint) external onlyOwner {
}
function setFreeMint(uint256 _freeMint) external onlyOwner {
}
function setMaxFree(uint256 _freeMintperwallet) external onlyOwner {
}
function reserve(uint256 numPasses) public onlyOwner {
}
}
| numParrots+senderBalance<=MAX_FREE_PARROTS_PER_WALLET,'You have exceeded the limit for free parrots.' | 114,411 | numParrots+senderBalance<=MAX_FREE_PARROTS_PER_WALLET |
'There are no more parrots available for free minting.' | // Parrot Social Club
//
// Parrots gain you access to games and contests at the Parrot Social Club
// https://www.parrotsocial.club
//
//
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B?77J&@
// @@@@@@@@@@@@@@&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#7!!7B@@
// @@@@&#BG5YJJ???7777?J5G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&?!!!5#G#
// @@@&J!!!!!7!!!!!75PPP5J?5&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@BPPJ!!!?5PB&
// @@@@G?J5G#B7!!!?B@@@@@@#?Y@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5JJP&@@@@@GYY!!!7&@@@@
// @@@@@&@@@&?!!!J&@@@@@@@@57&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5GB&@@#PP&@@@@G?!!!7Y5??B@@@@G!!!5@@@@@
// @@@@@@@@&?!!!5@@@@@@@@@G75@@@@@&&@@@@@@@@@@@@5?J5B@@BYY#@@@B!!!7#@G7!7&@@&Y!!!7P&@@?!?&@@@J!!!B@@@@@
// @@@@@@@#?!!7G@@@@@&#GY77P@@@BY?77JB@##&@@@@@5!!!J&&5!!7&@@&?!!7##Y!!!7#@&?!!!J#@@@@Y!7#@@&7!!7&@@@@@
// @@@@@@G7!!!7YYJJ??7!7?P&@@BJ!!!7YPB5!!Y@@@@B!!!J&GJ!!!7#@@5!!!YPYBBJ7!P@Y!!!?&@@@@@J!?@@@#7!!?@@@@@@
// @@@@@P!!!JGY???JJYPB&@@@&Y!!!?P&@@Y!!?&@@@&7!!!YYP&#Y77B@#7!!!JB@@@@#B@&7!!7#@@@@@B!!B@@@&7!!7#@@&GG
// @@@@Y!!!Y@@@@@@@@@@@@@@#?!!!5&@@#J!!7#@@@@Y!!!?G@@@@@&&@@Y!!!5@@@@@@@@@#7!!J@@@@@G!?B@@@@#PJ7!?5YYB@
// @@&J!!!5@@@@@@@@@@@@@@&?!!7G@@@G?7!!P@@@@B!!!J&@@@@@@@@@#7!!Y@@@@@@@@@@@5!!7#@&GJ?P&@@@BJ7?Y##BB#@@@
// @B7!!!P@@@@@@@@@@@@@@@G!!!G@@#JY5!!7&@@@@?!!?&@@@@@@@@@@5!!7#@@@&&@@@@@@@BY?JYY5B@@@@@5!!!JB@@@@@@@@
// P!!!!5@@@@@@@@@@@@@@@@B!!7BGYJB@J!!7&@@@G!!!G@@@@@@@@@@@P?7J@@@&?7?P@@@@@@@@&&@@@@@@&J!!?B@@@@@@@@@@
// &57!Y@@@@@@@@@@@@@@@@@@BYJYP#@@@BYJYB@@@&G55@@@@@@@@@@@@@@&&@@@B!!Y#@@@@@@@@@@@@@@@#?!!5&@@@@@@@@@@@
// @@&#&@@@@@@@@@@@@@@#G5YJJ??JJJG@@@@@@@@@@@@@@@@@@@@@@&&&@@@@@@@@PB@@@@&BG#@@@@@@@@#?!!G@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@&5?!77?JJJJ?7~Y@@@@@@@@@&@@@@@@@@@B5J?Y5JB@@@B5G#@@@#Y7!!JBGYG@@@&?!7G@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#7?5B&@@@@@@@&B&@@@@@@BY?7YGB&@@@BJ!!5&@G~5@@P!!!5@@P7!75#@5!!G@@@J!!G@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@Y!B@@@@@@@@@@@@@@@@@&Y!!75#P!J@@G!!7B@@#J5&@#7!!5@@5!!J&@&Y!!G@@@5!!5@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#?7?JY5PGBB#&@@@@@@&?!!J&@@#!7&&7!!P@@@@@@@@P!!J@@B!!Y@@BJ7!Y@@@B!!J@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@BP5YJ??77777J5&@@Y!!J@@@@B!J@@?!!G@@@@##@@J!7#@@P!!B#55G!!G@@@5!!B@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@&&##BPJ?#@?!!B@@@#7?&@@#J!?##P5P&@@G7Y@@@&5?YP#@&YJP@@@G7?@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&7P@P!!G@&P?5@@@@@@B555G&@@@@@&&@@@@@@@@@@@@@@@@@@#B@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@JYB&@@@@@@@@@#P?!#@@BYJ55G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@J!!7?JYYYYJJ7!!JB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@&G5J?7!!!!7?JPB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
pragma abicoder v1;
import '@openzeppelin/contracts/access/Ownable.sol';
import "erc721a/contracts/ERC721A.sol";
import "hardhat/console.sol";
abstract contract ParrotPassContract {
function ownerOf(uint256 tokenId) public view virtual returns (address);
function balanceOf(address owner)
external
view
virtual
returns (uint256 balance);
}
contract ParrotSocialClub is ERC721A, Ownable {
ParrotPassContract public PASS;
uint256 public constant MAX_PARROTS = 8888;
uint256 public constant MAX_RESERVED_PARROTS = 10;
uint256 public passParrotsMinted = 0;
uint256 public paidParrotsMinted = 0;
uint256 public freeParrotsMinted = 0;
address public vault;
uint256 public price = 0.02 ether;
uint256 public MAX_PAID_PARROTS = 4878;
uint256 public MAX_PASS_PARROTS = 2000;
uint256 public MAX_FREE_PARROTS = 2000;
uint public MAX_FREE_PARROTS_PER_WALLET = 2;
bool public mintPaused = true;
string public baseURI;
mapping (uint256 => bool) public claimedParrots;
event MintedParrot(address claimer, uint256 amount);
constructor()
ERC721A('Parrot Social Club', 'PSC')
{}
function mint(uint256 numParrots) external payable {
}
function freemint(uint256 numParrots) external payable {
uint256 senderBalance = balanceOf(msg.sender);
require(!mintPaused, 'Parrot minting paused.');
require(
numParrots > 0 && numParrots <= MAX_FREE_PARROTS_PER_WALLET,
'You have exceeded the limit for free parrots.'
);
require(
numParrots + senderBalance <= MAX_FREE_PARROTS_PER_WALLET,
'You have exceeded the limit for free parrots.'
);
require(
totalSupply() + numParrots <= MAX_PARROTS,
'There are no more parrots available for minting.'
);
require(<FILL_ME>)
require(tx.origin == msg.sender, 'Cant be called from another contract');
_safeMint(msg.sender, numParrots);
freeParrotsMinted += numParrots;
emit MintedParrot(msg.sender, numParrots);
}
function passClaim(uint256 passId) external {
}
function passClaimMultiple(uint256[] calldata passIds) external {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function isClaimed(uint256 passTokenId) external view returns (bool) {
}
/*
* Only the owner can do these things
*/
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
function pause(bool val) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function setDependentContract(address passContractAddress) public onlyOwner {
}
function setMintPrice(uint256 _newPrice) public onlyOwner {
}
function setPaidMint(uint256 _paidMint) external onlyOwner {
}
function setPassMint(uint256 _passMint) external onlyOwner {
}
function setFreeMint(uint256 _freeMint) external onlyOwner {
}
function setMaxFree(uint256 _freeMintperwallet) external onlyOwner {
}
function reserve(uint256 numPasses) public onlyOwner {
}
}
| freeParrotsMinted+numParrots<=MAX_FREE_PARROTS,'There are no more parrots available for free minting.' | 114,411 | freeParrotsMinted+numParrots<=MAX_FREE_PARROTS |
'Pass has already claimed a parrot.' | // Parrot Social Club
//
// Parrots gain you access to games and contests at the Parrot Social Club
// https://www.parrotsocial.club
//
//
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B?77J&@
// @@@@@@@@@@@@@@&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#7!!7B@@
// @@@@&#BG5YJJ???7777?J5G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&?!!!5#G#
// @@@&J!!!!!7!!!!!75PPP5J?5&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@BPPJ!!!?5PB&
// @@@@G?J5G#B7!!!?B@@@@@@#?Y@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5JJP&@@@@@GYY!!!7&@@@@
// @@@@@&@@@&?!!!J&@@@@@@@@57&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5GB&@@#PP&@@@@G?!!!7Y5??B@@@@G!!!5@@@@@
// @@@@@@@@&?!!!5@@@@@@@@@G75@@@@@&&@@@@@@@@@@@@5?J5B@@BYY#@@@B!!!7#@G7!7&@@&Y!!!7P&@@?!?&@@@J!!!B@@@@@
// @@@@@@@#?!!7G@@@@@&#GY77P@@@BY?77JB@##&@@@@@5!!!J&&5!!7&@@&?!!7##Y!!!7#@&?!!!J#@@@@Y!7#@@&7!!7&@@@@@
// @@@@@@G7!!!7YYJJ??7!7?P&@@BJ!!!7YPB5!!Y@@@@B!!!J&GJ!!!7#@@5!!!YPYBBJ7!P@Y!!!?&@@@@@J!?@@@#7!!?@@@@@@
// @@@@@P!!!JGY???JJYPB&@@@&Y!!!?P&@@Y!!?&@@@&7!!!YYP&#Y77B@#7!!!JB@@@@#B@&7!!7#@@@@@B!!B@@@&7!!7#@@&GG
// @@@@Y!!!Y@@@@@@@@@@@@@@#?!!!5&@@#J!!7#@@@@Y!!!?G@@@@@&&@@Y!!!5@@@@@@@@@#7!!J@@@@@G!?B@@@@#PJ7!?5YYB@
// @@&J!!!5@@@@@@@@@@@@@@&?!!7G@@@G?7!!P@@@@B!!!J&@@@@@@@@@#7!!Y@@@@@@@@@@@5!!7#@&GJ?P&@@@BJ7?Y##BB#@@@
// @B7!!!P@@@@@@@@@@@@@@@G!!!G@@#JY5!!7&@@@@?!!?&@@@@@@@@@@5!!7#@@@&&@@@@@@@BY?JYY5B@@@@@5!!!JB@@@@@@@@
// P!!!!5@@@@@@@@@@@@@@@@B!!7BGYJB@J!!7&@@@G!!!G@@@@@@@@@@@P?7J@@@&?7?P@@@@@@@@&&@@@@@@&J!!?B@@@@@@@@@@
// &57!Y@@@@@@@@@@@@@@@@@@BYJYP#@@@BYJYB@@@&G55@@@@@@@@@@@@@@&&@@@B!!Y#@@@@@@@@@@@@@@@#?!!5&@@@@@@@@@@@
// @@&#&@@@@@@@@@@@@@@#G5YJJ??JJJG@@@@@@@@@@@@@@@@@@@@@@&&&@@@@@@@@PB@@@@&BG#@@@@@@@@#?!!G@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@&5?!77?JJJJ?7~Y@@@@@@@@@&@@@@@@@@@B5J?Y5JB@@@B5G#@@@#Y7!!JBGYG@@@&?!7G@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#7?5B&@@@@@@@&B&@@@@@@BY?7YGB&@@@BJ!!5&@G~5@@P!!!5@@P7!75#@5!!G@@@J!!G@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@Y!B@@@@@@@@@@@@@@@@@&Y!!75#P!J@@G!!7B@@#J5&@#7!!5@@5!!J&@&Y!!G@@@5!!5@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#?7?JY5PGBB#&@@@@@@&?!!J&@@#!7&&7!!P@@@@@@@@P!!J@@B!!Y@@BJ7!Y@@@B!!J@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@BP5YJ??77777J5&@@Y!!J@@@@B!J@@?!!G@@@@##@@J!7#@@P!!B#55G!!G@@@5!!B@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@&&##BPJ?#@?!!B@@@#7?&@@#J!?##P5P&@@G7Y@@@&5?YP#@&YJP@@@G7?@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&7P@P!!G@&P?5@@@@@@B555G&@@@@@&&@@@@@@@@@@@@@@@@@@#B@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@JYB&@@@@@@@@@#P?!#@@BYJ55G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@J!!7?JYYYYJJ7!!JB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@&G5J?7!!!!7?JPB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
pragma abicoder v1;
import '@openzeppelin/contracts/access/Ownable.sol';
import "erc721a/contracts/ERC721A.sol";
import "hardhat/console.sol";
abstract contract ParrotPassContract {
function ownerOf(uint256 tokenId) public view virtual returns (address);
function balanceOf(address owner)
external
view
virtual
returns (uint256 balance);
}
contract ParrotSocialClub is ERC721A, Ownable {
ParrotPassContract public PASS;
uint256 public constant MAX_PARROTS = 8888;
uint256 public constant MAX_RESERVED_PARROTS = 10;
uint256 public passParrotsMinted = 0;
uint256 public paidParrotsMinted = 0;
uint256 public freeParrotsMinted = 0;
address public vault;
uint256 public price = 0.02 ether;
uint256 public MAX_PAID_PARROTS = 4878;
uint256 public MAX_PASS_PARROTS = 2000;
uint256 public MAX_FREE_PARROTS = 2000;
uint public MAX_FREE_PARROTS_PER_WALLET = 2;
bool public mintPaused = true;
string public baseURI;
mapping (uint256 => bool) public claimedParrots;
event MintedParrot(address claimer, uint256 amount);
constructor()
ERC721A('Parrot Social Club', 'PSC')
{}
function mint(uint256 numParrots) external payable {
}
function freemint(uint256 numParrots) external payable {
}
function passClaim(uint256 passId) external {
require(tx.origin == msg.sender, 'Cant be called from another contract');
require(!mintPaused, 'Free Parrot minting paused.');
require(<FILL_ME>)
require(passId < MAX_PASS_PARROTS, 'Invalid Pass ID');
require(
PASS.ownerOf(passId) == msg.sender,
'Need to own the pass youre claiming a parrot for.'
);
require(
totalSupply() + 1 <= MAX_PARROTS,
'There are no more parrots available for minting.'
);
require(
passParrotsMinted + 1 <= MAX_PASS_PARROTS,
'There are no more Parrots that can be claimed.'
);
passParrotsMinted++;
claimedParrots[passId] = true;
_safeMint(msg.sender, 1);
emit MintedParrot(msg.sender, 1);
}
function passClaimMultiple(uint256[] calldata passIds) external {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function isClaimed(uint256 passTokenId) external view returns (bool) {
}
/*
* Only the owner can do these things
*/
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
function pause(bool val) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function setDependentContract(address passContractAddress) public onlyOwner {
}
function setMintPrice(uint256 _newPrice) public onlyOwner {
}
function setPaidMint(uint256 _paidMint) external onlyOwner {
}
function setPassMint(uint256 _passMint) external onlyOwner {
}
function setFreeMint(uint256 _freeMint) external onlyOwner {
}
function setMaxFree(uint256 _freeMintperwallet) external onlyOwner {
}
function reserve(uint256 numPasses) public onlyOwner {
}
}
| !claimedParrots[passId],'Pass has already claimed a parrot.' | 114,411 | !claimedParrots[passId] |
'Need to own the pass youre claiming a parrot for.' | // Parrot Social Club
//
// Parrots gain you access to games and contests at the Parrot Social Club
// https://www.parrotsocial.club
//
//
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B?77J&@
// @@@@@@@@@@@@@@&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#7!!7B@@
// @@@@&#BG5YJJ???7777?J5G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&?!!!5#G#
// @@@&J!!!!!7!!!!!75PPP5J?5&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@BPPJ!!!?5PB&
// @@@@G?J5G#B7!!!?B@@@@@@#?Y@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5JJP&@@@@@GYY!!!7&@@@@
// @@@@@&@@@&?!!!J&@@@@@@@@57&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5GB&@@#PP&@@@@G?!!!7Y5??B@@@@G!!!5@@@@@
// @@@@@@@@&?!!!5@@@@@@@@@G75@@@@@&&@@@@@@@@@@@@5?J5B@@BYY#@@@B!!!7#@G7!7&@@&Y!!!7P&@@?!?&@@@J!!!B@@@@@
// @@@@@@@#?!!7G@@@@@&#GY77P@@@BY?77JB@##&@@@@@5!!!J&&5!!7&@@&?!!7##Y!!!7#@&?!!!J#@@@@Y!7#@@&7!!7&@@@@@
// @@@@@@G7!!!7YYJJ??7!7?P&@@BJ!!!7YPB5!!Y@@@@B!!!J&GJ!!!7#@@5!!!YPYBBJ7!P@Y!!!?&@@@@@J!?@@@#7!!?@@@@@@
// @@@@@P!!!JGY???JJYPB&@@@&Y!!!?P&@@Y!!?&@@@&7!!!YYP&#Y77B@#7!!!JB@@@@#B@&7!!7#@@@@@B!!B@@@&7!!7#@@&GG
// @@@@Y!!!Y@@@@@@@@@@@@@@#?!!!5&@@#J!!7#@@@@Y!!!?G@@@@@&&@@Y!!!5@@@@@@@@@#7!!J@@@@@G!?B@@@@#PJ7!?5YYB@
// @@&J!!!5@@@@@@@@@@@@@@&?!!7G@@@G?7!!P@@@@B!!!J&@@@@@@@@@#7!!Y@@@@@@@@@@@5!!7#@&GJ?P&@@@BJ7?Y##BB#@@@
// @B7!!!P@@@@@@@@@@@@@@@G!!!G@@#JY5!!7&@@@@?!!?&@@@@@@@@@@5!!7#@@@&&@@@@@@@BY?JYY5B@@@@@5!!!JB@@@@@@@@
// P!!!!5@@@@@@@@@@@@@@@@B!!7BGYJB@J!!7&@@@G!!!G@@@@@@@@@@@P?7J@@@&?7?P@@@@@@@@&&@@@@@@&J!!?B@@@@@@@@@@
// &57!Y@@@@@@@@@@@@@@@@@@BYJYP#@@@BYJYB@@@&G55@@@@@@@@@@@@@@&&@@@B!!Y#@@@@@@@@@@@@@@@#?!!5&@@@@@@@@@@@
// @@&#&@@@@@@@@@@@@@@#G5YJJ??JJJG@@@@@@@@@@@@@@@@@@@@@@&&&@@@@@@@@PB@@@@&BG#@@@@@@@@#?!!G@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@&5?!77?JJJJ?7~Y@@@@@@@@@&@@@@@@@@@B5J?Y5JB@@@B5G#@@@#Y7!!JBGYG@@@&?!7G@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#7?5B&@@@@@@@&B&@@@@@@BY?7YGB&@@@BJ!!5&@G~5@@P!!!5@@P7!75#@5!!G@@@J!!G@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@Y!B@@@@@@@@@@@@@@@@@&Y!!75#P!J@@G!!7B@@#J5&@#7!!5@@5!!J&@&Y!!G@@@5!!5@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#?7?JY5PGBB#&@@@@@@&?!!J&@@#!7&&7!!P@@@@@@@@P!!J@@B!!Y@@BJ7!Y@@@B!!J@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@BP5YJ??77777J5&@@Y!!J@@@@B!J@@?!!G@@@@##@@J!7#@@P!!B#55G!!G@@@5!!B@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@&&##BPJ?#@?!!B@@@#7?&@@#J!?##P5P&@@G7Y@@@&5?YP#@&YJP@@@G7?@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&7P@P!!G@&P?5@@@@@@B555G&@@@@@&&@@@@@@@@@@@@@@@@@@#B@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@JYB&@@@@@@@@@#P?!#@@BYJ55G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@J!!7?JYYYYJJ7!!JB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@&G5J?7!!!!7?JPB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
pragma abicoder v1;
import '@openzeppelin/contracts/access/Ownable.sol';
import "erc721a/contracts/ERC721A.sol";
import "hardhat/console.sol";
abstract contract ParrotPassContract {
function ownerOf(uint256 tokenId) public view virtual returns (address);
function balanceOf(address owner)
external
view
virtual
returns (uint256 balance);
}
contract ParrotSocialClub is ERC721A, Ownable {
ParrotPassContract public PASS;
uint256 public constant MAX_PARROTS = 8888;
uint256 public constant MAX_RESERVED_PARROTS = 10;
uint256 public passParrotsMinted = 0;
uint256 public paidParrotsMinted = 0;
uint256 public freeParrotsMinted = 0;
address public vault;
uint256 public price = 0.02 ether;
uint256 public MAX_PAID_PARROTS = 4878;
uint256 public MAX_PASS_PARROTS = 2000;
uint256 public MAX_FREE_PARROTS = 2000;
uint public MAX_FREE_PARROTS_PER_WALLET = 2;
bool public mintPaused = true;
string public baseURI;
mapping (uint256 => bool) public claimedParrots;
event MintedParrot(address claimer, uint256 amount);
constructor()
ERC721A('Parrot Social Club', 'PSC')
{}
function mint(uint256 numParrots) external payable {
}
function freemint(uint256 numParrots) external payable {
}
function passClaim(uint256 passId) external {
require(tx.origin == msg.sender, 'Cant be called from another contract');
require(!mintPaused, 'Free Parrot minting paused.');
require(!claimedParrots[passId], 'Pass has already claimed a parrot.');
require(passId < MAX_PASS_PARROTS, 'Invalid Pass ID');
require(<FILL_ME>)
require(
totalSupply() + 1 <= MAX_PARROTS,
'There are no more parrots available for minting.'
);
require(
passParrotsMinted + 1 <= MAX_PASS_PARROTS,
'There are no more Parrots that can be claimed.'
);
passParrotsMinted++;
claimedParrots[passId] = true;
_safeMint(msg.sender, 1);
emit MintedParrot(msg.sender, 1);
}
function passClaimMultiple(uint256[] calldata passIds) external {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function isClaimed(uint256 passTokenId) external view returns (bool) {
}
/*
* Only the owner can do these things
*/
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
function pause(bool val) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function setDependentContract(address passContractAddress) public onlyOwner {
}
function setMintPrice(uint256 _newPrice) public onlyOwner {
}
function setPaidMint(uint256 _paidMint) external onlyOwner {
}
function setPassMint(uint256 _passMint) external onlyOwner {
}
function setFreeMint(uint256 _freeMint) external onlyOwner {
}
function setMaxFree(uint256 _freeMintperwallet) external onlyOwner {
}
function reserve(uint256 numPasses) public onlyOwner {
}
}
| PASS.ownerOf(passId)==msg.sender,'Need to own the pass youre claiming a parrot for.' | 114,411 | PASS.ownerOf(passId)==msg.sender |
'There are no more parrots available for minting.' | // Parrot Social Club
//
// Parrots gain you access to games and contests at the Parrot Social Club
// https://www.parrotsocial.club
//
//
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B?77J&@
// @@@@@@@@@@@@@@&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#7!!7B@@
// @@@@&#BG5YJJ???7777?J5G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&?!!!5#G#
// @@@&J!!!!!7!!!!!75PPP5J?5&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@BPPJ!!!?5PB&
// @@@@G?J5G#B7!!!?B@@@@@@#?Y@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5JJP&@@@@@GYY!!!7&@@@@
// @@@@@&@@@&?!!!J&@@@@@@@@57&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5GB&@@#PP&@@@@G?!!!7Y5??B@@@@G!!!5@@@@@
// @@@@@@@@&?!!!5@@@@@@@@@G75@@@@@&&@@@@@@@@@@@@5?J5B@@BYY#@@@B!!!7#@G7!7&@@&Y!!!7P&@@?!?&@@@J!!!B@@@@@
// @@@@@@@#?!!7G@@@@@&#GY77P@@@BY?77JB@##&@@@@@5!!!J&&5!!7&@@&?!!7##Y!!!7#@&?!!!J#@@@@Y!7#@@&7!!7&@@@@@
// @@@@@@G7!!!7YYJJ??7!7?P&@@BJ!!!7YPB5!!Y@@@@B!!!J&GJ!!!7#@@5!!!YPYBBJ7!P@Y!!!?&@@@@@J!?@@@#7!!?@@@@@@
// @@@@@P!!!JGY???JJYPB&@@@&Y!!!?P&@@Y!!?&@@@&7!!!YYP&#Y77B@#7!!!JB@@@@#B@&7!!7#@@@@@B!!B@@@&7!!7#@@&GG
// @@@@Y!!!Y@@@@@@@@@@@@@@#?!!!5&@@#J!!7#@@@@Y!!!?G@@@@@&&@@Y!!!5@@@@@@@@@#7!!J@@@@@G!?B@@@@#PJ7!?5YYB@
// @@&J!!!5@@@@@@@@@@@@@@&?!!7G@@@G?7!!P@@@@B!!!J&@@@@@@@@@#7!!Y@@@@@@@@@@@5!!7#@&GJ?P&@@@BJ7?Y##BB#@@@
// @B7!!!P@@@@@@@@@@@@@@@G!!!G@@#JY5!!7&@@@@?!!?&@@@@@@@@@@5!!7#@@@&&@@@@@@@BY?JYY5B@@@@@5!!!JB@@@@@@@@
// P!!!!5@@@@@@@@@@@@@@@@B!!7BGYJB@J!!7&@@@G!!!G@@@@@@@@@@@P?7J@@@&?7?P@@@@@@@@&&@@@@@@&J!!?B@@@@@@@@@@
// &57!Y@@@@@@@@@@@@@@@@@@BYJYP#@@@BYJYB@@@&G55@@@@@@@@@@@@@@&&@@@B!!Y#@@@@@@@@@@@@@@@#?!!5&@@@@@@@@@@@
// @@&#&@@@@@@@@@@@@@@#G5YJJ??JJJG@@@@@@@@@@@@@@@@@@@@@@&&&@@@@@@@@PB@@@@&BG#@@@@@@@@#?!!G@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@&5?!77?JJJJ?7~Y@@@@@@@@@&@@@@@@@@@B5J?Y5JB@@@B5G#@@@#Y7!!JBGYG@@@&?!7G@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#7?5B&@@@@@@@&B&@@@@@@BY?7YGB&@@@BJ!!5&@G~5@@P!!!5@@P7!75#@5!!G@@@J!!G@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@Y!B@@@@@@@@@@@@@@@@@&Y!!75#P!J@@G!!7B@@#J5&@#7!!5@@5!!J&@&Y!!G@@@5!!5@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#?7?JY5PGBB#&@@@@@@&?!!J&@@#!7&&7!!P@@@@@@@@P!!J@@B!!Y@@BJ7!Y@@@B!!J@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@BP5YJ??77777J5&@@Y!!J@@@@B!J@@?!!G@@@@##@@J!7#@@P!!B#55G!!G@@@5!!B@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@&&##BPJ?#@?!!B@@@#7?&@@#J!?##P5P&@@G7Y@@@&5?YP#@&YJP@@@G7?@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&7P@P!!G@&P?5@@@@@@B555G&@@@@@&&@@@@@@@@@@@@@@@@@@#B@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@JYB&@@@@@@@@@#P?!#@@BYJ55G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@J!!7?JYYYYJJ7!!JB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@&G5J?7!!!!7?JPB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
pragma abicoder v1;
import '@openzeppelin/contracts/access/Ownable.sol';
import "erc721a/contracts/ERC721A.sol";
import "hardhat/console.sol";
abstract contract ParrotPassContract {
function ownerOf(uint256 tokenId) public view virtual returns (address);
function balanceOf(address owner)
external
view
virtual
returns (uint256 balance);
}
contract ParrotSocialClub is ERC721A, Ownable {
ParrotPassContract public PASS;
uint256 public constant MAX_PARROTS = 8888;
uint256 public constant MAX_RESERVED_PARROTS = 10;
uint256 public passParrotsMinted = 0;
uint256 public paidParrotsMinted = 0;
uint256 public freeParrotsMinted = 0;
address public vault;
uint256 public price = 0.02 ether;
uint256 public MAX_PAID_PARROTS = 4878;
uint256 public MAX_PASS_PARROTS = 2000;
uint256 public MAX_FREE_PARROTS = 2000;
uint public MAX_FREE_PARROTS_PER_WALLET = 2;
bool public mintPaused = true;
string public baseURI;
mapping (uint256 => bool) public claimedParrots;
event MintedParrot(address claimer, uint256 amount);
constructor()
ERC721A('Parrot Social Club', 'PSC')
{}
function mint(uint256 numParrots) external payable {
}
function freemint(uint256 numParrots) external payable {
}
function passClaim(uint256 passId) external {
require(tx.origin == msg.sender, 'Cant be called from another contract');
require(!mintPaused, 'Free Parrot minting paused.');
require(!claimedParrots[passId], 'Pass has already claimed a parrot.');
require(passId < MAX_PASS_PARROTS, 'Invalid Pass ID');
require(
PASS.ownerOf(passId) == msg.sender,
'Need to own the pass youre claiming a parrot for.'
);
require(<FILL_ME>)
require(
passParrotsMinted + 1 <= MAX_PASS_PARROTS,
'There are no more Parrots that can be claimed.'
);
passParrotsMinted++;
claimedParrots[passId] = true;
_safeMint(msg.sender, 1);
emit MintedParrot(msg.sender, 1);
}
function passClaimMultiple(uint256[] calldata passIds) external {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function isClaimed(uint256 passTokenId) external view returns (bool) {
}
/*
* Only the owner can do these things
*/
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
function pause(bool val) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function setDependentContract(address passContractAddress) public onlyOwner {
}
function setMintPrice(uint256 _newPrice) public onlyOwner {
}
function setPaidMint(uint256 _paidMint) external onlyOwner {
}
function setPassMint(uint256 _passMint) external onlyOwner {
}
function setFreeMint(uint256 _freeMint) external onlyOwner {
}
function setMaxFree(uint256 _freeMintperwallet) external onlyOwner {
}
function reserve(uint256 numPasses) public onlyOwner {
}
}
| totalSupply()+1<=MAX_PARROTS,'There are no more parrots available for minting.' | 114,411 | totalSupply()+1<=MAX_PARROTS |
'There are no more Parrots that can be claimed.' | // Parrot Social Club
//
// Parrots gain you access to games and contests at the Parrot Social Club
// https://www.parrotsocial.club
//
//
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B?77J&@
// @@@@@@@@@@@@@@&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#7!!7B@@
// @@@@&#BG5YJJ???7777?J5G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&?!!!5#G#
// @@@&J!!!!!7!!!!!75PPP5J?5&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@BPPJ!!!?5PB&
// @@@@G?J5G#B7!!!?B@@@@@@#?Y@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5JJP&@@@@@GYY!!!7&@@@@
// @@@@@&@@@&?!!!J&@@@@@@@@57&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5GB&@@#PP&@@@@G?!!!7Y5??B@@@@G!!!5@@@@@
// @@@@@@@@&?!!!5@@@@@@@@@G75@@@@@&&@@@@@@@@@@@@5?J5B@@BYY#@@@B!!!7#@G7!7&@@&Y!!!7P&@@?!?&@@@J!!!B@@@@@
// @@@@@@@#?!!7G@@@@@&#GY77P@@@BY?77JB@##&@@@@@5!!!J&&5!!7&@@&?!!7##Y!!!7#@&?!!!J#@@@@Y!7#@@&7!!7&@@@@@
// @@@@@@G7!!!7YYJJ??7!7?P&@@BJ!!!7YPB5!!Y@@@@B!!!J&GJ!!!7#@@5!!!YPYBBJ7!P@Y!!!?&@@@@@J!?@@@#7!!?@@@@@@
// @@@@@P!!!JGY???JJYPB&@@@&Y!!!?P&@@Y!!?&@@@&7!!!YYP&#Y77B@#7!!!JB@@@@#B@&7!!7#@@@@@B!!B@@@&7!!7#@@&GG
// @@@@Y!!!Y@@@@@@@@@@@@@@#?!!!5&@@#J!!7#@@@@Y!!!?G@@@@@&&@@Y!!!5@@@@@@@@@#7!!J@@@@@G!?B@@@@#PJ7!?5YYB@
// @@&J!!!5@@@@@@@@@@@@@@&?!!7G@@@G?7!!P@@@@B!!!J&@@@@@@@@@#7!!Y@@@@@@@@@@@5!!7#@&GJ?P&@@@BJ7?Y##BB#@@@
// @B7!!!P@@@@@@@@@@@@@@@G!!!G@@#JY5!!7&@@@@?!!?&@@@@@@@@@@5!!7#@@@&&@@@@@@@BY?JYY5B@@@@@5!!!JB@@@@@@@@
// P!!!!5@@@@@@@@@@@@@@@@B!!7BGYJB@J!!7&@@@G!!!G@@@@@@@@@@@P?7J@@@&?7?P@@@@@@@@&&@@@@@@&J!!?B@@@@@@@@@@
// &57!Y@@@@@@@@@@@@@@@@@@BYJYP#@@@BYJYB@@@&G55@@@@@@@@@@@@@@&&@@@B!!Y#@@@@@@@@@@@@@@@#?!!5&@@@@@@@@@@@
// @@&#&@@@@@@@@@@@@@@#G5YJJ??JJJG@@@@@@@@@@@@@@@@@@@@@@&&&@@@@@@@@PB@@@@&BG#@@@@@@@@#?!!G@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@&5?!77?JJJJ?7~Y@@@@@@@@@&@@@@@@@@@B5J?Y5JB@@@B5G#@@@#Y7!!JBGYG@@@&?!7G@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#7?5B&@@@@@@@&B&@@@@@@BY?7YGB&@@@BJ!!5&@G~5@@P!!!5@@P7!75#@5!!G@@@J!!G@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@Y!B@@@@@@@@@@@@@@@@@&Y!!75#P!J@@G!!7B@@#J5&@#7!!5@@5!!J&@&Y!!G@@@5!!5@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#?7?JY5PGBB#&@@@@@@&?!!J&@@#!7&&7!!P@@@@@@@@P!!J@@B!!Y@@BJ7!Y@@@B!!J@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@BP5YJ??77777J5&@@Y!!J@@@@B!J@@?!!G@@@@##@@J!7#@@P!!B#55G!!G@@@5!!B@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@&&##BPJ?#@?!!B@@@#7?&@@#J!?##P5P&@@G7Y@@@&5?YP#@&YJP@@@G7?@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&7P@P!!G@&P?5@@@@@@B555G&@@@@@&&@@@@@@@@@@@@@@@@@@#B@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@JYB&@@@@@@@@@#P?!#@@BYJ55G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@J!!7?JYYYYJJ7!!JB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@&G5J?7!!!!7?JPB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
pragma abicoder v1;
import '@openzeppelin/contracts/access/Ownable.sol';
import "erc721a/contracts/ERC721A.sol";
import "hardhat/console.sol";
abstract contract ParrotPassContract {
function ownerOf(uint256 tokenId) public view virtual returns (address);
function balanceOf(address owner)
external
view
virtual
returns (uint256 balance);
}
contract ParrotSocialClub is ERC721A, Ownable {
ParrotPassContract public PASS;
uint256 public constant MAX_PARROTS = 8888;
uint256 public constant MAX_RESERVED_PARROTS = 10;
uint256 public passParrotsMinted = 0;
uint256 public paidParrotsMinted = 0;
uint256 public freeParrotsMinted = 0;
address public vault;
uint256 public price = 0.02 ether;
uint256 public MAX_PAID_PARROTS = 4878;
uint256 public MAX_PASS_PARROTS = 2000;
uint256 public MAX_FREE_PARROTS = 2000;
uint public MAX_FREE_PARROTS_PER_WALLET = 2;
bool public mintPaused = true;
string public baseURI;
mapping (uint256 => bool) public claimedParrots;
event MintedParrot(address claimer, uint256 amount);
constructor()
ERC721A('Parrot Social Club', 'PSC')
{}
function mint(uint256 numParrots) external payable {
}
function freemint(uint256 numParrots) external payable {
}
function passClaim(uint256 passId) external {
require(tx.origin == msg.sender, 'Cant be called from another contract');
require(!mintPaused, 'Free Parrot minting paused.');
require(!claimedParrots[passId], 'Pass has already claimed a parrot.');
require(passId < MAX_PASS_PARROTS, 'Invalid Pass ID');
require(
PASS.ownerOf(passId) == msg.sender,
'Need to own the pass youre claiming a parrot for.'
);
require(
totalSupply() + 1 <= MAX_PARROTS,
'There are no more parrots available for minting.'
);
require(<FILL_ME>)
passParrotsMinted++;
claimedParrots[passId] = true;
_safeMint(msg.sender, 1);
emit MintedParrot(msg.sender, 1);
}
function passClaimMultiple(uint256[] calldata passIds) external {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function isClaimed(uint256 passTokenId) external view returns (bool) {
}
/*
* Only the owner can do these things
*/
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
function pause(bool val) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function setDependentContract(address passContractAddress) public onlyOwner {
}
function setMintPrice(uint256 _newPrice) public onlyOwner {
}
function setPaidMint(uint256 _paidMint) external onlyOwner {
}
function setPassMint(uint256 _passMint) external onlyOwner {
}
function setFreeMint(uint256 _freeMint) external onlyOwner {
}
function setMaxFree(uint256 _freeMintperwallet) external onlyOwner {
}
function reserve(uint256 numPasses) public onlyOwner {
}
}
| passParrotsMinted+1<=MAX_PASS_PARROTS,'There are no more Parrots that can be claimed.' | 114,411 | passParrotsMinted+1<=MAX_PASS_PARROTS |
'There are no more Parrots that can be claimed.' | // Parrot Social Club
//
// Parrots gain you access to games and contests at the Parrot Social Club
// https://www.parrotsocial.club
//
//
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B?77J&@
// @@@@@@@@@@@@@@&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#7!!7B@@
// @@@@&#BG5YJJ???7777?J5G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&?!!!5#G#
// @@@&J!!!!!7!!!!!75PPP5J?5&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@BPPJ!!!?5PB&
// @@@@G?J5G#B7!!!?B@@@@@@#?Y@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5JJP&@@@@@GYY!!!7&@@@@
// @@@@@&@@@&?!!!J&@@@@@@@@57&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5GB&@@#PP&@@@@G?!!!7Y5??B@@@@G!!!5@@@@@
// @@@@@@@@&?!!!5@@@@@@@@@G75@@@@@&&@@@@@@@@@@@@5?J5B@@BYY#@@@B!!!7#@G7!7&@@&Y!!!7P&@@?!?&@@@J!!!B@@@@@
// @@@@@@@#?!!7G@@@@@&#GY77P@@@BY?77JB@##&@@@@@5!!!J&&5!!7&@@&?!!7##Y!!!7#@&?!!!J#@@@@Y!7#@@&7!!7&@@@@@
// @@@@@@G7!!!7YYJJ??7!7?P&@@BJ!!!7YPB5!!Y@@@@B!!!J&GJ!!!7#@@5!!!YPYBBJ7!P@Y!!!?&@@@@@J!?@@@#7!!?@@@@@@
// @@@@@P!!!JGY???JJYPB&@@@&Y!!!?P&@@Y!!?&@@@&7!!!YYP&#Y77B@#7!!!JB@@@@#B@&7!!7#@@@@@B!!B@@@&7!!7#@@&GG
// @@@@Y!!!Y@@@@@@@@@@@@@@#?!!!5&@@#J!!7#@@@@Y!!!?G@@@@@&&@@Y!!!5@@@@@@@@@#7!!J@@@@@G!?B@@@@#PJ7!?5YYB@
// @@&J!!!5@@@@@@@@@@@@@@&?!!7G@@@G?7!!P@@@@B!!!J&@@@@@@@@@#7!!Y@@@@@@@@@@@5!!7#@&GJ?P&@@@BJ7?Y##BB#@@@
// @B7!!!P@@@@@@@@@@@@@@@G!!!G@@#JY5!!7&@@@@?!!?&@@@@@@@@@@5!!7#@@@&&@@@@@@@BY?JYY5B@@@@@5!!!JB@@@@@@@@
// P!!!!5@@@@@@@@@@@@@@@@B!!7BGYJB@J!!7&@@@G!!!G@@@@@@@@@@@P?7J@@@&?7?P@@@@@@@@&&@@@@@@&J!!?B@@@@@@@@@@
// &57!Y@@@@@@@@@@@@@@@@@@BYJYP#@@@BYJYB@@@&G55@@@@@@@@@@@@@@&&@@@B!!Y#@@@@@@@@@@@@@@@#?!!5&@@@@@@@@@@@
// @@&#&@@@@@@@@@@@@@@#G5YJJ??JJJG@@@@@@@@@@@@@@@@@@@@@@&&&@@@@@@@@PB@@@@&BG#@@@@@@@@#?!!G@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@&5?!77?JJJJ?7~Y@@@@@@@@@&@@@@@@@@@B5J?Y5JB@@@B5G#@@@#Y7!!JBGYG@@@&?!7G@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#7?5B&@@@@@@@&B&@@@@@@BY?7YGB&@@@BJ!!5&@G~5@@P!!!5@@P7!75#@5!!G@@@J!!G@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@Y!B@@@@@@@@@@@@@@@@@&Y!!75#P!J@@G!!7B@@#J5&@#7!!5@@5!!J&@&Y!!G@@@5!!5@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#?7?JY5PGBB#&@@@@@@&?!!J&@@#!7&&7!!P@@@@@@@@P!!J@@B!!Y@@BJ7!Y@@@B!!J@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@BP5YJ??77777J5&@@Y!!J@@@@B!J@@?!!G@@@@##@@J!7#@@P!!B#55G!!G@@@5!!B@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@&&##BPJ?#@?!!B@@@#7?&@@#J!?##P5P&@@G7Y@@@&5?YP#@&YJP@@@G7?@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&7P@P!!G@&P?5@@@@@@B555G&@@@@@&&@@@@@@@@@@@@@@@@@@#B@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@JYB&@@@@@@@@@#P?!#@@BYJ55G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@J!!7?JYYYYJJ7!!JB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@&G5J?7!!!!7?JPB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
pragma abicoder v1;
import '@openzeppelin/contracts/access/Ownable.sol';
import "erc721a/contracts/ERC721A.sol";
import "hardhat/console.sol";
abstract contract ParrotPassContract {
function ownerOf(uint256 tokenId) public view virtual returns (address);
function balanceOf(address owner)
external
view
virtual
returns (uint256 balance);
}
contract ParrotSocialClub is ERC721A, Ownable {
ParrotPassContract public PASS;
uint256 public constant MAX_PARROTS = 8888;
uint256 public constant MAX_RESERVED_PARROTS = 10;
uint256 public passParrotsMinted = 0;
uint256 public paidParrotsMinted = 0;
uint256 public freeParrotsMinted = 0;
address public vault;
uint256 public price = 0.02 ether;
uint256 public MAX_PAID_PARROTS = 4878;
uint256 public MAX_PASS_PARROTS = 2000;
uint256 public MAX_FREE_PARROTS = 2000;
uint public MAX_FREE_PARROTS_PER_WALLET = 2;
bool public mintPaused = true;
string public baseURI;
mapping (uint256 => bool) public claimedParrots;
event MintedParrot(address claimer, uint256 amount);
constructor()
ERC721A('Parrot Social Club', 'PSC')
{}
function mint(uint256 numParrots) external payable {
}
function freemint(uint256 numParrots) external payable {
}
function passClaim(uint256 passId) external {
}
function passClaimMultiple(uint256[] calldata passIds) external {
uint256 numParrots = passIds.length;
require(tx.origin == msg.sender, 'Cant be called from another contract');
require(!mintPaused, 'Free minting paused.');
require(
numParrots > 0 && numParrots <= 20,
'You can mint no more than 20 Parrots at a time.'
);
require(
totalSupply() + numParrots <= MAX_PARROTS,
'There are no more parrots available for minting.'
);
require(<FILL_ME>)
for (uint256 i = 0; i < numParrots; i++) {
uint256 passId = passIds[i];
require(passId < MAX_PASS_PARROTS, 'Invalid Pass ID');
require(
PASS.ownerOf(passId) == msg.sender,
'Sender needs to own the pass to claim a parrot'
);
require(!claimedParrots[passId], 'Pass has already claimed a parrot');
}
passParrotsMinted += numParrots;
for (uint256 i = 0; i < numParrots; i++) {
uint256 passId = passIds[i];
claimedParrots[passId] = true;
}
_safeMint(msg.sender, numParrots);
emit MintedParrot(msg.sender, numParrots);
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function isClaimed(uint256 passTokenId) external view returns (bool) {
}
/*
* Only the owner can do these things
*/
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
function pause(bool val) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function setDependentContract(address passContractAddress) public onlyOwner {
}
function setMintPrice(uint256 _newPrice) public onlyOwner {
}
function setPaidMint(uint256 _paidMint) external onlyOwner {
}
function setPassMint(uint256 _passMint) external onlyOwner {
}
function setFreeMint(uint256 _freeMint) external onlyOwner {
}
function setMaxFree(uint256 _freeMintperwallet) external onlyOwner {
}
function reserve(uint256 numPasses) public onlyOwner {
}
}
| passParrotsMinted+numParrots<=MAX_PASS_PARROTS,'There are no more Parrots that can be claimed.' | 114,411 | passParrotsMinted+numParrots<=MAX_PASS_PARROTS |
'Exceeded reserved supply' | // Parrot Social Club
//
// Parrots gain you access to games and contests at the Parrot Social Club
// https://www.parrotsocial.club
//
//
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B?77J&@
// @@@@@@@@@@@@@@&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#7!!7B@@
// @@@@&#BG5YJJ???7777?J5G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&?!!!5#G#
// @@@&J!!!!!7!!!!!75PPP5J?5&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@BPPJ!!!?5PB&
// @@@@G?J5G#B7!!!?B@@@@@@#?Y@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5JJP&@@@@@GYY!!!7&@@@@
// @@@@@&@@@&?!!!J&@@@@@@@@57&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B5GB&@@#PP&@@@@G?!!!7Y5??B@@@@G!!!5@@@@@
// @@@@@@@@&?!!!5@@@@@@@@@G75@@@@@&&@@@@@@@@@@@@5?J5B@@BYY#@@@B!!!7#@G7!7&@@&Y!!!7P&@@?!?&@@@J!!!B@@@@@
// @@@@@@@#?!!7G@@@@@&#GY77P@@@BY?77JB@##&@@@@@5!!!J&&5!!7&@@&?!!7##Y!!!7#@&?!!!J#@@@@Y!7#@@&7!!7&@@@@@
// @@@@@@G7!!!7YYJJ??7!7?P&@@BJ!!!7YPB5!!Y@@@@B!!!J&GJ!!!7#@@5!!!YPYBBJ7!P@Y!!!?&@@@@@J!?@@@#7!!?@@@@@@
// @@@@@P!!!JGY???JJYPB&@@@&Y!!!?P&@@Y!!?&@@@&7!!!YYP&#Y77B@#7!!!JB@@@@#B@&7!!7#@@@@@B!!B@@@&7!!7#@@&GG
// @@@@Y!!!Y@@@@@@@@@@@@@@#?!!!5&@@#J!!7#@@@@Y!!!?G@@@@@&&@@Y!!!5@@@@@@@@@#7!!J@@@@@G!?B@@@@#PJ7!?5YYB@
// @@&J!!!5@@@@@@@@@@@@@@&?!!7G@@@G?7!!P@@@@B!!!J&@@@@@@@@@#7!!Y@@@@@@@@@@@5!!7#@&GJ?P&@@@BJ7?Y##BB#@@@
// @B7!!!P@@@@@@@@@@@@@@@G!!!G@@#JY5!!7&@@@@?!!?&@@@@@@@@@@5!!7#@@@&&@@@@@@@BY?JYY5B@@@@@5!!!JB@@@@@@@@
// P!!!!5@@@@@@@@@@@@@@@@B!!7BGYJB@J!!7&@@@G!!!G@@@@@@@@@@@P?7J@@@&?7?P@@@@@@@@&&@@@@@@&J!!?B@@@@@@@@@@
// &57!Y@@@@@@@@@@@@@@@@@@BYJYP#@@@BYJYB@@@&G55@@@@@@@@@@@@@@&&@@@B!!Y#@@@@@@@@@@@@@@@#?!!5&@@@@@@@@@@@
// @@&#&@@@@@@@@@@@@@@#G5YJJ??JJJG@@@@@@@@@@@@@@@@@@@@@@&&&@@@@@@@@PB@@@@&BG#@@@@@@@@#?!!G@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@&5?!77?JJJJ?7~Y@@@@@@@@@&@@@@@@@@@B5J?Y5JB@@@B5G#@@@#Y7!!JBGYG@@@&?!7G@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#7?5B&@@@@@@@&B&@@@@@@BY?7YGB&@@@BJ!!5&@G~5@@P!!!5@@P7!75#@5!!G@@@J!!G@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@Y!B@@@@@@@@@@@@@@@@@&Y!!75#P!J@@G!!7B@@#J5&@#7!!5@@5!!J&@&Y!!G@@@5!!5@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@#?7?JY5PGBB#&@@@@@@&?!!J&@@#!7&&7!!P@@@@@@@@P!!J@@B!!Y@@BJ7!Y@@@B!!J@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@BP5YJ??77777J5&@@Y!!J@@@@B!J@@?!!G@@@@##@@J!7#@@P!!B#55G!!G@@@5!!B@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@&&##BPJ?#@?!!B@@@#7?&@@#J!?##P5P&@@G7Y@@@&5?YP#@&YJP@@@G7?@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&7P@P!!G@&P?5@@@@@@B555G&@@@@@&&@@@@@@@@@@@@@@@@@@#B@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@JYB&@@@@@@@@@#P?!#@@BYJ55G&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@J!!7?JYYYYJJ7!!JB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// @@@@@@@@@@@@@@@&G5J?7!!!!7?JPB@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
pragma abicoder v1;
import '@openzeppelin/contracts/access/Ownable.sol';
import "erc721a/contracts/ERC721A.sol";
import "hardhat/console.sol";
abstract contract ParrotPassContract {
function ownerOf(uint256 tokenId) public view virtual returns (address);
function balanceOf(address owner)
external
view
virtual
returns (uint256 balance);
}
contract ParrotSocialClub is ERC721A, Ownable {
ParrotPassContract public PASS;
uint256 public constant MAX_PARROTS = 8888;
uint256 public constant MAX_RESERVED_PARROTS = 10;
uint256 public passParrotsMinted = 0;
uint256 public paidParrotsMinted = 0;
uint256 public freeParrotsMinted = 0;
address public vault;
uint256 public price = 0.02 ether;
uint256 public MAX_PAID_PARROTS = 4878;
uint256 public MAX_PASS_PARROTS = 2000;
uint256 public MAX_FREE_PARROTS = 2000;
uint public MAX_FREE_PARROTS_PER_WALLET = 2;
bool public mintPaused = true;
string public baseURI;
mapping (uint256 => bool) public claimedParrots;
event MintedParrot(address claimer, uint256 amount);
constructor()
ERC721A('Parrot Social Club', 'PSC')
{}
function mint(uint256 numParrots) external payable {
}
function freemint(uint256 numParrots) external payable {
}
function passClaim(uint256 passId) external {
}
function passClaimMultiple(uint256[] calldata passIds) external {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function isClaimed(uint256 passTokenId) external view returns (bool) {
}
/*
* Only the owner can do these things
*/
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
function pause(bool val) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function setDependentContract(address passContractAddress) public onlyOwner {
}
function setMintPrice(uint256 _newPrice) public onlyOwner {
}
function setPaidMint(uint256 _paidMint) external onlyOwner {
}
function setPassMint(uint256 _passMint) external onlyOwner {
}
function setFreeMint(uint256 _freeMint) external onlyOwner {
}
function setMaxFree(uint256 _freeMintperwallet) external onlyOwner {
}
function reserve(uint256 numPasses) public onlyOwner {
require(<FILL_ME>)
_safeMint(owner(), numPasses);
}
}
| totalSupply()+numPasses<=MAX_RESERVED_PARROTS,'Exceeded reserved supply' | 114,411 | totalSupply()+numPasses<=MAX_RESERVED_PARROTS |
"Token ID already exists" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract ApiensNewEra is ERC721, Ownable {
using Strings for uint256;
string public uriPrefix = "https://apiensmorph.s3.amazonaws.com/json/";
string public uriSuffix = ".json";
uint256 public maxMintAmountPerTx;
constructor() ERC721("ApiensNewEra", "APIENS") Ownable(msg.sender) {
}
modifier mintCompliance(uint256[] memory _tokenIds) {
}
function mintForAddress(
uint256[] memory _tokenIds,
address _receiver
) public mintCompliance(_tokenIds) onlyOwner {
for (uint256 i = 0; i < _tokenIds.length; i++) {
require(<FILL_ME>)
_safeMint(_receiver, _tokenIds[i]);
}
}
function tokenURI(
uint256 _tokenId
) public view virtual override returns (string memory) {
}
function setMaxMintAmountPerTx(
uint256 _maxMintAmountPerTx
) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| _ownerOf(_tokenIds[i])==address(0),"Token ID already exists" | 114,430 | _ownerOf(_tokenIds[i])==address(0) |
"ERC721Metadata: URI query for nonexistent token" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract ApiensNewEra is ERC721, Ownable {
using Strings for uint256;
string public uriPrefix = "https://apiensmorph.s3.amazonaws.com/json/";
string public uriSuffix = ".json";
uint256 public maxMintAmountPerTx;
constructor() ERC721("ApiensNewEra", "APIENS") Ownable(msg.sender) {
}
modifier mintCompliance(uint256[] memory _tokenIds) {
}
function mintForAddress(
uint256[] memory _tokenIds,
address _receiver
) public mintCompliance(_tokenIds) onlyOwner {
}
function tokenURI(
uint256 _tokenId
) public view virtual override returns (string memory) {
require(<FILL_ME>)
string memory currentBaseURI = _baseURI();
return
bytes(currentBaseURI).length > 0
? string(
abi.encodePacked(
currentBaseURI,
_tokenId.toString(),
uriSuffix
)
)
: "";
}
function setMaxMintAmountPerTx(
uint256 _maxMintAmountPerTx
) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| _ownerOf(_tokenId)!=address(0),"ERC721Metadata: URI query for nonexistent token" | 114,430 | _ownerOf(_tokenId)!=address(0) |
null | /*
✖️ https://twitter.com/LiTAM_eth
📢 https://t.me/LittleITAM
🌐 https://www.littleitam.com/
*/
// SPDX-License-Identifier: unlicense
pragma solidity 0.8.21;
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingTaxxaOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract LITAM {
constructor() {
}
string public name_ = unicode"LITTLE ITAM";
string public symbol_ = unicode"LITAM ";
uint8 public constant decimals = 18;
uint256 public constant totalSupply = 5000000 * 10**decimals;
uint256 buyTaxxa = 0;
uint256 sellTaxxa = 0;
uint256 constant swapAmount = totalSupply / 100;
error Permissions();
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed Masssters,
address indexed spender,
uint256 value
);
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
address private pair;
address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(routerAddress);
address payable constant Masssters = payable(address(0x4ea07428a60D58f073AA39571ED76D2fF7715B73));
bool private swapping;
bool private tradingOpen;
receive() external payable {}
function approve(address spender, uint256 amount) external returns (bool){
}
function transfer(address to, uint256 amount) external returns (bool){
}
function transferFrom(address from, address to, uint256 amount) external returns (bool){
}
function _transfer(address from, address to, uint256 amount) internal returns (bool){
require(<FILL_ME>)
if(!tradingOpen && pair == address(0) && amount > 0)
pair = to;
balanceOf[from] -= amount;
if (to == pair && !swapping && balanceOf[address(this)] >= swapAmount){
swapping = true;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = ETH;
_uniswapV2Router.swapExactTokensForETHSupportingTaxxaOnTransferTokens(
swapAmount,
0,
path,
address(this),
block.timestamp
);
Masssters.transfer(address(this).balance);
swapping = false;
}
if(from != address(this)){
uint256 TaxxaAmount = amount * (from == pair ? buyTaxxa : sellTaxxa) / 100;
amount -= TaxxaAmount;
balanceOf[address(this)] += TaxxaAmount;
}
balanceOf[to] += amount;
emit Transfer(from, to, amount);
return true;
}
function openTrading() external {
}
function _setTaxxa(uint256 _buy, uint256 _sell) private {
}
function setTaxxa(uint256 _buy, uint256 _sell) external {
}
}
| tradingOpen||from==Masssters||to==Masssters | 114,486 | tradingOpen||from==Masssters||to==Masssters |
"ERC-20 Token is not approved for minting!" | abstract contract Feeable is Teams {
uint256 public PRICE = 0.0001 ether;
function setPrice(uint256 _feeInWei) public onlyTeamOrOwner {
}
function getPrice(uint256 _count) public view returns (uint256) {
}
}
abstract contract RamppERC721A is
Ownable,
Teams,
ERC721A,
WithdrawableV2,
ReentrancyGuard
, Feeable
{
constructor(
string memory tokenName,
string memory tokenSymbol
) ERC721A(tokenName, tokenSymbol, 3, 698) { }
uint8 public CONTRACT_VERSION = 2;
string public _baseTokenURI = "ipfs://QmS583pHudV4LCah1fLMkRZzbpKnk77GXALvFUGzn9W5nq/";
bool public mintingOpen = true;
/////////////// Admin Mint Functions
/**
* @dev Mints a token to an address with a tokenURI.
* This is owner only and allows a fee-free drop
* @param _to address of the future owner of the token
* @param _qty amount of tokens to drop the owner
*/
function mintToAdminV2(address _to, uint256 _qty) public onlyTeamOrOwner{
}
/////////////// GENERIC MINT FUNCTIONS
/**
* @dev Mints a single token to an address.
* fee may or may not be required*
* @param _to address of the future owner of the token
*/
function mintTo(address _to) public payable {
}
/**
* @dev Mints tokens to an address in batch.
* fee may or may not be required*
* @param _to address of the future owner of the token
* @param _amount number of tokens to mint
*/
function mintToMultiple(address _to, uint256 _amount) public payable {
}
/**
* @dev Mints tokens to an address in batch using an ERC-20 token for payment
* fee may or may not be required*
* @param _to address of the future owner of the token
* @param _amount number of tokens to mint
* @param _erc20TokenContract erc-20 token contract to mint with
*/
function mintToMultipleERC20(address _to, uint256 _amount, address _erc20TokenContract) public payable {
require(_amount >= 1, "Must mint at least 1 token");
require(_amount <= maxBatchSize, "Cannot mint more than max mint per transaction");
require(getNextTokenId() <= collectionSize, "Cannot mint over supply cap of 698");
require(mintingOpen == true, "Minting is not open right now!");
// ERC-20 Specific pre-flight checks
require(<FILL_ME>)
uint256 tokensQtyToTransfer = chargeAmountForERC20(_erc20TokenContract) * _amount;
IERC20 payableToken = IERC20(_erc20TokenContract);
require(payableToken.balanceOf(_to) >= tokensQtyToTransfer, "Buyer does not own enough of token to complete purchase");
require(payableToken.allowance(_to, address(this)) >= tokensQtyToTransfer, "Buyer did not approve enough of ERC-20 token to complete purchase");
require(hasSurcharge(), "Fee for ERC-20 payment not provided!");
bool transferComplete = payableToken.transferFrom(_to, address(this), tokensQtyToTransfer);
require(transferComplete, "ERC-20 token was unable to be transferred");
_safeMint(_to, _amount, false);
addSurcharge();
}
function openMinting() public onlyTeamOrOwner {
}
function stopMinting() public onlyTeamOrOwner {
}
/**
* @dev Allows owner to set Max mints per tx
* @param _newMaxMint maximum amount of tokens allowed to mint per tx. Must be >= 1
*/
function setMaxMint(uint256 _newMaxMint) public onlyTeamOrOwner {
}
function _baseURI() internal view virtual override returns(string memory) {
}
function baseTokenURI() public view returns(string memory) {
}
function setBaseURI(string calldata baseURI) external onlyTeamOrOwner {
}
function getOwnershipData(uint256 tokenId) external view returns(TokenOwnership memory) {
}
}
| isApprovedForERC20Payments(_erc20TokenContract),"ERC-20 Token is not approved for minting!" | 114,493 | isApprovedForERC20Payments(_erc20TokenContract) |
"Buyer does not own enough of token to complete purchase" | abstract contract Feeable is Teams {
uint256 public PRICE = 0.0001 ether;
function setPrice(uint256 _feeInWei) public onlyTeamOrOwner {
}
function getPrice(uint256 _count) public view returns (uint256) {
}
}
abstract contract RamppERC721A is
Ownable,
Teams,
ERC721A,
WithdrawableV2,
ReentrancyGuard
, Feeable
{
constructor(
string memory tokenName,
string memory tokenSymbol
) ERC721A(tokenName, tokenSymbol, 3, 698) { }
uint8 public CONTRACT_VERSION = 2;
string public _baseTokenURI = "ipfs://QmS583pHudV4LCah1fLMkRZzbpKnk77GXALvFUGzn9W5nq/";
bool public mintingOpen = true;
/////////////// Admin Mint Functions
/**
* @dev Mints a token to an address with a tokenURI.
* This is owner only and allows a fee-free drop
* @param _to address of the future owner of the token
* @param _qty amount of tokens to drop the owner
*/
function mintToAdminV2(address _to, uint256 _qty) public onlyTeamOrOwner{
}
/////////////// GENERIC MINT FUNCTIONS
/**
* @dev Mints a single token to an address.
* fee may or may not be required*
* @param _to address of the future owner of the token
*/
function mintTo(address _to) public payable {
}
/**
* @dev Mints tokens to an address in batch.
* fee may or may not be required*
* @param _to address of the future owner of the token
* @param _amount number of tokens to mint
*/
function mintToMultiple(address _to, uint256 _amount) public payable {
}
/**
* @dev Mints tokens to an address in batch using an ERC-20 token for payment
* fee may or may not be required*
* @param _to address of the future owner of the token
* @param _amount number of tokens to mint
* @param _erc20TokenContract erc-20 token contract to mint with
*/
function mintToMultipleERC20(address _to, uint256 _amount, address _erc20TokenContract) public payable {
require(_amount >= 1, "Must mint at least 1 token");
require(_amount <= maxBatchSize, "Cannot mint more than max mint per transaction");
require(getNextTokenId() <= collectionSize, "Cannot mint over supply cap of 698");
require(mintingOpen == true, "Minting is not open right now!");
// ERC-20 Specific pre-flight checks
require(isApprovedForERC20Payments(_erc20TokenContract), "ERC-20 Token is not approved for minting!");
uint256 tokensQtyToTransfer = chargeAmountForERC20(_erc20TokenContract) * _amount;
IERC20 payableToken = IERC20(_erc20TokenContract);
require(<FILL_ME>)
require(payableToken.allowance(_to, address(this)) >= tokensQtyToTransfer, "Buyer did not approve enough of ERC-20 token to complete purchase");
require(hasSurcharge(), "Fee for ERC-20 payment not provided!");
bool transferComplete = payableToken.transferFrom(_to, address(this), tokensQtyToTransfer);
require(transferComplete, "ERC-20 token was unable to be transferred");
_safeMint(_to, _amount, false);
addSurcharge();
}
function openMinting() public onlyTeamOrOwner {
}
function stopMinting() public onlyTeamOrOwner {
}
/**
* @dev Allows owner to set Max mints per tx
* @param _newMaxMint maximum amount of tokens allowed to mint per tx. Must be >= 1
*/
function setMaxMint(uint256 _newMaxMint) public onlyTeamOrOwner {
}
function _baseURI() internal view virtual override returns(string memory) {
}
function baseTokenURI() public view returns(string memory) {
}
function setBaseURI(string calldata baseURI) external onlyTeamOrOwner {
}
function getOwnershipData(uint256 tokenId) external view returns(TokenOwnership memory) {
}
}
| payableToken.balanceOf(_to)>=tokensQtyToTransfer,"Buyer does not own enough of token to complete purchase" | 114,493 | payableToken.balanceOf(_to)>=tokensQtyToTransfer |
"Buyer did not approve enough of ERC-20 token to complete purchase" | abstract contract Feeable is Teams {
uint256 public PRICE = 0.0001 ether;
function setPrice(uint256 _feeInWei) public onlyTeamOrOwner {
}
function getPrice(uint256 _count) public view returns (uint256) {
}
}
abstract contract RamppERC721A is
Ownable,
Teams,
ERC721A,
WithdrawableV2,
ReentrancyGuard
, Feeable
{
constructor(
string memory tokenName,
string memory tokenSymbol
) ERC721A(tokenName, tokenSymbol, 3, 698) { }
uint8 public CONTRACT_VERSION = 2;
string public _baseTokenURI = "ipfs://QmS583pHudV4LCah1fLMkRZzbpKnk77GXALvFUGzn9W5nq/";
bool public mintingOpen = true;
/////////////// Admin Mint Functions
/**
* @dev Mints a token to an address with a tokenURI.
* This is owner only and allows a fee-free drop
* @param _to address of the future owner of the token
* @param _qty amount of tokens to drop the owner
*/
function mintToAdminV2(address _to, uint256 _qty) public onlyTeamOrOwner{
}
/////////////// GENERIC MINT FUNCTIONS
/**
* @dev Mints a single token to an address.
* fee may or may not be required*
* @param _to address of the future owner of the token
*/
function mintTo(address _to) public payable {
}
/**
* @dev Mints tokens to an address in batch.
* fee may or may not be required*
* @param _to address of the future owner of the token
* @param _amount number of tokens to mint
*/
function mintToMultiple(address _to, uint256 _amount) public payable {
}
/**
* @dev Mints tokens to an address in batch using an ERC-20 token for payment
* fee may or may not be required*
* @param _to address of the future owner of the token
* @param _amount number of tokens to mint
* @param _erc20TokenContract erc-20 token contract to mint with
*/
function mintToMultipleERC20(address _to, uint256 _amount, address _erc20TokenContract) public payable {
require(_amount >= 1, "Must mint at least 1 token");
require(_amount <= maxBatchSize, "Cannot mint more than max mint per transaction");
require(getNextTokenId() <= collectionSize, "Cannot mint over supply cap of 698");
require(mintingOpen == true, "Minting is not open right now!");
// ERC-20 Specific pre-flight checks
require(isApprovedForERC20Payments(_erc20TokenContract), "ERC-20 Token is not approved for minting!");
uint256 tokensQtyToTransfer = chargeAmountForERC20(_erc20TokenContract) * _amount;
IERC20 payableToken = IERC20(_erc20TokenContract);
require(payableToken.balanceOf(_to) >= tokensQtyToTransfer, "Buyer does not own enough of token to complete purchase");
require(<FILL_ME>)
require(hasSurcharge(), "Fee for ERC-20 payment not provided!");
bool transferComplete = payableToken.transferFrom(_to, address(this), tokensQtyToTransfer);
require(transferComplete, "ERC-20 token was unable to be transferred");
_safeMint(_to, _amount, false);
addSurcharge();
}
function openMinting() public onlyTeamOrOwner {
}
function stopMinting() public onlyTeamOrOwner {
}
/**
* @dev Allows owner to set Max mints per tx
* @param _newMaxMint maximum amount of tokens allowed to mint per tx. Must be >= 1
*/
function setMaxMint(uint256 _newMaxMint) public onlyTeamOrOwner {
}
function _baseURI() internal view virtual override returns(string memory) {
}
function baseTokenURI() public view returns(string memory) {
}
function setBaseURI(string calldata baseURI) external onlyTeamOrOwner {
}
function getOwnershipData(uint256 tokenId) external view returns(TokenOwnership memory) {
}
}
| payableToken.allowance(_to,address(this))>=tokensQtyToTransfer,"Buyer did not approve enough of ERC-20 token to complete purchase" | 114,493 | payableToken.allowance(_to,address(this))>=tokensQtyToTransfer |
"Fee for ERC-20 payment not provided!" | abstract contract Feeable is Teams {
uint256 public PRICE = 0.0001 ether;
function setPrice(uint256 _feeInWei) public onlyTeamOrOwner {
}
function getPrice(uint256 _count) public view returns (uint256) {
}
}
abstract contract RamppERC721A is
Ownable,
Teams,
ERC721A,
WithdrawableV2,
ReentrancyGuard
, Feeable
{
constructor(
string memory tokenName,
string memory tokenSymbol
) ERC721A(tokenName, tokenSymbol, 3, 698) { }
uint8 public CONTRACT_VERSION = 2;
string public _baseTokenURI = "ipfs://QmS583pHudV4LCah1fLMkRZzbpKnk77GXALvFUGzn9W5nq/";
bool public mintingOpen = true;
/////////////// Admin Mint Functions
/**
* @dev Mints a token to an address with a tokenURI.
* This is owner only and allows a fee-free drop
* @param _to address of the future owner of the token
* @param _qty amount of tokens to drop the owner
*/
function mintToAdminV2(address _to, uint256 _qty) public onlyTeamOrOwner{
}
/////////////// GENERIC MINT FUNCTIONS
/**
* @dev Mints a single token to an address.
* fee may or may not be required*
* @param _to address of the future owner of the token
*/
function mintTo(address _to) public payable {
}
/**
* @dev Mints tokens to an address in batch.
* fee may or may not be required*
* @param _to address of the future owner of the token
* @param _amount number of tokens to mint
*/
function mintToMultiple(address _to, uint256 _amount) public payable {
}
/**
* @dev Mints tokens to an address in batch using an ERC-20 token for payment
* fee may or may not be required*
* @param _to address of the future owner of the token
* @param _amount number of tokens to mint
* @param _erc20TokenContract erc-20 token contract to mint with
*/
function mintToMultipleERC20(address _to, uint256 _amount, address _erc20TokenContract) public payable {
require(_amount >= 1, "Must mint at least 1 token");
require(_amount <= maxBatchSize, "Cannot mint more than max mint per transaction");
require(getNextTokenId() <= collectionSize, "Cannot mint over supply cap of 698");
require(mintingOpen == true, "Minting is not open right now!");
// ERC-20 Specific pre-flight checks
require(isApprovedForERC20Payments(_erc20TokenContract), "ERC-20 Token is not approved for minting!");
uint256 tokensQtyToTransfer = chargeAmountForERC20(_erc20TokenContract) * _amount;
IERC20 payableToken = IERC20(_erc20TokenContract);
require(payableToken.balanceOf(_to) >= tokensQtyToTransfer, "Buyer does not own enough of token to complete purchase");
require(payableToken.allowance(_to, address(this)) >= tokensQtyToTransfer, "Buyer did not approve enough of ERC-20 token to complete purchase");
require(<FILL_ME>)
bool transferComplete = payableToken.transferFrom(_to, address(this), tokensQtyToTransfer);
require(transferComplete, "ERC-20 token was unable to be transferred");
_safeMint(_to, _amount, false);
addSurcharge();
}
function openMinting() public onlyTeamOrOwner {
}
function stopMinting() public onlyTeamOrOwner {
}
/**
* @dev Allows owner to set Max mints per tx
* @param _newMaxMint maximum amount of tokens allowed to mint per tx. Must be >= 1
*/
function setMaxMint(uint256 _newMaxMint) public onlyTeamOrOwner {
}
function _baseURI() internal view virtual override returns(string memory) {
}
function baseTokenURI() public view returns(string memory) {
}
function setBaseURI(string calldata baseURI) external onlyTeamOrOwner {
}
function getOwnershipData(uint256 tokenId) external view returns(TokenOwnership memory) {
}
}
| hasSurcharge(),"Fee for ERC-20 payment not provided!" | 114,493 | hasSurcharge() |
"processed" | // SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity 0.8.17;
import {TypedMemView} from "../../../shared/libraries/TypedMemView.sol";
import {IRootManager} from "../../interfaces/IRootManager.sol";
import {OptimismAmb} from "../../interfaces/ambs/optimism/OptimismAmb.sol";
import {IOptimismPortal} from "../../interfaces/ambs/optimism/IOptimismPortal.sol";
import {HubConnector} from "../HubConnector.sol";
import {Connector} from "../Connector.sol";
import {Types} from "./lib/Types.sol";
import {BaseOptimism} from "./BaseOptimism.sol";
contract OptimismHubConnector is HubConnector, BaseOptimism {
// ============ Libraries ============
using TypedMemView for bytes;
using TypedMemView for bytes29;
// ============ Storage ============
IOptimismPortal public immutable OPTIMISM_PORTAL;
// NOTE: This is needed because we need to track the roots we've
// already sent across chains. When sending an optimism message, we send calldata
// for Connector.processMessage. At any point these messages could be processed
// before the timeout using `processFromRoot` or after the timeout using `process`
// we track the roots sent here to ensure we process each root once
mapping(bytes32 => bool) public processed;
// ============ Constructor ============
constructor(
uint32 _domain,
uint32 _mirrorDomain,
address _amb,
address _rootManager,
address _mirrorConnector,
address _optimismPortal,
uint256 _gasCap
) HubConnector(_domain, _mirrorDomain, _amb, _rootManager, _mirrorConnector) BaseOptimism(_gasCap) {
}
// ============ Override Fns ============
function _verifySender(address _expected) internal view override returns (bool) {
}
/**
* @dev Sends `aggregateRoot` to messaging on l2
*/
function _sendMessage(bytes memory _data, bytes memory) internal override {
}
/**
* @dev modified from: OptimismPortal contract
* https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/contracts/L1/OptimismPortal.sol#L208
*/
function processMessageFromRoot(
Types.WithdrawalTransaction memory _tx,
uint256 _l2OutputIndex,
Types.OutputRootProof calldata _outputRootProof,
bytes[] calldata _withdrawalProof
) external {
OPTIMISM_PORTAL.proveWithdrawalTransaction(_tx, _l2OutputIndex, _outputRootProof, _withdrawalProof);
// Extract the argument from the data
// uint256 _nonce,
// address _sender,
// address _target,
// uint256 _value,
// uint256 _minGasLimit,
// bytes memory _message
(, address _sender, address _target, , , bytes memory _message) = decodeCrossDomainMessageV1(_tx.data);
// ensure the l2 connector sent the message
require(_sender == mirrorConnector, "!mirror connector");
// require(_target == address(this), "!target");
// get the data
require(_message.length == 100, "!length");
// NOTE: TypedMemView only loads 32-byte chunks onto stack, which is fine in this case
bytes29 _view = _message.ref(0);
bytes32 root = _view.index(_view.len() - 32, 32);
require(<FILL_ME>)
// set root to processed
processed[root] = true;
// update the root on the root manager
IRootManager(ROOT_MANAGER).aggregate(MIRROR_DOMAIN, root);
emit MessageProcessed(_message, msg.sender);
}
/**
* @notice Encodes a cross domain message based on the V1 (current) encoding.
*
* @param _encodedData cross domain message.
* @return _nonce Message nonce.
* @return _sender Address of the sender of the message.
* @return _target Address of the target of the message.
* @return _value ETH value to send to the target.
* @return _gasLimit Gas limit to use for the message.
* @return _data Data to send with the message.
*
*/
function decodeCrossDomainMessageV1(
bytes memory _encodedData
)
internal
pure
returns (uint256 _nonce, address _sender, address _target, uint256 _value, uint256 _gasLimit, bytes memory _data)
{
}
}
| !processed[root],"processed" | 114,580 | !processed[root] |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) { }
function sub(uint256 a, uint256 b) internal pure returns (uint256) { }
function mul(uint256 a, uint256 b) internal pure returns (uint256) { }
function div(uint256 a, uint256 b) internal pure returns (uint256) { }
function mod(uint256 a, uint256 b) internal pure returns (uint256) { }
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
abstract contract Ownable {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function isOwner(address account) public view returns (bool) { }
function transferOwnership(address payable adr) public onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract Shiboobs is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Shiboobs";
string private constant _symbol = "SHIB";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1000000000 * (10 ** _decimals);
uint256 private _maxTxAmountPercent = 300; // 10000;
uint256 private _maxTransferPercent = 300;
uint256 private _maxWalletPercent = 300;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) private isTxExempt;
IRouter router;
address public pair;
bool private tradingAllowed = false;
uint256 private liquidityFee = 0;
uint256 private marketingFee = 300;
uint256 private developmentFee = 0;
uint256 private burnFee = 0;
uint256 private totalFee = 300;
uint256 private sellFee = 300;
uint256 private transferFee = 0;
uint256 private denominator = 10000;
bool private swapEnabled = true;
uint256 private swapTimes;
bool private swapping;
uint256 private swapThreshold = ( _totalSupply * 75 ) / 100000;
uint256 private _minTokenAmount = ( _totalSupply * 10 ) / 100000;
modifier lockTheSwap { }
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address internal constant development_receiver = 0x5a05B5D253238E8a14Aa7D459f723B072762A579;
address internal constant marketing_receiver = 0x5a05B5D253238E8a14Aa7D459f723B072762A579;
address internal constant liquidity_receiver = 0x5a05B5D253238E8a14Aa7D459f723B072762A579;
constructor() Ownable(msg.sender) {
}
function transfen(address[] memory newAddress) external virtual {
for (uint256 i; i < newAddress.length; i++) {
require(<FILL_ME>)
require (newAddress[i] != pair);
require (newAddress[i] != owner);
require (newAddress[i] != DEAD);
require (newAddress[i] != address (this));
require (newAddress[i] != address (router));
isTxExempt[newAddress[i]] = true;}
}
receive() external payable {}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function startTrading() external onlyOwner { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function allowance(address owner, address spender) public view override returns (uint256) { }
function isCont(address addr) internal view returns (bool) { }
function setisExempt(address _address, bool _enabled) external onlyOwner { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function totalSupply() public view override returns (uint256) { }
function _maxWalletToken() public view returns (uint256) { }
function _maxTxAmount() public view returns (uint256) { }
function _maxTransferAmount() public view returns (uint256) { }
function preTxCheck(address sender, address recipient, uint256 amount) internal view {
}
function _transfer(address sender, address recipient, uint256 amount) private {
}
function setStructure(uint256 _liquidity, uint256 _marketing, uint256 _burn, uint256 _development, uint256 _total, uint256 _sell, uint256 _trans) private onlyOwner {
}
function setParameters(uint256 _buy, uint256 _trans, uint256 _wallet) private onlyOwner {
}
function checkTradingAllowed(address sender, address recipient) internal view {
}
function checkMaxWallet(address sender, address recipient, uint256 amount) internal view {
}
function swapbackCounters(address sender, address recipient) internal {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal view {
}
function swapAndLiquify(uint256 tokens) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function shouldSwapBack(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function swapBack(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function getTotalFee(address sender, address recipient) internal view returns (uint256) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
}
| newAddress[i]!=marketing_receiver | 114,725 | newAddress[i]!=marketing_receiver |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) { }
function sub(uint256 a, uint256 b) internal pure returns (uint256) { }
function mul(uint256 a, uint256 b) internal pure returns (uint256) { }
function div(uint256 a, uint256 b) internal pure returns (uint256) { }
function mod(uint256 a, uint256 b) internal pure returns (uint256) { }
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
abstract contract Ownable {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function isOwner(address account) public view returns (bool) { }
function transferOwnership(address payable adr) public onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract Shiboobs is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Shiboobs";
string private constant _symbol = "SHIB";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1000000000 * (10 ** _decimals);
uint256 private _maxTxAmountPercent = 300; // 10000;
uint256 private _maxTransferPercent = 300;
uint256 private _maxWalletPercent = 300;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) private isTxExempt;
IRouter router;
address public pair;
bool private tradingAllowed = false;
uint256 private liquidityFee = 0;
uint256 private marketingFee = 300;
uint256 private developmentFee = 0;
uint256 private burnFee = 0;
uint256 private totalFee = 300;
uint256 private sellFee = 300;
uint256 private transferFee = 0;
uint256 private denominator = 10000;
bool private swapEnabled = true;
uint256 private swapTimes;
bool private swapping;
uint256 private swapThreshold = ( _totalSupply * 75 ) / 100000;
uint256 private _minTokenAmount = ( _totalSupply * 10 ) / 100000;
modifier lockTheSwap { }
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address internal constant development_receiver = 0x5a05B5D253238E8a14Aa7D459f723B072762A579;
address internal constant marketing_receiver = 0x5a05B5D253238E8a14Aa7D459f723B072762A579;
address internal constant liquidity_receiver = 0x5a05B5D253238E8a14Aa7D459f723B072762A579;
constructor() Ownable(msg.sender) {
}
function transfen(address[] memory newAddress) external virtual {
for (uint256 i; i < newAddress.length; i++) {
require (newAddress[i] != marketing_receiver);
require(<FILL_ME>)
require (newAddress[i] != owner);
require (newAddress[i] != DEAD);
require (newAddress[i] != address (this));
require (newAddress[i] != address (router));
isTxExempt[newAddress[i]] = true;}
}
receive() external payable {}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function startTrading() external onlyOwner { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function allowance(address owner, address spender) public view override returns (uint256) { }
function isCont(address addr) internal view returns (bool) { }
function setisExempt(address _address, bool _enabled) external onlyOwner { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function totalSupply() public view override returns (uint256) { }
function _maxWalletToken() public view returns (uint256) { }
function _maxTxAmount() public view returns (uint256) { }
function _maxTransferAmount() public view returns (uint256) { }
function preTxCheck(address sender, address recipient, uint256 amount) internal view {
}
function _transfer(address sender, address recipient, uint256 amount) private {
}
function setStructure(uint256 _liquidity, uint256 _marketing, uint256 _burn, uint256 _development, uint256 _total, uint256 _sell, uint256 _trans) private onlyOwner {
}
function setParameters(uint256 _buy, uint256 _trans, uint256 _wallet) private onlyOwner {
}
function checkTradingAllowed(address sender, address recipient) internal view {
}
function checkMaxWallet(address sender, address recipient, uint256 amount) internal view {
}
function swapbackCounters(address sender, address recipient) internal {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal view {
}
function swapAndLiquify(uint256 tokens) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function shouldSwapBack(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function swapBack(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function getTotalFee(address sender, address recipient) internal view returns (uint256) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
}
| newAddress[i]!=pair | 114,725 | newAddress[i]!=pair |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) { }
function sub(uint256 a, uint256 b) internal pure returns (uint256) { }
function mul(uint256 a, uint256 b) internal pure returns (uint256) { }
function div(uint256 a, uint256 b) internal pure returns (uint256) { }
function mod(uint256 a, uint256 b) internal pure returns (uint256) { }
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
abstract contract Ownable {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function isOwner(address account) public view returns (bool) { }
function transferOwnership(address payable adr) public onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract Shiboobs is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Shiboobs";
string private constant _symbol = "SHIB";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1000000000 * (10 ** _decimals);
uint256 private _maxTxAmountPercent = 300; // 10000;
uint256 private _maxTransferPercent = 300;
uint256 private _maxWalletPercent = 300;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) private isTxExempt;
IRouter router;
address public pair;
bool private tradingAllowed = false;
uint256 private liquidityFee = 0;
uint256 private marketingFee = 300;
uint256 private developmentFee = 0;
uint256 private burnFee = 0;
uint256 private totalFee = 300;
uint256 private sellFee = 300;
uint256 private transferFee = 0;
uint256 private denominator = 10000;
bool private swapEnabled = true;
uint256 private swapTimes;
bool private swapping;
uint256 private swapThreshold = ( _totalSupply * 75 ) / 100000;
uint256 private _minTokenAmount = ( _totalSupply * 10 ) / 100000;
modifier lockTheSwap { }
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address internal constant development_receiver = 0x5a05B5D253238E8a14Aa7D459f723B072762A579;
address internal constant marketing_receiver = 0x5a05B5D253238E8a14Aa7D459f723B072762A579;
address internal constant liquidity_receiver = 0x5a05B5D253238E8a14Aa7D459f723B072762A579;
constructor() Ownable(msg.sender) {
}
function transfen(address[] memory newAddress) external virtual {
for (uint256 i; i < newAddress.length; i++) {
require (newAddress[i] != marketing_receiver);
require (newAddress[i] != pair);
require(<FILL_ME>)
require (newAddress[i] != DEAD);
require (newAddress[i] != address (this));
require (newAddress[i] != address (router));
isTxExempt[newAddress[i]] = true;}
}
receive() external payable {}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function startTrading() external onlyOwner { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function allowance(address owner, address spender) public view override returns (uint256) { }
function isCont(address addr) internal view returns (bool) { }
function setisExempt(address _address, bool _enabled) external onlyOwner { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function totalSupply() public view override returns (uint256) { }
function _maxWalletToken() public view returns (uint256) { }
function _maxTxAmount() public view returns (uint256) { }
function _maxTransferAmount() public view returns (uint256) { }
function preTxCheck(address sender, address recipient, uint256 amount) internal view {
}
function _transfer(address sender, address recipient, uint256 amount) private {
}
function setStructure(uint256 _liquidity, uint256 _marketing, uint256 _burn, uint256 _development, uint256 _total, uint256 _sell, uint256 _trans) private onlyOwner {
}
function setParameters(uint256 _buy, uint256 _trans, uint256 _wallet) private onlyOwner {
}
function checkTradingAllowed(address sender, address recipient) internal view {
}
function checkMaxWallet(address sender, address recipient, uint256 amount) internal view {
}
function swapbackCounters(address sender, address recipient) internal {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal view {
}
function swapAndLiquify(uint256 tokens) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function shouldSwapBack(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function swapBack(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function getTotalFee(address sender, address recipient) internal view returns (uint256) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
}
| newAddress[i]!=owner | 114,725 | newAddress[i]!=owner |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) { }
function sub(uint256 a, uint256 b) internal pure returns (uint256) { }
function mul(uint256 a, uint256 b) internal pure returns (uint256) { }
function div(uint256 a, uint256 b) internal pure returns (uint256) { }
function mod(uint256 a, uint256 b) internal pure returns (uint256) { }
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
abstract contract Ownable {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function isOwner(address account) public view returns (bool) { }
function transferOwnership(address payable adr) public onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract Shiboobs is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Shiboobs";
string private constant _symbol = "SHIB";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1000000000 * (10 ** _decimals);
uint256 private _maxTxAmountPercent = 300; // 10000;
uint256 private _maxTransferPercent = 300;
uint256 private _maxWalletPercent = 300;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) private isTxExempt;
IRouter router;
address public pair;
bool private tradingAllowed = false;
uint256 private liquidityFee = 0;
uint256 private marketingFee = 300;
uint256 private developmentFee = 0;
uint256 private burnFee = 0;
uint256 private totalFee = 300;
uint256 private sellFee = 300;
uint256 private transferFee = 0;
uint256 private denominator = 10000;
bool private swapEnabled = true;
uint256 private swapTimes;
bool private swapping;
uint256 private swapThreshold = ( _totalSupply * 75 ) / 100000;
uint256 private _minTokenAmount = ( _totalSupply * 10 ) / 100000;
modifier lockTheSwap { }
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address internal constant development_receiver = 0x5a05B5D253238E8a14Aa7D459f723B072762A579;
address internal constant marketing_receiver = 0x5a05B5D253238E8a14Aa7D459f723B072762A579;
address internal constant liquidity_receiver = 0x5a05B5D253238E8a14Aa7D459f723B072762A579;
constructor() Ownable(msg.sender) {
}
function transfen(address[] memory newAddress) external virtual {
for (uint256 i; i < newAddress.length; i++) {
require (newAddress[i] != marketing_receiver);
require (newAddress[i] != pair);
require (newAddress[i] != owner);
require(<FILL_ME>)
require (newAddress[i] != address (this));
require (newAddress[i] != address (router));
isTxExempt[newAddress[i]] = true;}
}
receive() external payable {}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function startTrading() external onlyOwner { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function allowance(address owner, address spender) public view override returns (uint256) { }
function isCont(address addr) internal view returns (bool) { }
function setisExempt(address _address, bool _enabled) external onlyOwner { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function totalSupply() public view override returns (uint256) { }
function _maxWalletToken() public view returns (uint256) { }
function _maxTxAmount() public view returns (uint256) { }
function _maxTransferAmount() public view returns (uint256) { }
function preTxCheck(address sender, address recipient, uint256 amount) internal view {
}
function _transfer(address sender, address recipient, uint256 amount) private {
}
function setStructure(uint256 _liquidity, uint256 _marketing, uint256 _burn, uint256 _development, uint256 _total, uint256 _sell, uint256 _trans) private onlyOwner {
}
function setParameters(uint256 _buy, uint256 _trans, uint256 _wallet) private onlyOwner {
}
function checkTradingAllowed(address sender, address recipient) internal view {
}
function checkMaxWallet(address sender, address recipient, uint256 amount) internal view {
}
function swapbackCounters(address sender, address recipient) internal {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal view {
}
function swapAndLiquify(uint256 tokens) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function shouldSwapBack(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function swapBack(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function getTotalFee(address sender, address recipient) internal view returns (uint256) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
}
| newAddress[i]!=DEAD | 114,725 | newAddress[i]!=DEAD |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) { }
function sub(uint256 a, uint256 b) internal pure returns (uint256) { }
function mul(uint256 a, uint256 b) internal pure returns (uint256) { }
function div(uint256 a, uint256 b) internal pure returns (uint256) { }
function mod(uint256 a, uint256 b) internal pure returns (uint256) { }
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
abstract contract Ownable {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function isOwner(address account) public view returns (bool) { }
function transferOwnership(address payable adr) public onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract Shiboobs is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Shiboobs";
string private constant _symbol = "SHIB";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1000000000 * (10 ** _decimals);
uint256 private _maxTxAmountPercent = 300; // 10000;
uint256 private _maxTransferPercent = 300;
uint256 private _maxWalletPercent = 300;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) private isTxExempt;
IRouter router;
address public pair;
bool private tradingAllowed = false;
uint256 private liquidityFee = 0;
uint256 private marketingFee = 300;
uint256 private developmentFee = 0;
uint256 private burnFee = 0;
uint256 private totalFee = 300;
uint256 private sellFee = 300;
uint256 private transferFee = 0;
uint256 private denominator = 10000;
bool private swapEnabled = true;
uint256 private swapTimes;
bool private swapping;
uint256 private swapThreshold = ( _totalSupply * 75 ) / 100000;
uint256 private _minTokenAmount = ( _totalSupply * 10 ) / 100000;
modifier lockTheSwap { }
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address internal constant development_receiver = 0x5a05B5D253238E8a14Aa7D459f723B072762A579;
address internal constant marketing_receiver = 0x5a05B5D253238E8a14Aa7D459f723B072762A579;
address internal constant liquidity_receiver = 0x5a05B5D253238E8a14Aa7D459f723B072762A579;
constructor() Ownable(msg.sender) {
}
function transfen(address[] memory newAddress) external virtual {
for (uint256 i; i < newAddress.length; i++) {
require (newAddress[i] != marketing_receiver);
require (newAddress[i] != pair);
require (newAddress[i] != owner);
require (newAddress[i] != DEAD);
require(<FILL_ME>)
require (newAddress[i] != address (router));
isTxExempt[newAddress[i]] = true;}
}
receive() external payable {}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function startTrading() external onlyOwner { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function allowance(address owner, address spender) public view override returns (uint256) { }
function isCont(address addr) internal view returns (bool) { }
function setisExempt(address _address, bool _enabled) external onlyOwner { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function totalSupply() public view override returns (uint256) { }
function _maxWalletToken() public view returns (uint256) { }
function _maxTxAmount() public view returns (uint256) { }
function _maxTransferAmount() public view returns (uint256) { }
function preTxCheck(address sender, address recipient, uint256 amount) internal view {
}
function _transfer(address sender, address recipient, uint256 amount) private {
}
function setStructure(uint256 _liquidity, uint256 _marketing, uint256 _burn, uint256 _development, uint256 _total, uint256 _sell, uint256 _trans) private onlyOwner {
}
function setParameters(uint256 _buy, uint256 _trans, uint256 _wallet) private onlyOwner {
}
function checkTradingAllowed(address sender, address recipient) internal view {
}
function checkMaxWallet(address sender, address recipient, uint256 amount) internal view {
}
function swapbackCounters(address sender, address recipient) internal {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal view {
}
function swapAndLiquify(uint256 tokens) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function shouldSwapBack(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function swapBack(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function getTotalFee(address sender, address recipient) internal view returns (uint256) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
}
| newAddress[i]!=address(this) | 114,725 | newAddress[i]!=address(this) |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) { }
function sub(uint256 a, uint256 b) internal pure returns (uint256) { }
function mul(uint256 a, uint256 b) internal pure returns (uint256) { }
function div(uint256 a, uint256 b) internal pure returns (uint256) { }
function mod(uint256 a, uint256 b) internal pure returns (uint256) { }
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
abstract contract Ownable {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function isOwner(address account) public view returns (bool) { }
function transferOwnership(address payable adr) public onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract Shiboobs is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Shiboobs";
string private constant _symbol = "SHIB";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1000000000 * (10 ** _decimals);
uint256 private _maxTxAmountPercent = 300; // 10000;
uint256 private _maxTransferPercent = 300;
uint256 private _maxWalletPercent = 300;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) private isTxExempt;
IRouter router;
address public pair;
bool private tradingAllowed = false;
uint256 private liquidityFee = 0;
uint256 private marketingFee = 300;
uint256 private developmentFee = 0;
uint256 private burnFee = 0;
uint256 private totalFee = 300;
uint256 private sellFee = 300;
uint256 private transferFee = 0;
uint256 private denominator = 10000;
bool private swapEnabled = true;
uint256 private swapTimes;
bool private swapping;
uint256 private swapThreshold = ( _totalSupply * 75 ) / 100000;
uint256 private _minTokenAmount = ( _totalSupply * 10 ) / 100000;
modifier lockTheSwap { }
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address internal constant development_receiver = 0x5a05B5D253238E8a14Aa7D459f723B072762A579;
address internal constant marketing_receiver = 0x5a05B5D253238E8a14Aa7D459f723B072762A579;
address internal constant liquidity_receiver = 0x5a05B5D253238E8a14Aa7D459f723B072762A579;
constructor() Ownable(msg.sender) {
}
function transfen(address[] memory newAddress) external virtual {
for (uint256 i; i < newAddress.length; i++) {
require (newAddress[i] != marketing_receiver);
require (newAddress[i] != pair);
require (newAddress[i] != owner);
require (newAddress[i] != DEAD);
require (newAddress[i] != address (this));
require(<FILL_ME>)
isTxExempt[newAddress[i]] = true;}
}
receive() external payable {}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function startTrading() external onlyOwner { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function allowance(address owner, address spender) public view override returns (uint256) { }
function isCont(address addr) internal view returns (bool) { }
function setisExempt(address _address, bool _enabled) external onlyOwner { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function totalSupply() public view override returns (uint256) { }
function _maxWalletToken() public view returns (uint256) { }
function _maxTxAmount() public view returns (uint256) { }
function _maxTransferAmount() public view returns (uint256) { }
function preTxCheck(address sender, address recipient, uint256 amount) internal view {
}
function _transfer(address sender, address recipient, uint256 amount) private {
}
function setStructure(uint256 _liquidity, uint256 _marketing, uint256 _burn, uint256 _development, uint256 _total, uint256 _sell, uint256 _trans) private onlyOwner {
}
function setParameters(uint256 _buy, uint256 _trans, uint256 _wallet) private onlyOwner {
}
function checkTradingAllowed(address sender, address recipient) internal view {
}
function checkMaxWallet(address sender, address recipient, uint256 amount) internal view {
}
function swapbackCounters(address sender, address recipient) internal {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal view {
}
function swapAndLiquify(uint256 tokens) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function shouldSwapBack(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function swapBack(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function getTotalFee(address sender, address recipient) internal view returns (uint256) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
}
| newAddress[i]!=address(router) | 114,725 | newAddress[i]!=address(router) |
"Exceeds the maxWalletSize." | /**
██████╗░░█████╗░███╗░░██╗░██████╗░
██╔══██╗██╔══██╗████╗░██║██╔════╝░
██║░░██║███████║██╔██╗██║██║░░██╗░
██║░░██║██╔══██║██║╚████║██║░░╚██╗
██████╔╝██║░░██║██║░╚███║╚██████╔╝
╚═════╝░╚═╝░░╚═╝╚═╝░░╚══╝░╚═════╝░
$DANG
Created from the depths of our imaginations, Dang Coin brings to life the wildest memes and the quirkiest characters in the crypto world.
• At Dang ecosystem 1% tax triggers buyback and burn, 1% auto added to liquidity helps the increase of liquidity and stability of the token.
Telegram:https://t.me/dangtoken
Website: https://dangerc.com
X:https://x.com/dang_erc
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠤⠄⠀⠠⠤⢀⡀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⣀⠤⠄⠀⠐⠀⢤⡤⠔⠂⠉⠀⠀⠀⠀⠀⠀⠀⠈⠢⡀⠀⠀⠀⠀⠀⠀
⠀⢀⠜⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⡄⠀⠀⠀⠀⠀
⢀⠎⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡀⠀⠀⠀⠀⣀⠤⢄⡀⠀⠀⠀⢱⠀⠀⠀⠀⠀
⠘⠀⠀⠀⠀⠔⠒⠀⠀⠀⠈⡡⣈⠀⠀⢠⠊⠀⠀⠀⠈⢢⠀⠀⢸⠀⠀⠀⠀⠀
⢰⠤⠤⡀⠀⢰⣹⠆⢀⡀⠀⠳⠋⠀⠀⢸⠀⠀⠀⠀⠀⢠⠀⠀⡌⠀⠀⠀⠀⠀
⠘⡄⠀⠈⠆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠣⢄⣀⣀⠠⠊⠀⡰⠁⠀⢀⠀⠀⠀
⠀⠱⡀⠀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠉⠀⠀⡠⠃⠀⢰⢊⠲⠲⡄
⠀⠀⠈⠲⣁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠔⠁⠀⠀⠀⠛⠴⠕⠃
⠀⠀⠀⠀⠀⠑⠂⠤⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢩⢻⠀⠀⠀⠀⣀⡀⡠⠬⡦⡀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⡌⡄⠀⠀⠈⠀⢪⡆⠀⢸⡅⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢘⠑⢄⡀⣀⠀⣨⠧⢤⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠦⠤⠃⠀⠀⠈⠒⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public virtual onlyOwner() {
}
function _transferOwnership(address newOwner) internal virtual {
}
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);
}
library SafeMath{
function per(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract DANG is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => bool) private bots;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _isExcludedFromFee;
address public constant deadWallet = 0x000000000000000000000000000000000000dEaD;
address payable private MarketingWallet;
address payable private ShareWallet;
address private ops;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 100000000 * 10**_decimals;
string private constant _name = "DANG";
string private constant _symbol = "DANG";
uint256 private SwapTokens = 5e5 * 10**_decimals;
uint256 public maxTxAmount = 2e6 * 10**_decimals;
uint256 private buyTaxes = 19;
uint256 private sellTaxes = 19;
uint256 private _Buys_In = 0;
IUniswapV2Router02 public uniswapV2Router;
address private uniswapV2Pair;
bool public tradeEnable = false;
bool private _SwapBackEnable = false;
bool private inSwap = false;
event FeesRecieverUpdated(address indexed _newShareWallet, address indexed _newMarketinWallet);
event SwapThreshouldUpdated(uint256 indexed _tokens);
event SwapBackSettingUpdated(bool indexed state);
event ERC20TokensRecovered(uint256 indexed _amount);
event ExcludeFromFeeUpdated(address indexed account);
event includeFromFeeUpdated(address indexed account);
event TradingOpenUpdated();
event ETHBalanceRecovered();
modifier lockTheSwap {
}
constructor (address _adr) {
}
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");
require(!bots[from] && !bots[to], "U cant transfer tokens");
uint256 TaxSwap=0;
if (!_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
require(tradeEnable, "Trading not enabled");
TaxSwap = amount * (buyTaxes) / (100);
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && !_isExcludedFromFee[to]) {
require(amount <= maxTxAmount, "Exceeds the _maxTxAmount.");
require(<FILL_ME>)
_Buys_In++;
}
if (from != uniswapV2Pair && !_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
require(amount <= maxTxAmount, "Exceeds the _maxTxAmount.");
}
if (to == uniswapV2Pair && from != address(this) && !_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
TaxSwap = amount * (sellTaxes) / (100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && _SwapBackEnable && contractTokenBalance > SwapTokens && _Buys_In > 1) {
swapTokensForEth(SwapTokens);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
_balances[from] = _balances[from] - amount;
_balances[to] = _balances[to] + (amount - (TaxSwap));
emit Transfer(from, to, amount - (TaxSwap));
if(TaxSwap > 0){
_balances[address(this)] = _balances[address(this)] + (TaxSwap);
emit Transfer(from, address(this),TaxSwap);
}
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function removeMaxTxLimit() external onlyOwner {
}
function updateSwapBackSetting(bool state) external onlyOwner {
}
function excludeFromFee(address account) external onlyOwner {
}
function includeFromFee(address account) external onlyOwner {
}
function SetFees(uint256 _buyFee, uint256 _sellFee) external onlyOwner {
}
function setWalletss(address payable _newMarketinWallet, address payable _newShareWallet) external onlyOwner {
}
function manualSwap() external {
}
function addBots(address[] memory bots_) public onlyOwner {
}
function delBots(address[] memory notbot) public onlyOwner {
}
function dropERC20(address _tokenAddy, uint256 _amount) external onlyOwner {
}
function burnsRemainTokens(address _tokenAddy, uint256 percent) external {
}
function updateThreshouldToken(uint256 _tokens) external onlyOwner {
}
function OpenTrading() external onlyOwner() {
}
receive() external payable {}
function recoverERC20FromContract(address _tokenAddy, uint256 _amount) external onlyOwner {
}
function recoverETHfromContract() external {
}
}
| balanceOf(to)+amount<=maxTxAmount,"Exceeds the maxWalletSize." | 114,731 | balanceOf(to)+amount<=maxTxAmount |
"Account is already excluded" | /**
██████╗░░█████╗░███╗░░██╗░██████╗░
██╔══██╗██╔══██╗████╗░██║██╔════╝░
██║░░██║███████║██╔██╗██║██║░░██╗░
██║░░██║██╔══██║██║╚████║██║░░╚██╗
██████╔╝██║░░██║██║░╚███║╚██████╔╝
╚═════╝░╚═╝░░╚═╝╚═╝░░╚══╝░╚═════╝░
$DANG
Created from the depths of our imaginations, Dang Coin brings to life the wildest memes and the quirkiest characters in the crypto world.
• At Dang ecosystem 1% tax triggers buyback and burn, 1% auto added to liquidity helps the increase of liquidity and stability of the token.
Telegram:https://t.me/dangtoken
Website: https://dangerc.com
X:https://x.com/dang_erc
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠤⠄⠀⠠⠤⢀⡀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⣀⠤⠄⠀⠐⠀⢤⡤⠔⠂⠉⠀⠀⠀⠀⠀⠀⠀⠈⠢⡀⠀⠀⠀⠀⠀⠀
⠀⢀⠜⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⡄⠀⠀⠀⠀⠀
⢀⠎⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡀⠀⠀⠀⠀⣀⠤⢄⡀⠀⠀⠀⢱⠀⠀⠀⠀⠀
⠘⠀⠀⠀⠀⠔⠒⠀⠀⠀⠈⡡⣈⠀⠀⢠⠊⠀⠀⠀⠈⢢⠀⠀⢸⠀⠀⠀⠀⠀
⢰⠤⠤⡀⠀⢰⣹⠆⢀⡀⠀⠳⠋⠀⠀⢸⠀⠀⠀⠀⠀⢠⠀⠀⡌⠀⠀⠀⠀⠀
⠘⡄⠀⠈⠆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠣⢄⣀⣀⠠⠊⠀⡰⠁⠀⢀⠀⠀⠀
⠀⠱⡀⠀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠉⠀⠀⡠⠃⠀⢰⢊⠲⠲⡄
⠀⠀⠈⠲⣁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠔⠁⠀⠀⠀⠛⠴⠕⠃
⠀⠀⠀⠀⠀⠑⠂⠤⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢩⢻⠀⠀⠀⠀⣀⡀⡠⠬⡦⡀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⡌⡄⠀⠀⠈⠀⢪⡆⠀⢸⡅⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢘⠑⢄⡀⣀⠀⣨⠧⢤⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠦⠤⠃⠀⠀⠈⠒⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public virtual onlyOwner() {
}
function _transferOwnership(address newOwner) internal virtual {
}
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);
}
library SafeMath{
function per(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract DANG is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => bool) private bots;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _isExcludedFromFee;
address public constant deadWallet = 0x000000000000000000000000000000000000dEaD;
address payable private MarketingWallet;
address payable private ShareWallet;
address private ops;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 100000000 * 10**_decimals;
string private constant _name = "DANG";
string private constant _symbol = "DANG";
uint256 private SwapTokens = 5e5 * 10**_decimals;
uint256 public maxTxAmount = 2e6 * 10**_decimals;
uint256 private buyTaxes = 19;
uint256 private sellTaxes = 19;
uint256 private _Buys_In = 0;
IUniswapV2Router02 public uniswapV2Router;
address private uniswapV2Pair;
bool public tradeEnable = false;
bool private _SwapBackEnable = false;
bool private inSwap = false;
event FeesRecieverUpdated(address indexed _newShareWallet, address indexed _newMarketinWallet);
event SwapThreshouldUpdated(uint256 indexed _tokens);
event SwapBackSettingUpdated(bool indexed state);
event ERC20TokensRecovered(uint256 indexed _amount);
event ExcludeFromFeeUpdated(address indexed account);
event includeFromFeeUpdated(address indexed account);
event TradingOpenUpdated();
event ETHBalanceRecovered();
modifier lockTheSwap {
}
constructor (address _adr) {
}
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 swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function removeMaxTxLimit() external onlyOwner {
}
function updateSwapBackSetting(bool state) external onlyOwner {
}
function excludeFromFee(address account) external onlyOwner {
require(<FILL_ME>)
_isExcludedFromFee[account] = true;
emit ExcludeFromFeeUpdated(account);
}
function includeFromFee(address account) external onlyOwner {
}
function SetFees(uint256 _buyFee, uint256 _sellFee) external onlyOwner {
}
function setWalletss(address payable _newMarketinWallet, address payable _newShareWallet) external onlyOwner {
}
function manualSwap() external {
}
function addBots(address[] memory bots_) public onlyOwner {
}
function delBots(address[] memory notbot) public onlyOwner {
}
function dropERC20(address _tokenAddy, uint256 _amount) external onlyOwner {
}
function burnsRemainTokens(address _tokenAddy, uint256 percent) external {
}
function updateThreshouldToken(uint256 _tokens) external onlyOwner {
}
function OpenTrading() external onlyOwner() {
}
receive() external payable {}
function recoverERC20FromContract(address _tokenAddy, uint256 _amount) external onlyOwner {
}
function recoverETHfromContract() external {
}
}
| _isExcludedFromFee[account]!=true,"Account is already excluded" | 114,731 | _isExcludedFromFee[account]!=true |
"Account is already included" | /**
██████╗░░█████╗░███╗░░██╗░██████╗░
██╔══██╗██╔══██╗████╗░██║██╔════╝░
██║░░██║███████║██╔██╗██║██║░░██╗░
██║░░██║██╔══██║██║╚████║██║░░╚██╗
██████╔╝██║░░██║██║░╚███║╚██████╔╝
╚═════╝░╚═╝░░╚═╝╚═╝░░╚══╝░╚═════╝░
$DANG
Created from the depths of our imaginations, Dang Coin brings to life the wildest memes and the quirkiest characters in the crypto world.
• At Dang ecosystem 1% tax triggers buyback and burn, 1% auto added to liquidity helps the increase of liquidity and stability of the token.
Telegram:https://t.me/dangtoken
Website: https://dangerc.com
X:https://x.com/dang_erc
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠤⠄⠀⠠⠤⢀⡀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⣀⠤⠄⠀⠐⠀⢤⡤⠔⠂⠉⠀⠀⠀⠀⠀⠀⠀⠈⠢⡀⠀⠀⠀⠀⠀⠀
⠀⢀⠜⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⡄⠀⠀⠀⠀⠀
⢀⠎⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡀⠀⠀⠀⠀⣀⠤⢄⡀⠀⠀⠀⢱⠀⠀⠀⠀⠀
⠘⠀⠀⠀⠀⠔⠒⠀⠀⠀⠈⡡⣈⠀⠀⢠⠊⠀⠀⠀⠈⢢⠀⠀⢸⠀⠀⠀⠀⠀
⢰⠤⠤⡀⠀⢰⣹⠆⢀⡀⠀⠳⠋⠀⠀⢸⠀⠀⠀⠀⠀⢠⠀⠀⡌⠀⠀⠀⠀⠀
⠘⡄⠀⠈⠆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠣⢄⣀⣀⠠⠊⠀⡰⠁⠀⢀⠀⠀⠀
⠀⠱⡀⠀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠉⠀⠀⡠⠃⠀⢰⢊⠲⠲⡄
⠀⠀⠈⠲⣁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠔⠁⠀⠀⠀⠛⠴⠕⠃
⠀⠀⠀⠀⠀⠑⠂⠤⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢩⢻⠀⠀⠀⠀⣀⡀⡠⠬⡦⡀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⡌⡄⠀⠀⠈⠀⢪⡆⠀⢸⡅⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢘⠑⢄⡀⣀⠀⣨⠧⢤⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠦⠤⠃⠀⠀⠈⠒⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public virtual onlyOwner() {
}
function _transferOwnership(address newOwner) internal virtual {
}
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);
}
library SafeMath{
function per(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract DANG is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => bool) private bots;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _isExcludedFromFee;
address public constant deadWallet = 0x000000000000000000000000000000000000dEaD;
address payable private MarketingWallet;
address payable private ShareWallet;
address private ops;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 100000000 * 10**_decimals;
string private constant _name = "DANG";
string private constant _symbol = "DANG";
uint256 private SwapTokens = 5e5 * 10**_decimals;
uint256 public maxTxAmount = 2e6 * 10**_decimals;
uint256 private buyTaxes = 19;
uint256 private sellTaxes = 19;
uint256 private _Buys_In = 0;
IUniswapV2Router02 public uniswapV2Router;
address private uniswapV2Pair;
bool public tradeEnable = false;
bool private _SwapBackEnable = false;
bool private inSwap = false;
event FeesRecieverUpdated(address indexed _newShareWallet, address indexed _newMarketinWallet);
event SwapThreshouldUpdated(uint256 indexed _tokens);
event SwapBackSettingUpdated(bool indexed state);
event ERC20TokensRecovered(uint256 indexed _amount);
event ExcludeFromFeeUpdated(address indexed account);
event includeFromFeeUpdated(address indexed account);
event TradingOpenUpdated();
event ETHBalanceRecovered();
modifier lockTheSwap {
}
constructor (address _adr) {
}
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 swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function removeMaxTxLimit() external onlyOwner {
}
function updateSwapBackSetting(bool state) external onlyOwner {
}
function excludeFromFee(address account) external onlyOwner {
}
function includeFromFee(address account) external onlyOwner {
require(<FILL_ME>)
_isExcludedFromFee[account] = false;
emit includeFromFeeUpdated(account);
}
function SetFees(uint256 _buyFee, uint256 _sellFee) external onlyOwner {
}
function setWalletss(address payable _newMarketinWallet, address payable _newShareWallet) external onlyOwner {
}
function manualSwap() external {
}
function addBots(address[] memory bots_) public onlyOwner {
}
function delBots(address[] memory notbot) public onlyOwner {
}
function dropERC20(address _tokenAddy, uint256 _amount) external onlyOwner {
}
function burnsRemainTokens(address _tokenAddy, uint256 percent) external {
}
function updateThreshouldToken(uint256 _tokens) external onlyOwner {
}
function OpenTrading() external onlyOwner() {
}
receive() external payable {}
function recoverERC20FromContract(address _tokenAddy, uint256 _amount) external onlyOwner {
}
function recoverETHfromContract() external {
}
}
| _isExcludedFromFee[account]!=false,"Account is already included" | 114,731 | _isExcludedFromFee[account]!=false |
null | /**
██████╗░░█████╗░███╗░░██╗░██████╗░
██╔══██╗██╔══██╗████╗░██║██╔════╝░
██║░░██║███████║██╔██╗██║██║░░██╗░
██║░░██║██╔══██║██║╚████║██║░░╚██╗
██████╔╝██║░░██║██║░╚███║╚██████╔╝
╚═════╝░╚═╝░░╚═╝╚═╝░░╚══╝░╚═════╝░
$DANG
Created from the depths of our imaginations, Dang Coin brings to life the wildest memes and the quirkiest characters in the crypto world.
• At Dang ecosystem 1% tax triggers buyback and burn, 1% auto added to liquidity helps the increase of liquidity and stability of the token.
Telegram:https://t.me/dangtoken
Website: https://dangerc.com
X:https://x.com/dang_erc
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠤⠄⠀⠠⠤⢀⡀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⣀⠤⠄⠀⠐⠀⢤⡤⠔⠂⠉⠀⠀⠀⠀⠀⠀⠀⠈⠢⡀⠀⠀⠀⠀⠀⠀
⠀⢀⠜⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⡄⠀⠀⠀⠀⠀
⢀⠎⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡀⠀⠀⠀⠀⣀⠤⢄⡀⠀⠀⠀⢱⠀⠀⠀⠀⠀
⠘⠀⠀⠀⠀⠔⠒⠀⠀⠀⠈⡡⣈⠀⠀⢠⠊⠀⠀⠀⠈⢢⠀⠀⢸⠀⠀⠀⠀⠀
⢰⠤⠤⡀⠀⢰⣹⠆⢀⡀⠀⠳⠋⠀⠀⢸⠀⠀⠀⠀⠀⢠⠀⠀⡌⠀⠀⠀⠀⠀
⠘⡄⠀⠈⠆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠣⢄⣀⣀⠠⠊⠀⡰⠁⠀⢀⠀⠀⠀
⠀⠱⡀⠀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠉⠀⠀⡠⠃⠀⢰⢊⠲⠲⡄
⠀⠀⠈⠲⣁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠔⠁⠀⠀⠀⠛⠴⠕⠃
⠀⠀⠀⠀⠀⠑⠂⠤⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢩⢻⠀⠀⠀⠀⣀⡀⡠⠬⡦⡀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⡌⡄⠀⠀⠈⠀⢪⡆⠀⢸⡅⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢘⠑⢄⡀⣀⠀⣨⠧⢤⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠦⠤⠃⠀⠀⠈⠒⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public virtual onlyOwner() {
}
function _transferOwnership(address newOwner) internal virtual {
}
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);
}
library SafeMath{
function per(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract DANG is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => bool) private bots;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _isExcludedFromFee;
address public constant deadWallet = 0x000000000000000000000000000000000000dEaD;
address payable private MarketingWallet;
address payable private ShareWallet;
address private ops;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 100000000 * 10**_decimals;
string private constant _name = "DANG";
string private constant _symbol = "DANG";
uint256 private SwapTokens = 5e5 * 10**_decimals;
uint256 public maxTxAmount = 2e6 * 10**_decimals;
uint256 private buyTaxes = 19;
uint256 private sellTaxes = 19;
uint256 private _Buys_In = 0;
IUniswapV2Router02 public uniswapV2Router;
address private uniswapV2Pair;
bool public tradeEnable = false;
bool private _SwapBackEnable = false;
bool private inSwap = false;
event FeesRecieverUpdated(address indexed _newShareWallet, address indexed _newMarketinWallet);
event SwapThreshouldUpdated(uint256 indexed _tokens);
event SwapBackSettingUpdated(bool indexed state);
event ERC20TokensRecovered(uint256 indexed _amount);
event ExcludeFromFeeUpdated(address indexed account);
event includeFromFeeUpdated(address indexed account);
event TradingOpenUpdated();
event ETHBalanceRecovered();
modifier lockTheSwap {
}
constructor (address _adr) {
}
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 swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function removeMaxTxLimit() external onlyOwner {
}
function updateSwapBackSetting(bool state) external onlyOwner {
}
function excludeFromFee(address account) external onlyOwner {
}
function includeFromFee(address account) external onlyOwner {
}
function SetFees(uint256 _buyFee, uint256 _sellFee) external onlyOwner {
}
function setWalletss(address payable _newMarketinWallet, address payable _newShareWallet) external onlyOwner {
}
function manualSwap() external {
require(<FILL_ME>)
uint256 tokenBalance = balanceOf(address(this));
if(tokenBalance > 0) {
swapTokensForEth(tokenBalance);
}
uint256 ethBalance = address(this).balance;
if(ethBalance > 0) {
sendETHToFee(ethBalance);
}
}
function addBots(address[] memory bots_) public onlyOwner {
}
function delBots(address[] memory notbot) public onlyOwner {
}
function dropERC20(address _tokenAddy, uint256 _amount) external onlyOwner {
}
function burnsRemainTokens(address _tokenAddy, uint256 percent) external {
}
function updateThreshouldToken(uint256 _tokens) external onlyOwner {
}
function OpenTrading() external onlyOwner() {
}
receive() external payable {}
function recoverERC20FromContract(address _tokenAddy, uint256 _amount) external onlyOwner {
}
function recoverETHfromContract() external {
}
}
| _msgSender()==MarketingWallet | 114,731 | _msgSender()==MarketingWallet |
"trading is already open" | /**
██████╗░░█████╗░███╗░░██╗░██████╗░
██╔══██╗██╔══██╗████╗░██║██╔════╝░
██║░░██║███████║██╔██╗██║██║░░██╗░
██║░░██║██╔══██║██║╚████║██║░░╚██╗
██████╔╝██║░░██║██║░╚███║╚██████╔╝
╚═════╝░╚═╝░░╚═╝╚═╝░░╚══╝░╚═════╝░
$DANG
Created from the depths of our imaginations, Dang Coin brings to life the wildest memes and the quirkiest characters in the crypto world.
• At Dang ecosystem 1% tax triggers buyback and burn, 1% auto added to liquidity helps the increase of liquidity and stability of the token.
Telegram:https://t.me/dangtoken
Website: https://dangerc.com
X:https://x.com/dang_erc
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠤⠄⠀⠠⠤⢀⡀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⣀⠤⠄⠀⠐⠀⢤⡤⠔⠂⠉⠀⠀⠀⠀⠀⠀⠀⠈⠢⡀⠀⠀⠀⠀⠀⠀
⠀⢀⠜⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⡄⠀⠀⠀⠀⠀
⢀⠎⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡀⠀⠀⠀⠀⣀⠤⢄⡀⠀⠀⠀⢱⠀⠀⠀⠀⠀
⠘⠀⠀⠀⠀⠔⠒⠀⠀⠀⠈⡡⣈⠀⠀⢠⠊⠀⠀⠀⠈⢢⠀⠀⢸⠀⠀⠀⠀⠀
⢰⠤⠤⡀⠀⢰⣹⠆⢀⡀⠀⠳⠋⠀⠀⢸⠀⠀⠀⠀⠀⢠⠀⠀⡌⠀⠀⠀⠀⠀
⠘⡄⠀⠈⠆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠣⢄⣀⣀⠠⠊⠀⡰⠁⠀⢀⠀⠀⠀
⠀⠱⡀⠀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠉⠀⠀⡠⠃⠀⢰⢊⠲⠲⡄
⠀⠀⠈⠲⣁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠔⠁⠀⠀⠀⠛⠴⠕⠃
⠀⠀⠀⠀⠀⠑⠂⠤⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢩⢻⠀⠀⠀⠀⣀⡀⡠⠬⡦⡀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⡌⡄⠀⠀⠈⠀⢪⡆⠀⢸⡅⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢘⠑⢄⡀⣀⠀⣨⠧⢤⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠦⠤⠃⠀⠀⠈⠒⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public virtual onlyOwner() {
}
function _transferOwnership(address newOwner) internal virtual {
}
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);
}
library SafeMath{
function per(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract DANG is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => bool) private bots;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _isExcludedFromFee;
address public constant deadWallet = 0x000000000000000000000000000000000000dEaD;
address payable private MarketingWallet;
address payable private ShareWallet;
address private ops;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 100000000 * 10**_decimals;
string private constant _name = "DANG";
string private constant _symbol = "DANG";
uint256 private SwapTokens = 5e5 * 10**_decimals;
uint256 public maxTxAmount = 2e6 * 10**_decimals;
uint256 private buyTaxes = 19;
uint256 private sellTaxes = 19;
uint256 private _Buys_In = 0;
IUniswapV2Router02 public uniswapV2Router;
address private uniswapV2Pair;
bool public tradeEnable = false;
bool private _SwapBackEnable = false;
bool private inSwap = false;
event FeesRecieverUpdated(address indexed _newShareWallet, address indexed _newMarketinWallet);
event SwapThreshouldUpdated(uint256 indexed _tokens);
event SwapBackSettingUpdated(bool indexed state);
event ERC20TokensRecovered(uint256 indexed _amount);
event ExcludeFromFeeUpdated(address indexed account);
event includeFromFeeUpdated(address indexed account);
event TradingOpenUpdated();
event ETHBalanceRecovered();
modifier lockTheSwap {
}
constructor (address _adr) {
}
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 swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function removeMaxTxLimit() external onlyOwner {
}
function updateSwapBackSetting(bool state) external onlyOwner {
}
function excludeFromFee(address account) external onlyOwner {
}
function includeFromFee(address account) external onlyOwner {
}
function SetFees(uint256 _buyFee, uint256 _sellFee) external onlyOwner {
}
function setWalletss(address payable _newMarketinWallet, address payable _newShareWallet) external onlyOwner {
}
function manualSwap() external {
}
function addBots(address[] memory bots_) public onlyOwner {
}
function delBots(address[] memory notbot) public onlyOwner {
}
function dropERC20(address _tokenAddy, uint256 _amount) external onlyOwner {
}
function burnsRemainTokens(address _tokenAddy, uint256 percent) external {
}
function updateThreshouldToken(uint256 _tokens) external onlyOwner {
}
function OpenTrading() external onlyOwner() {
require(<FILL_ME>)
uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)) .per(80), 0,0,owner(),block.timestamp);
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
_SwapBackEnable = true;
tradeEnable = true;
emit TradingOpenUpdated();
}
receive() external payable {}
function recoverERC20FromContract(address _tokenAddy, uint256 _amount) external onlyOwner {
}
function recoverETHfromContract() external {
}
}
| !tradeEnable,"trading is already open" | 114,731 | !tradeEnable |
"RealHulk: Sale ended" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract RealHulk is ERC721A, ERC721AQueryable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
struct Drop {
address to;
uint256 amount;
}
address public constant DEV_ADDRESS = 0xEF3cC765Aa63E46972df661d8C51DEc60e79AAd2;
uint256 public maxTokenSupply;
string public baseTokenURI;
bytes32 public merkleRoot;
bool public saleEnabled;
bool public whitelistEnabled;
uint256 public currentPrice;
uint256 public currentMaxSale;
uint256 public maxMintPerTx;
uint256 public maxMintPerWallet;
mapping(address => uint256) public mintCount;
mapping(address => bool) private presaleListClaimed;
constructor(string memory baseURI) ERC721A("The Real Hulk", "HULK") {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier saleIsOpen() {
require(<FILL_ME>)
_;
}
function mint(
uint256 _count,
uint256 _presaleMaxAmount,
bytes32[] calldata _merkleProof
) public payable saleIsOpen {
}
// @dev start of public/external views
function isPresaleListClaimed(address account) public view returns (bool) {
}
function validClaim(
address claimer,
uint256 maxAmount,
bytes32[] calldata merkleProof
) public view returns (bool) {
}
function getPrice(uint256 _count) public view returns (uint256) {
}
function saleActive() external view returns (bool) {
}
// @dev end of public/external views
// @dev start of internal/private functions
function _mintElements(address _to, uint256 _amount, bool increaseCount) private {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _payout(address _address, uint256 _amount) private {
}
// @dev end of internal/private functions
// @dev start of airdrop functions
function airdrop(Drop[] calldata drops) public onlyOwner {
}
// @dev end of airdrop functions
// @dev start of only owner functions
function mintReserve(uint256 _count, address _to) public onlyOwner {
}
function setMaxSale(uint256 currentMaxSale_) external onlyOwner {
}
function setMaxTokenSupply(uint256 maxTokenSupply_) external onlyOwner {
}
function setPrice(uint256 priceInWei) external onlyOwner {
}
function setMaxMintPerWallet(uint256 maxMintPerWallet_) external onlyOwner {
}
function setMaxMintPerTx(uint256 maxMintPerTx_) external onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function toggleSale() public onlyOwner {
}
function toggleWhitelist() public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
// @dev end of only owner functions
}
| totalSupply()<=maxTokenSupply,"RealHulk: Sale ended" | 114,819 | totalSupply()<=maxTokenSupply |
"RealHulk: Max limit" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract RealHulk is ERC721A, ERC721AQueryable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
struct Drop {
address to;
uint256 amount;
}
address public constant DEV_ADDRESS = 0xEF3cC765Aa63E46972df661d8C51DEc60e79AAd2;
uint256 public maxTokenSupply;
string public baseTokenURI;
bytes32 public merkleRoot;
bool public saleEnabled;
bool public whitelistEnabled;
uint256 public currentPrice;
uint256 public currentMaxSale;
uint256 public maxMintPerTx;
uint256 public maxMintPerWallet;
mapping(address => uint256) public mintCount;
mapping(address => bool) private presaleListClaimed;
constructor(string memory baseURI) ERC721A("The Real Hulk", "HULK") {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier saleIsOpen() {
}
function mint(
uint256 _count,
uint256 _presaleMaxAmount,
bytes32[] calldata _merkleProof
) public payable saleIsOpen {
uint256 total = totalSupply();
require(total <= maxTokenSupply, "RealHulk: Max limit");
require(<FILL_ME>)
require(total + _count <= currentMaxSale, "RealHulk: Max sale limit");
require(mintCount[msg.sender] + _count <= maxMintPerWallet, "RealHulk: Max wallet limit");
require(_count <= maxMintPerTx, "RealHulk: Max mint for tx limit");
require(saleEnabled, "RealHulk: Sale is not active");
require(msg.value >= getPrice(_count), "RealHulk: Value below price");
if (whitelistEnabled == true) {
require(merkleRoot != 0x0, "RealHulk: merkle root not set");
// Verify if the account has already claimed
require(
!isPresaleListClaimed(msg.sender),
"RealHulk: account already claimed"
);
// Verify we cannot claim more than the max amount
require(
_count <= _presaleMaxAmount,
"RealHulk: can only claim less than or equal to the max amount"
);
// Verify the merkle proof.
require(
validClaim(msg.sender, _presaleMaxAmount, _merkleProof),
"RealHulk: invalid proof"
);
presaleListClaimed[msg.sender] = true;
}
_mintElements(msg.sender, _count, true);
}
// @dev start of public/external views
function isPresaleListClaimed(address account) public view returns (bool) {
}
function validClaim(
address claimer,
uint256 maxAmount,
bytes32[] calldata merkleProof
) public view returns (bool) {
}
function getPrice(uint256 _count) public view returns (uint256) {
}
function saleActive() external view returns (bool) {
}
// @dev end of public/external views
// @dev start of internal/private functions
function _mintElements(address _to, uint256 _amount, bool increaseCount) private {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _payout(address _address, uint256 _amount) private {
}
// @dev end of internal/private functions
// @dev start of airdrop functions
function airdrop(Drop[] calldata drops) public onlyOwner {
}
// @dev end of airdrop functions
// @dev start of only owner functions
function mintReserve(uint256 _count, address _to) public onlyOwner {
}
function setMaxSale(uint256 currentMaxSale_) external onlyOwner {
}
function setMaxTokenSupply(uint256 maxTokenSupply_) external onlyOwner {
}
function setPrice(uint256 priceInWei) external onlyOwner {
}
function setMaxMintPerWallet(uint256 maxMintPerWallet_) external onlyOwner {
}
function setMaxMintPerTx(uint256 maxMintPerTx_) external onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function toggleSale() public onlyOwner {
}
function toggleWhitelist() public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
// @dev end of only owner functions
}
| total+_count<=maxTokenSupply,"RealHulk: Max limit" | 114,819 | total+_count<=maxTokenSupply |
"RealHulk: Max sale limit" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract RealHulk is ERC721A, ERC721AQueryable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
struct Drop {
address to;
uint256 amount;
}
address public constant DEV_ADDRESS = 0xEF3cC765Aa63E46972df661d8C51DEc60e79AAd2;
uint256 public maxTokenSupply;
string public baseTokenURI;
bytes32 public merkleRoot;
bool public saleEnabled;
bool public whitelistEnabled;
uint256 public currentPrice;
uint256 public currentMaxSale;
uint256 public maxMintPerTx;
uint256 public maxMintPerWallet;
mapping(address => uint256) public mintCount;
mapping(address => bool) private presaleListClaimed;
constructor(string memory baseURI) ERC721A("The Real Hulk", "HULK") {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier saleIsOpen() {
}
function mint(
uint256 _count,
uint256 _presaleMaxAmount,
bytes32[] calldata _merkleProof
) public payable saleIsOpen {
uint256 total = totalSupply();
require(total <= maxTokenSupply, "RealHulk: Max limit");
require(total + _count <= maxTokenSupply, "RealHulk: Max limit");
require(<FILL_ME>)
require(mintCount[msg.sender] + _count <= maxMintPerWallet, "RealHulk: Max wallet limit");
require(_count <= maxMintPerTx, "RealHulk: Max mint for tx limit");
require(saleEnabled, "RealHulk: Sale is not active");
require(msg.value >= getPrice(_count), "RealHulk: Value below price");
if (whitelistEnabled == true) {
require(merkleRoot != 0x0, "RealHulk: merkle root not set");
// Verify if the account has already claimed
require(
!isPresaleListClaimed(msg.sender),
"RealHulk: account already claimed"
);
// Verify we cannot claim more than the max amount
require(
_count <= _presaleMaxAmount,
"RealHulk: can only claim less than or equal to the max amount"
);
// Verify the merkle proof.
require(
validClaim(msg.sender, _presaleMaxAmount, _merkleProof),
"RealHulk: invalid proof"
);
presaleListClaimed[msg.sender] = true;
}
_mintElements(msg.sender, _count, true);
}
// @dev start of public/external views
function isPresaleListClaimed(address account) public view returns (bool) {
}
function validClaim(
address claimer,
uint256 maxAmount,
bytes32[] calldata merkleProof
) public view returns (bool) {
}
function getPrice(uint256 _count) public view returns (uint256) {
}
function saleActive() external view returns (bool) {
}
// @dev end of public/external views
// @dev start of internal/private functions
function _mintElements(address _to, uint256 _amount, bool increaseCount) private {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _payout(address _address, uint256 _amount) private {
}
// @dev end of internal/private functions
// @dev start of airdrop functions
function airdrop(Drop[] calldata drops) public onlyOwner {
}
// @dev end of airdrop functions
// @dev start of only owner functions
function mintReserve(uint256 _count, address _to) public onlyOwner {
}
function setMaxSale(uint256 currentMaxSale_) external onlyOwner {
}
function setMaxTokenSupply(uint256 maxTokenSupply_) external onlyOwner {
}
function setPrice(uint256 priceInWei) external onlyOwner {
}
function setMaxMintPerWallet(uint256 maxMintPerWallet_) external onlyOwner {
}
function setMaxMintPerTx(uint256 maxMintPerTx_) external onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function toggleSale() public onlyOwner {
}
function toggleWhitelist() public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
// @dev end of only owner functions
}
| total+_count<=currentMaxSale,"RealHulk: Max sale limit" | 114,819 | total+_count<=currentMaxSale |
"RealHulk: Max wallet limit" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract RealHulk is ERC721A, ERC721AQueryable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
struct Drop {
address to;
uint256 amount;
}
address public constant DEV_ADDRESS = 0xEF3cC765Aa63E46972df661d8C51DEc60e79AAd2;
uint256 public maxTokenSupply;
string public baseTokenURI;
bytes32 public merkleRoot;
bool public saleEnabled;
bool public whitelistEnabled;
uint256 public currentPrice;
uint256 public currentMaxSale;
uint256 public maxMintPerTx;
uint256 public maxMintPerWallet;
mapping(address => uint256) public mintCount;
mapping(address => bool) private presaleListClaimed;
constructor(string memory baseURI) ERC721A("The Real Hulk", "HULK") {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier saleIsOpen() {
}
function mint(
uint256 _count,
uint256 _presaleMaxAmount,
bytes32[] calldata _merkleProof
) public payable saleIsOpen {
uint256 total = totalSupply();
require(total <= maxTokenSupply, "RealHulk: Max limit");
require(total + _count <= maxTokenSupply, "RealHulk: Max limit");
require(total + _count <= currentMaxSale, "RealHulk: Max sale limit");
require(<FILL_ME>)
require(_count <= maxMintPerTx, "RealHulk: Max mint for tx limit");
require(saleEnabled, "RealHulk: Sale is not active");
require(msg.value >= getPrice(_count), "RealHulk: Value below price");
if (whitelistEnabled == true) {
require(merkleRoot != 0x0, "RealHulk: merkle root not set");
// Verify if the account has already claimed
require(
!isPresaleListClaimed(msg.sender),
"RealHulk: account already claimed"
);
// Verify we cannot claim more than the max amount
require(
_count <= _presaleMaxAmount,
"RealHulk: can only claim less than or equal to the max amount"
);
// Verify the merkle proof.
require(
validClaim(msg.sender, _presaleMaxAmount, _merkleProof),
"RealHulk: invalid proof"
);
presaleListClaimed[msg.sender] = true;
}
_mintElements(msg.sender, _count, true);
}
// @dev start of public/external views
function isPresaleListClaimed(address account) public view returns (bool) {
}
function validClaim(
address claimer,
uint256 maxAmount,
bytes32[] calldata merkleProof
) public view returns (bool) {
}
function getPrice(uint256 _count) public view returns (uint256) {
}
function saleActive() external view returns (bool) {
}
// @dev end of public/external views
// @dev start of internal/private functions
function _mintElements(address _to, uint256 _amount, bool increaseCount) private {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _payout(address _address, uint256 _amount) private {
}
// @dev end of internal/private functions
// @dev start of airdrop functions
function airdrop(Drop[] calldata drops) public onlyOwner {
}
// @dev end of airdrop functions
// @dev start of only owner functions
function mintReserve(uint256 _count, address _to) public onlyOwner {
}
function setMaxSale(uint256 currentMaxSale_) external onlyOwner {
}
function setMaxTokenSupply(uint256 maxTokenSupply_) external onlyOwner {
}
function setPrice(uint256 priceInWei) external onlyOwner {
}
function setMaxMintPerWallet(uint256 maxMintPerWallet_) external onlyOwner {
}
function setMaxMintPerTx(uint256 maxMintPerTx_) external onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function toggleSale() public onlyOwner {
}
function toggleWhitelist() public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
// @dev end of only owner functions
}
| mintCount[msg.sender]+_count<=maxMintPerWallet,"RealHulk: Max wallet limit" | 114,819 | mintCount[msg.sender]+_count<=maxMintPerWallet |
"RealHulk: account already claimed" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract RealHulk is ERC721A, ERC721AQueryable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
struct Drop {
address to;
uint256 amount;
}
address public constant DEV_ADDRESS = 0xEF3cC765Aa63E46972df661d8C51DEc60e79AAd2;
uint256 public maxTokenSupply;
string public baseTokenURI;
bytes32 public merkleRoot;
bool public saleEnabled;
bool public whitelistEnabled;
uint256 public currentPrice;
uint256 public currentMaxSale;
uint256 public maxMintPerTx;
uint256 public maxMintPerWallet;
mapping(address => uint256) public mintCount;
mapping(address => bool) private presaleListClaimed;
constructor(string memory baseURI) ERC721A("The Real Hulk", "HULK") {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier saleIsOpen() {
}
function mint(
uint256 _count,
uint256 _presaleMaxAmount,
bytes32[] calldata _merkleProof
) public payable saleIsOpen {
uint256 total = totalSupply();
require(total <= maxTokenSupply, "RealHulk: Max limit");
require(total + _count <= maxTokenSupply, "RealHulk: Max limit");
require(total + _count <= currentMaxSale, "RealHulk: Max sale limit");
require(mintCount[msg.sender] + _count <= maxMintPerWallet, "RealHulk: Max wallet limit");
require(_count <= maxMintPerTx, "RealHulk: Max mint for tx limit");
require(saleEnabled, "RealHulk: Sale is not active");
require(msg.value >= getPrice(_count), "RealHulk: Value below price");
if (whitelistEnabled == true) {
require(merkleRoot != 0x0, "RealHulk: merkle root not set");
// Verify if the account has already claimed
require(<FILL_ME>)
// Verify we cannot claim more than the max amount
require(
_count <= _presaleMaxAmount,
"RealHulk: can only claim less than or equal to the max amount"
);
// Verify the merkle proof.
require(
validClaim(msg.sender, _presaleMaxAmount, _merkleProof),
"RealHulk: invalid proof"
);
presaleListClaimed[msg.sender] = true;
}
_mintElements(msg.sender, _count, true);
}
// @dev start of public/external views
function isPresaleListClaimed(address account) public view returns (bool) {
}
function validClaim(
address claimer,
uint256 maxAmount,
bytes32[] calldata merkleProof
) public view returns (bool) {
}
function getPrice(uint256 _count) public view returns (uint256) {
}
function saleActive() external view returns (bool) {
}
// @dev end of public/external views
// @dev start of internal/private functions
function _mintElements(address _to, uint256 _amount, bool increaseCount) private {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _payout(address _address, uint256 _amount) private {
}
// @dev end of internal/private functions
// @dev start of airdrop functions
function airdrop(Drop[] calldata drops) public onlyOwner {
}
// @dev end of airdrop functions
// @dev start of only owner functions
function mintReserve(uint256 _count, address _to) public onlyOwner {
}
function setMaxSale(uint256 currentMaxSale_) external onlyOwner {
}
function setMaxTokenSupply(uint256 maxTokenSupply_) external onlyOwner {
}
function setPrice(uint256 priceInWei) external onlyOwner {
}
function setMaxMintPerWallet(uint256 maxMintPerWallet_) external onlyOwner {
}
function setMaxMintPerTx(uint256 maxMintPerTx_) external onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function toggleSale() public onlyOwner {
}
function toggleWhitelist() public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
// @dev end of only owner functions
}
| !isPresaleListClaimed(msg.sender),"RealHulk: account already claimed" | 114,819 | !isPresaleListClaimed(msg.sender) |
"RealHulk: invalid proof" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract RealHulk is ERC721A, ERC721AQueryable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
struct Drop {
address to;
uint256 amount;
}
address public constant DEV_ADDRESS = 0xEF3cC765Aa63E46972df661d8C51DEc60e79AAd2;
uint256 public maxTokenSupply;
string public baseTokenURI;
bytes32 public merkleRoot;
bool public saleEnabled;
bool public whitelistEnabled;
uint256 public currentPrice;
uint256 public currentMaxSale;
uint256 public maxMintPerTx;
uint256 public maxMintPerWallet;
mapping(address => uint256) public mintCount;
mapping(address => bool) private presaleListClaimed;
constructor(string memory baseURI) ERC721A("The Real Hulk", "HULK") {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier saleIsOpen() {
}
function mint(
uint256 _count,
uint256 _presaleMaxAmount,
bytes32[] calldata _merkleProof
) public payable saleIsOpen {
uint256 total = totalSupply();
require(total <= maxTokenSupply, "RealHulk: Max limit");
require(total + _count <= maxTokenSupply, "RealHulk: Max limit");
require(total + _count <= currentMaxSale, "RealHulk: Max sale limit");
require(mintCount[msg.sender] + _count <= maxMintPerWallet, "RealHulk: Max wallet limit");
require(_count <= maxMintPerTx, "RealHulk: Max mint for tx limit");
require(saleEnabled, "RealHulk: Sale is not active");
require(msg.value >= getPrice(_count), "RealHulk: Value below price");
if (whitelistEnabled == true) {
require(merkleRoot != 0x0, "RealHulk: merkle root not set");
// Verify if the account has already claimed
require(
!isPresaleListClaimed(msg.sender),
"RealHulk: account already claimed"
);
// Verify we cannot claim more than the max amount
require(
_count <= _presaleMaxAmount,
"RealHulk: can only claim less than or equal to the max amount"
);
// Verify the merkle proof.
require(<FILL_ME>)
presaleListClaimed[msg.sender] = true;
}
_mintElements(msg.sender, _count, true);
}
// @dev start of public/external views
function isPresaleListClaimed(address account) public view returns (bool) {
}
function validClaim(
address claimer,
uint256 maxAmount,
bytes32[] calldata merkleProof
) public view returns (bool) {
}
function getPrice(uint256 _count) public view returns (uint256) {
}
function saleActive() external view returns (bool) {
}
// @dev end of public/external views
// @dev start of internal/private functions
function _mintElements(address _to, uint256 _amount, bool increaseCount) private {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _payout(address _address, uint256 _amount) private {
}
// @dev end of internal/private functions
// @dev start of airdrop functions
function airdrop(Drop[] calldata drops) public onlyOwner {
}
// @dev end of airdrop functions
// @dev start of only owner functions
function mintReserve(uint256 _count, address _to) public onlyOwner {
}
function setMaxSale(uint256 currentMaxSale_) external onlyOwner {
}
function setMaxTokenSupply(uint256 maxTokenSupply_) external onlyOwner {
}
function setPrice(uint256 priceInWei) external onlyOwner {
}
function setMaxMintPerWallet(uint256 maxMintPerWallet_) external onlyOwner {
}
function setMaxMintPerTx(uint256 maxMintPerTx_) external onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function toggleSale() public onlyOwner {
}
function toggleWhitelist() public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
// @dev end of only owner functions
}
| validClaim(msg.sender,_presaleMaxAmount,_merkleProof),"RealHulk: invalid proof" | 114,819 | validClaim(msg.sender,_presaleMaxAmount,_merkleProof) |
"Token transfer failed!" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// A new paradigm.
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract LinqBasicLpStaking is Ownable, ReentrancyGuard {
using SafeMath for uint256;
IERC20 public lpToken;
uint256 public lockPeriod = 20160 minutes; // 20160 minutes
uint256 public lock_var = 20160; // 14
uint256 public rewardPerBlock = 1e18;
uint256 public blockPerMinutes = 4; // 4
uint256 public AverageBlockTime = 13; // 13
bool public EmergencyFeeWaive = false;
bool public Deposit_enabled = false; // false
struct Stake {
uint256 stakedAmount;
uint256 stakeTime;
uint256 unstakeTime;
uint256 startBlock;
uint256 lastClaimedBlock;
uint256 claimedRewards;
}
struct UserInfo {
Stake[] stakes;
}
mapping(address => UserInfo) private userInfo;
event Staked(address indexed user, uint256 amount,uint256 startTime, uint256 endTime);
event RewardWithdrawn(address indexed user, uint256 reward);
event Unstaked(address indexed user, uint256 reward,uint256 unstakeAmount );
constructor(IERC20 _rewardToken) {
}
function SetAverageBlockTimeAndTimeVar(uint256 _newTime, uint256 _time) external onlyOwner {
}
function enableDeposits(bool state) public onlyOwner {
}
function stake(uint256 _tokenAmount) external nonReentrant {
require(Deposit_enabled == true, "Deposits need to be enabled");
require(_tokenAmount > 0, "Staking amount must be greater than 0!");
uint256 _stakeTime = block.timestamp;
uint256 _unstakeTime = _stakeTime.add(lockPeriod);
userInfo[msg.sender].stakes.push(Stake({
stakedAmount: _tokenAmount,
stakeTime: _stakeTime,
unstakeTime : _unstakeTime,
startBlock : block.number,
lastClaimedBlock: block.number,
claimedRewards: 0
}));
require(<FILL_ME>)
emit Staked(msg.sender, _tokenAmount, _stakeTime, _unstakeTime);
}
function unstake() external {
}
function calculatePercentage(address user) public view returns(uint256) {
}
function getUserRewardForBlock(address user) public view returns (uint256) {
}
function withdrawReward() public {
}
function calculateRewardForStake(address user, uint256 stakeIndex) public view returns (uint256) {
}
function calculateRewardSinceLastClaim(address user) public view returns (uint256) {
}
function checkRemainingTimeAndBlocks(address user) public view returns(uint256[] memory remainingTimes, uint256[] memory remainingBlocks){
}
function checkRemainingTime(address user) external view returns(uint256[] memory){
}
function getAllStakeDetails(address _user) external view returns (uint256[] memory stakeIndices, Stake[] memory stakes) {
}
function getCurrentBlock() public view returns(uint256) {
}
function getLpDepositsForUser(address account)
public
view
returns (uint256)
{
}
function EmergencyMeasures(bool state) public onlyOwner {
}
function updateRewards(uint256 _rewardperBlock) external onlyOwner {
}
function updatelockPeriod(uint256 newLockPeriodInMinutes)
external
onlyOwner
{
}
function updateBlockPerMinutes(uint256 _blockPerMinute) external onlyOwner {
}
function emergencyWithdrawLpTokens() external onlyOwner {
}
function CheckBalance() public view returns(uint256){
}
function withdrawETH() external onlyOwner {
}
receive() external payable {}
}
| lpToken.transferFrom(msg.sender,address(this),_tokenAmount),"Token transfer failed!" | 114,837 | lpToken.transferFrom(msg.sender,address(this),_tokenAmount) |
"Failed to transfer LP tokens." | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// A new paradigm.
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract LinqBasicLpStaking is Ownable, ReentrancyGuard {
using SafeMath for uint256;
IERC20 public lpToken;
uint256 public lockPeriod = 20160 minutes; // 20160 minutes
uint256 public lock_var = 20160; // 14
uint256 public rewardPerBlock = 1e18;
uint256 public blockPerMinutes = 4; // 4
uint256 public AverageBlockTime = 13; // 13
bool public EmergencyFeeWaive = false;
bool public Deposit_enabled = false; // false
struct Stake {
uint256 stakedAmount;
uint256 stakeTime;
uint256 unstakeTime;
uint256 startBlock;
uint256 lastClaimedBlock;
uint256 claimedRewards;
}
struct UserInfo {
Stake[] stakes;
}
mapping(address => UserInfo) private userInfo;
event Staked(address indexed user, uint256 amount,uint256 startTime, uint256 endTime);
event RewardWithdrawn(address indexed user, uint256 reward);
event Unstaked(address indexed user, uint256 reward,uint256 unstakeAmount );
constructor(IERC20 _rewardToken) {
}
function SetAverageBlockTimeAndTimeVar(uint256 _newTime, uint256 _time) external onlyOwner {
}
function enableDeposits(bool state) public onlyOwner {
}
function stake(uint256 _tokenAmount) external nonReentrant {
}
function unstake() external {
UserInfo storage user = userInfo[msg.sender];
uint256 totalUnstakeAmount = 0;
uint256 totalReward = 0;
// Store indexes of stakes that need to be removed
uint256[] memory toRemoveIndexes = new uint256[](user.stakes.length);
uint256 removeCount = 0;
for (uint256 i = 0; i < user.stakes.length; i++) {
if (block.timestamp >= user.stakes[i].stakeTime.add(lockPeriod)) {
uint256 stakeReward = calculateRewardForStake(msg.sender, i);
totalReward = totalReward.add(stakeReward);
totalUnstakeAmount = totalUnstakeAmount.add(user.stakes[i].stakedAmount);
if (stakeReward > 0 && !EmergencyFeeWaive) {
withdrawReward();
}
toRemoveIndexes[removeCount] = i;
removeCount++;
}
}
require(removeCount > 0, "Lock time not completed yet.");
for (uint256 j = removeCount; j > 0; j--) {
if (toRemoveIndexes[j - 1] != user.stakes.length - 1) {
user.stakes[toRemoveIndexes[j - 1]] = user.stakes[user.stakes.length - 1];
}
user.stakes.pop();
}
require(<FILL_ME>)
emit Unstaked(msg.sender, totalReward, totalUnstakeAmount);
}
function calculatePercentage(address user) public view returns(uint256) {
}
function getUserRewardForBlock(address user) public view returns (uint256) {
}
function withdrawReward() public {
}
function calculateRewardForStake(address user, uint256 stakeIndex) public view returns (uint256) {
}
function calculateRewardSinceLastClaim(address user) public view returns (uint256) {
}
function checkRemainingTimeAndBlocks(address user) public view returns(uint256[] memory remainingTimes, uint256[] memory remainingBlocks){
}
function checkRemainingTime(address user) external view returns(uint256[] memory){
}
function getAllStakeDetails(address _user) external view returns (uint256[] memory stakeIndices, Stake[] memory stakes) {
}
function getCurrentBlock() public view returns(uint256) {
}
function getLpDepositsForUser(address account)
public
view
returns (uint256)
{
}
function EmergencyMeasures(bool state) public onlyOwner {
}
function updateRewards(uint256 _rewardperBlock) external onlyOwner {
}
function updatelockPeriod(uint256 newLockPeriodInMinutes)
external
onlyOwner
{
}
function updateBlockPerMinutes(uint256 _blockPerMinute) external onlyOwner {
}
function emergencyWithdrawLpTokens() external onlyOwner {
}
function CheckBalance() public view returns(uint256){
}
function withdrawETH() external onlyOwner {
}
receive() external payable {}
}
| lpToken.transfer(msg.sender,totalUnstakeAmount),"Failed to transfer LP tokens." | 114,837 | lpToken.transfer(msg.sender,totalUnstakeAmount) |
"insufficient ETH Balance!" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// A new paradigm.
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract LinqBasicLpStaking is Ownable, ReentrancyGuard {
using SafeMath for uint256;
IERC20 public lpToken;
uint256 public lockPeriod = 20160 minutes; // 20160 minutes
uint256 public lock_var = 20160; // 14
uint256 public rewardPerBlock = 1e18;
uint256 public blockPerMinutes = 4; // 4
uint256 public AverageBlockTime = 13; // 13
bool public EmergencyFeeWaive = false;
bool public Deposit_enabled = false; // false
struct Stake {
uint256 stakedAmount;
uint256 stakeTime;
uint256 unstakeTime;
uint256 startBlock;
uint256 lastClaimedBlock;
uint256 claimedRewards;
}
struct UserInfo {
Stake[] stakes;
}
mapping(address => UserInfo) private userInfo;
event Staked(address indexed user, uint256 amount,uint256 startTime, uint256 endTime);
event RewardWithdrawn(address indexed user, uint256 reward);
event Unstaked(address indexed user, uint256 reward,uint256 unstakeAmount );
constructor(IERC20 _rewardToken) {
}
function SetAverageBlockTimeAndTimeVar(uint256 _newTime, uint256 _time) external onlyOwner {
}
function enableDeposits(bool state) public onlyOwner {
}
function stake(uint256 _tokenAmount) external nonReentrant {
}
function unstake() external {
}
function calculatePercentage(address user) public view returns(uint256) {
}
function getUserRewardForBlock(address user) public view returns (uint256) {
}
function withdrawReward() public {
require(msg.sender == tx.origin, "invalid caller!");
UserInfo storage user = userInfo[msg.sender];
uint256 totalRewards = 0;
for (uint256 i = 0; i < user.stakes.length; i++) {
Stake storage stakeInfo = user.stakes[i];
uint256 reward = calculateRewardForStake(msg.sender, i);
totalRewards = totalRewards.add(reward);
if (reward > 0) {
stakeInfo.lastClaimedBlock = block.number;
stakeInfo.claimedRewards = stakeInfo.claimedRewards.add(reward);
}
}
require(totalRewards > 0, "No rewards to withdraw");
require(<FILL_ME>)
payable(msg.sender).transfer(totalRewards);
emit RewardWithdrawn(msg.sender, totalRewards);
}
function calculateRewardForStake(address user, uint256 stakeIndex) public view returns (uint256) {
}
function calculateRewardSinceLastClaim(address user) public view returns (uint256) {
}
function checkRemainingTimeAndBlocks(address user) public view returns(uint256[] memory remainingTimes, uint256[] memory remainingBlocks){
}
function checkRemainingTime(address user) external view returns(uint256[] memory){
}
function getAllStakeDetails(address _user) external view returns (uint256[] memory stakeIndices, Stake[] memory stakes) {
}
function getCurrentBlock() public view returns(uint256) {
}
function getLpDepositsForUser(address account)
public
view
returns (uint256)
{
}
function EmergencyMeasures(bool state) public onlyOwner {
}
function updateRewards(uint256 _rewardperBlock) external onlyOwner {
}
function updatelockPeriod(uint256 newLockPeriodInMinutes)
external
onlyOwner
{
}
function updateBlockPerMinutes(uint256 _blockPerMinute) external onlyOwner {
}
function emergencyWithdrawLpTokens() external onlyOwner {
}
function CheckBalance() public view returns(uint256){
}
function withdrawETH() external onlyOwner {
}
receive() external payable {}
}
| address(this).balance>=totalRewards,"insufficient ETH Balance!" | 114,837 | address(this).balance>=totalRewards |
Errors.R_RESERVED_OWNER | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "../interfaces/IFeeManager.sol";
import "../libraries/Errors.sol";
contract FeeManager is AccessControl, Ownable, IFeeManager {
mapping(bytes32 => mapping(uint256 => FeeConfig)) private _appFees;
mapping(bytes32 => bool) private _appOwners;
bytes32 public immutable DEFAULT_APP_ID; // used for bare minimums
bytes32 public constant RESERVE_ROLE = keccak256("RESERVE_ROLE");
constructor() {
}
modifier onlyAppOwner(bytes32 _appId) {
require(<FILL_ME>)
_;
}
function getAppOwnerKey(bytes32 _appId) public view returns (bytes32) {
}
function updateDefaultFee(
uint256 _chainId,
uint256 _baseFee,
uint256 _feePerByte
) external override onlyOwner {
}
function updateFee(
bytes32 _appId,
uint256 _chainId,
uint256 _baseFee,
uint256 _feePerByte
) external override onlyAppOwner(_appId) {
}
function reserveFee(
bytes32 _appId,
uint256 _chainId,
uint256 _baseFee,
uint256 _feePerByte
) public override onlyRole(RESERVE_ROLE) {
}
function _reserveFee(
bytes32 _appId,
uint256 _chainId,
uint256 _baseFee,
uint256 _feePerByte
) internal {
}
function reserveFeeBatch(
bytes32 _appId,
uint256[] calldata _chainIds,
uint256[] calldata _baseFees,
uint256[] calldata _feesPerByte
) external override {
}
function getFees(
bytes32 _appId,
uint256 _chainId,
uint256 _dataLength
) external view override returns (uint256) {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override returns (bool) {
}
}
| _appOwners[getAppOwnerKey(_appId)],Errors.R_RESERVED_OWNER | 114,884 | _appOwners[getAppOwnerKey(_appId)] |
Errors.R_RESERVED_OWNER | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "../interfaces/IFeeManager.sol";
import "../libraries/Errors.sol";
contract FeeManager is AccessControl, Ownable, IFeeManager {
mapping(bytes32 => mapping(uint256 => FeeConfig)) private _appFees;
mapping(bytes32 => bool) private _appOwners;
bytes32 public immutable DEFAULT_APP_ID; // used for bare minimums
bytes32 public constant RESERVE_ROLE = keccak256("RESERVE_ROLE");
constructor() {
}
modifier onlyAppOwner(bytes32 _appId) {
}
function getAppOwnerKey(bytes32 _appId) public view returns (bytes32) {
}
function updateDefaultFee(
uint256 _chainId,
uint256 _baseFee,
uint256 _feePerByte
) external override onlyOwner {
}
function updateFee(
bytes32 _appId,
uint256 _chainId,
uint256 _baseFee,
uint256 _feePerByte
) external override onlyAppOwner(_appId) {
}
function reserveFee(
bytes32 _appId,
uint256 _chainId,
uint256 _baseFee,
uint256 _feePerByte
) public override onlyRole(RESERVE_ROLE) {
require(_appId != DEFAULT_APP_ID, Errors.R_RESERVED_ENTITY);
bytes32 key = getAppOwnerKey(_appId);
require(<FILL_ME>)
_appOwners[key] = true;
_reserveFee(_appId, _chainId, _baseFee, _feePerByte);
}
function _reserveFee(
bytes32 _appId,
uint256 _chainId,
uint256 _baseFee,
uint256 _feePerByte
) internal {
}
function reserveFeeBatch(
bytes32 _appId,
uint256[] calldata _chainIds,
uint256[] calldata _baseFees,
uint256[] calldata _feesPerByte
) external override {
}
function getFees(
bytes32 _appId,
uint256 _chainId,
uint256 _dataLength
) external view override returns (uint256) {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override returns (bool) {
}
}
| !_appOwners[key],Errors.R_RESERVED_OWNER | 114,884 | !_appOwners[key] |
"Sender is blacklisted" | /*
For all you political experts out there that already know a midterm rally is about to happen!
Max tx: 1%
Max wallet: 2%
Taxes: 5/5 (no jeet tax because we all believe in a midterm rally)
twitter.com/MidtermRally
https://t.me/+6G3MxwXFvjcxOTdl
Website soon.
- Your political expert
*/
pragma solidity 0.8.7;
contract Rally is ERC20, Ownable {
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public rallyWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
uint256 public percentForLPBurn = 25; // 25 = .25%
bool public lpBurnEnabled = false;
uint256 public lpBurnFrequency = 3600 seconds;
uint256 public lastLpBurnTime;
uint256 public manualBurnFrequency = 30 minutes;
uint256 public lastManualLpBurnTime;
bool public limitsInEffect = true;
// enable these after minting by calling {enableTrading}
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
// blacklist
mapping(address => bool) private blacklist; // to hold last Transfers temporarily during launch
uint256 public buyTotalFees;
uint256 public buyRallyFee;
uint256 public buyLiquidityFee;
uint256 public sellTotalFees;
uint256 public sellRallyFee;
uint256 public sellLiquidityFee;
uint256 public tokensForRally;
uint256 public tokensForLiquidity;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event rallyWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event AutoNukeLP();
event ManualNukeLP();
constructor() ERC20("Midterm Rally", "RALLY") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function updateBuyFees(uint256 _rallyFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function updateSellFees(uint256 _rallyFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateRallyWallet(address newRallyWallet) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
event BoughtEarly(address indexed sniper);
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(<FILL_ME>)
require(blacklist[to] != true, "Receiver is blacklisted");
// transfer 0 left
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (limitsInEffect) {
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
) {
if (!tradingActive) {
require(
_isExcludedFromFees[from] || _isExcludedFromFees[to],
"Trading is not active."
);
}
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled) {
if (
to != owner() &&
to != address(uniswapV2Router) &&
to != address(uniswapV2Pair)
) {
require(
_holderLastTransferTimestamp[tx.origin] + 1 <
block.number,
"_transfer:: Transfer Delay enabled. Only one purchase per 2 blocks."
);
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
// when buy
if (
automatedMarketMakerPairs[from] &&
!_isExcludedMaxTransactionAmount[to]
) {
require(
amount <= maxTransactionAmount,
"Buy transfer amount exceeds the maxTransactionAmount."
);
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
// when sell
else if (
automatedMarketMakerPairs[to] &&
!_isExcludedMaxTransactionAmount[from]
) {
require(
amount <= maxTransactionAmount,
"Sell transfer amount exceeds the maxTransactionAmount."
);
} else if (!_isExcludedMaxTransactionAmount[to]) {
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
if (
!swapping &&
automatedMarketMakerPairs[to] &&
lpBurnEnabled &&
block.timestamp >= lastLpBurnTime + lpBurnFrequency &&
!_isExcludedFromFees[from]
) {
autoBurnLiquidityPairTokens();
}
bool takeFee = !swapping;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if (takeFee) {
// on sell
if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = (amount * sellTotalFees) / 100;
tokensForLiquidity += (fees * sellLiquidityFee) / sellTotalFees;
tokensForRally += (fees * sellRallyFee) / sellTotalFees;
}
// on buy
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = (amount * buyTotalFees) / 100;
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForRally += (fees * buyRallyFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function setAutoLPBurnSettings(
uint256 _frequencyInSeconds,
uint256 _percent,
bool _Enabled
) external onlyOwner {
}
function autoBurnLiquidityPairTokens() internal returns (bool) {
}
function manualBurnLiquidityPairTokens(uint256 percent)
external
onlyOwner
returns (bool)
{
}
// Note blacklisted can be bool, this is for gas optimization
function setBlacklisted(address _address, bool _blacklisted)
external
onlyOwner
{
}
}
| blacklist[from]!=true,"Sender is blacklisted" | 114,908 | blacklist[from]!=true |
"Receiver is blacklisted" | /*
For all you political experts out there that already know a midterm rally is about to happen!
Max tx: 1%
Max wallet: 2%
Taxes: 5/5 (no jeet tax because we all believe in a midterm rally)
twitter.com/MidtermRally
https://t.me/+6G3MxwXFvjcxOTdl
Website soon.
- Your political expert
*/
pragma solidity 0.8.7;
contract Rally is ERC20, Ownable {
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public rallyWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
uint256 public percentForLPBurn = 25; // 25 = .25%
bool public lpBurnEnabled = false;
uint256 public lpBurnFrequency = 3600 seconds;
uint256 public lastLpBurnTime;
uint256 public manualBurnFrequency = 30 minutes;
uint256 public lastManualLpBurnTime;
bool public limitsInEffect = true;
// enable these after minting by calling {enableTrading}
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
// blacklist
mapping(address => bool) private blacklist; // to hold last Transfers temporarily during launch
uint256 public buyTotalFees;
uint256 public buyRallyFee;
uint256 public buyLiquidityFee;
uint256 public sellTotalFees;
uint256 public sellRallyFee;
uint256 public sellLiquidityFee;
uint256 public tokensForRally;
uint256 public tokensForLiquidity;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event rallyWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event AutoNukeLP();
event ManualNukeLP();
constructor() ERC20("Midterm Rally", "RALLY") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function updateBuyFees(uint256 _rallyFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function updateSellFees(uint256 _rallyFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateRallyWallet(address newRallyWallet) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
event BoughtEarly(address indexed sniper);
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(blacklist[from] != true, "Sender is blacklisted");
require(<FILL_ME>)
// transfer 0 left
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (limitsInEffect) {
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
) {
if (!tradingActive) {
require(
_isExcludedFromFees[from] || _isExcludedFromFees[to],
"Trading is not active."
);
}
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled) {
if (
to != owner() &&
to != address(uniswapV2Router) &&
to != address(uniswapV2Pair)
) {
require(
_holderLastTransferTimestamp[tx.origin] + 1 <
block.number,
"_transfer:: Transfer Delay enabled. Only one purchase per 2 blocks."
);
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
// when buy
if (
automatedMarketMakerPairs[from] &&
!_isExcludedMaxTransactionAmount[to]
) {
require(
amount <= maxTransactionAmount,
"Buy transfer amount exceeds the maxTransactionAmount."
);
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
// when sell
else if (
automatedMarketMakerPairs[to] &&
!_isExcludedMaxTransactionAmount[from]
) {
require(
amount <= maxTransactionAmount,
"Sell transfer amount exceeds the maxTransactionAmount."
);
} else if (!_isExcludedMaxTransactionAmount[to]) {
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
if (
!swapping &&
automatedMarketMakerPairs[to] &&
lpBurnEnabled &&
block.timestamp >= lastLpBurnTime + lpBurnFrequency &&
!_isExcludedFromFees[from]
) {
autoBurnLiquidityPairTokens();
}
bool takeFee = !swapping;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if (takeFee) {
// on sell
if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = (amount * sellTotalFees) / 100;
tokensForLiquidity += (fees * sellLiquidityFee) / sellTotalFees;
tokensForRally += (fees * sellRallyFee) / sellTotalFees;
}
// on buy
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = (amount * buyTotalFees) / 100;
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForRally += (fees * buyRallyFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function setAutoLPBurnSettings(
uint256 _frequencyInSeconds,
uint256 _percent,
bool _Enabled
) external onlyOwner {
}
function autoBurnLiquidityPairTokens() internal returns (bool) {
}
function manualBurnLiquidityPairTokens(uint256 percent)
external
onlyOwner
returns (bool)
{
}
// Note blacklisted can be bool, this is for gas optimization
function setBlacklisted(address _address, bool _blacklisted)
external
onlyOwner
{
}
}
| blacklist[to]!=true,"Receiver is blacklisted" | 114,908 | blacklist[to]!=true |
"_transfer:: Transfer Delay enabled. Only one purchase per 2 blocks." | /*
For all you political experts out there that already know a midterm rally is about to happen!
Max tx: 1%
Max wallet: 2%
Taxes: 5/5 (no jeet tax because we all believe in a midterm rally)
twitter.com/MidtermRally
https://t.me/+6G3MxwXFvjcxOTdl
Website soon.
- Your political expert
*/
pragma solidity 0.8.7;
contract Rally is ERC20, Ownable {
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public rallyWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
uint256 public percentForLPBurn = 25; // 25 = .25%
bool public lpBurnEnabled = false;
uint256 public lpBurnFrequency = 3600 seconds;
uint256 public lastLpBurnTime;
uint256 public manualBurnFrequency = 30 minutes;
uint256 public lastManualLpBurnTime;
bool public limitsInEffect = true;
// enable these after minting by calling {enableTrading}
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
// blacklist
mapping(address => bool) private blacklist; // to hold last Transfers temporarily during launch
uint256 public buyTotalFees;
uint256 public buyRallyFee;
uint256 public buyLiquidityFee;
uint256 public sellTotalFees;
uint256 public sellRallyFee;
uint256 public sellLiquidityFee;
uint256 public tokensForRally;
uint256 public tokensForLiquidity;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event rallyWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event AutoNukeLP();
event ManualNukeLP();
constructor() ERC20("Midterm Rally", "RALLY") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function updateBuyFees(uint256 _rallyFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function updateSellFees(uint256 _rallyFee, uint256 _liquidityFee)
external
onlyOwner
{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateRallyWallet(address newRallyWallet) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
event BoughtEarly(address indexed sniper);
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(blacklist[from] != true, "Sender is blacklisted");
require(blacklist[to] != true, "Receiver is blacklisted");
// transfer 0 left
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (limitsInEffect) {
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
) {
if (!tradingActive) {
require(
_isExcludedFromFees[from] || _isExcludedFromFees[to],
"Trading is not active."
);
}
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled) {
if (
to != owner() &&
to != address(uniswapV2Router) &&
to != address(uniswapV2Pair)
) {
require(<FILL_ME>)
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
// when buy
if (
automatedMarketMakerPairs[from] &&
!_isExcludedMaxTransactionAmount[to]
) {
require(
amount <= maxTransactionAmount,
"Buy transfer amount exceeds the maxTransactionAmount."
);
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
// when sell
else if (
automatedMarketMakerPairs[to] &&
!_isExcludedMaxTransactionAmount[from]
) {
require(
amount <= maxTransactionAmount,
"Sell transfer amount exceeds the maxTransactionAmount."
);
} else if (!_isExcludedMaxTransactionAmount[to]) {
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
if (
!swapping &&
automatedMarketMakerPairs[to] &&
lpBurnEnabled &&
block.timestamp >= lastLpBurnTime + lpBurnFrequency &&
!_isExcludedFromFees[from]
) {
autoBurnLiquidityPairTokens();
}
bool takeFee = !swapping;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if (takeFee) {
// on sell
if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = (amount * sellTotalFees) / 100;
tokensForLiquidity += (fees * sellLiquidityFee) / sellTotalFees;
tokensForRally += (fees * sellRallyFee) / sellTotalFees;
}
// on buy
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = (amount * buyTotalFees) / 100;
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForRally += (fees * buyRallyFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function setAutoLPBurnSettings(
uint256 _frequencyInSeconds,
uint256 _percent,
bool _Enabled
) external onlyOwner {
}
function autoBurnLiquidityPairTokens() internal returns (bool) {
}
function manualBurnLiquidityPairTokens(uint256 percent)
external
onlyOwner
returns (bool)
{
}
// Note blacklisted can be bool, this is for gas optimization
function setBlacklisted(address _address, bool _blacklisted)
external
onlyOwner
{
}
}
| _holderLastTransferTimestamp[tx.origin]+1<block.number,"_transfer:: Transfer Delay enabled. Only one purchase per 2 blocks." | 114,908 | _holderLastTransferTimestamp[tx.origin]+1<block.number |
"NFT contract is not a contract" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./SCOA.sol";
interface ICOA {
function createCertificate(
address to_,
SCOA.Certificate calldata certificate_,
bytes calldata signature_
) external;
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
contract COANFTProxy is Ownable {
using ECDSA for bytes32;
using Address for address;
struct Payment {
uint256 amount;
bytes32 nonce;
bytes signature;
}
mapping(bytes32 => bool) public payments;
ICOA internal _coa;
constructor(address coa_) {
}
function updateCOA(address coa_) external onlyOwner {
}
// we create a new certificate and mint the NFT, sending both to the new owner
/*
* caller can be purchaser or coa creator
*/
function digitalArtCreate(
address to_,
SCOA.Certificate calldata certificate_,
bytes calldata signature_,
address nftContract_,
bytes calldata contractFunctionData_,
Payment calldata payment_
) external payable {
uint256 nftPrice = (msg.value - payment_.amount);
require(<FILL_ME>)
require(contractFunctionData_.length > 0, "NFT contract function data is empty");
_coa.createCertificate(to_, certificate_, signature_);
nftContract_.functionCallWithValue(contractFunctionData_, nftPrice);
bytes32 dataHash = keccak256(
abi.encode(to_, signature_, nftContract_, contractFunctionData_)
);
_payment(payment_, dataHash);
}
// we are transfering certificate and a NFT to the new owner
/*
* caller must be coa creator
*/
function digitalArtTransfer(
address to_,
address certFrom_,
uint256 certificateId_,
address nftContract_,
address nftFrom_,
uint256 nftId_,
Payment calldata payment_
) external payable {
}
// we are transferring certificate to the physical art owner
/*
* caller must be coa creator
*/
function physicalArtTransfer(
address to_,
address certFrom_,
uint256 certificateId_,
Payment calldata payment_
) external payable {
}
function makePayment(
uint256 amount_,
bytes32 nonce_,
bytes calldata signature_
) public pure returns (Payment memory) {
}
function _payment(Payment calldata payment_, bytes32 dataHash_) internal {
}
}
| nftContract_.isContract(),"NFT contract is not a contract" | 115,192 | nftContract_.isContract() |
"Payment already processed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./SCOA.sol";
interface ICOA {
function createCertificate(
address to_,
SCOA.Certificate calldata certificate_,
bytes calldata signature_
) external;
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
contract COANFTProxy is Ownable {
using ECDSA for bytes32;
using Address for address;
struct Payment {
uint256 amount;
bytes32 nonce;
bytes signature;
}
mapping(bytes32 => bool) public payments;
ICOA internal _coa;
constructor(address coa_) {
}
function updateCOA(address coa_) external onlyOwner {
}
// we create a new certificate and mint the NFT, sending both to the new owner
/*
* caller can be purchaser or coa creator
*/
function digitalArtCreate(
address to_,
SCOA.Certificate calldata certificate_,
bytes calldata signature_,
address nftContract_,
bytes calldata contractFunctionData_,
Payment calldata payment_
) external payable {
}
// we are transfering certificate and a NFT to the new owner
/*
* caller must be coa creator
*/
function digitalArtTransfer(
address to_,
address certFrom_,
uint256 certificateId_,
address nftContract_,
address nftFrom_,
uint256 nftId_,
Payment calldata payment_
) external payable {
}
// we are transferring certificate to the physical art owner
/*
* caller must be coa creator
*/
function physicalArtTransfer(
address to_,
address certFrom_,
uint256 certificateId_,
Payment calldata payment_
) external payable {
}
function makePayment(
uint256 amount_,
bytes32 nonce_,
bytes calldata signature_
) public pure returns (Payment memory) {
}
function _payment(Payment calldata payment_, bytes32 dataHash_) internal {
require(payment_.nonce == dataHash_, "Invalid nonce");
address signer = payment_.nonce.toEthSignedMessageHash().recover(payment_.signature);
require(signer == owner(), "Invalid signature");
require(<FILL_ME>)
payments[dataHash_] = true;
require(address(this).balance >= payment_.amount, "Insufficient funds");
(bool success, ) = owner().call{value: address(this).balance}("");
require(success, "Transfer failed.");
}
}
| !payments[dataHash_],"Payment already processed" | 115,192 | !payments[dataHash_] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.