comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"invalid merkle proof" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract CapitalistPigs is ERC721, Ownable {
using Strings for uint256;
enum MintStatus { Closed, Presale, Public }
struct TierInfo {
uint price;
MintStatus mintStatus;
uint minId;
uint nextId;
uint maxId;
}
mapping(uint => TierInfo) tiers;
uint nextTier;
// A counter to allow us to keep fresh presale buyers list for arbitrary future mints.
uint currentPresale;
// currrentPresale => address => hasMinted
mapping(uint => mapping(address => bool)) presaleBuyers;
mapping(uint => bytes32) presaleRoot;
address payable devWallet;
string baseURI;
uint royaltyRate;
uint constant royaltyRateDivisor = 100_000;
address payable royaltyWallet;
constructor (
string memory _baseURI,
address payable _royaltyWallet,
address payable _devWallet
) ERC721("Capitalist Pigs", "PIGS") {
}
// MINTING FUNCTIONS //
function mintPresale(uint _edition, bytes32[] calldata _proof) public payable {
TierInfo storage tier = tiers[_edition];
require(tier.mintStatus == MintStatus.Presale, "presale minting closed");
require(presaleBuyers[currentPresale][msg.sender] == false, 'already minted');
require(<FILL_ME>)
presaleBuyers[currentPresale][msg.sender] = true;
_mintTokens(tier, 1);
}
function mintPublic(uint _edition, uint _quantity) public payable {
}
function _mintTokens(TierInfo storage tier, uint _quantity) internal {
}
function ownerMint(uint _edition, address _to) external onlyOwner {
}
// VIEWS //
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function getTierInfo(uint _edition) public view returns (TierInfo memory) {
}
function isPigInTier(uint _tokenId, uint _edition) public view returns (bool) {
}
function isOwnerInTier(address _owner, uint _tokenId, uint _edition) public view returns (bool) {
}
// CREATE & UPDATE TIERS //
function createNewTier(uint _price, MintStatus _mintStatus, uint _minId, uint _maxId) external onlyOwner {
}
function setTierInfo(uint _edition, MintStatus _status, uint _price, uint _maxId) external onlyOwner {
}
// ADMIN //
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setDevWallet(address payable _devWallet) external onlyOwner {
}
function startNewPresale(bytes32 _root) external onlyOwner {
}
function withdrawEth(address payable _addr) external onlyOwner {
}
function withdrawToken(address token, address _addr) external onlyOwner {
}
// EIP 2981 ROYALTIES //
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) external view returns (address receiver, uint256 royaltyAmount) {
}
function updateRoyaltyRate(uint256 _rate) public onlyOwner {
}
function updateRoyaltyWallet(address payable _wallet) public onlyOwner {
}
}
| MerkleProof.verify(_proof,presaleRoot[currentPresale],keccak256(abi.encodePacked(msg.sender))),"invalid merkle proof" | 199,509 | MerkleProof.verify(_proof,presaleRoot[currentPresale],keccak256(abi.encodePacked(msg.sender))) |
"max id reached" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract CapitalistPigs is ERC721, Ownable {
using Strings for uint256;
enum MintStatus { Closed, Presale, Public }
struct TierInfo {
uint price;
MintStatus mintStatus;
uint minId;
uint nextId;
uint maxId;
}
mapping(uint => TierInfo) tiers;
uint nextTier;
// A counter to allow us to keep fresh presale buyers list for arbitrary future mints.
uint currentPresale;
// currrentPresale => address => hasMinted
mapping(uint => mapping(address => bool)) presaleBuyers;
mapping(uint => bytes32) presaleRoot;
address payable devWallet;
string baseURI;
uint royaltyRate;
uint constant royaltyRateDivisor = 100_000;
address payable royaltyWallet;
constructor (
string memory _baseURI,
address payable _royaltyWallet,
address payable _devWallet
) ERC721("Capitalist Pigs", "PIGS") {
}
// MINTING FUNCTIONS //
function mintPresale(uint _edition, bytes32[] calldata _proof) public payable {
}
function mintPublic(uint _edition, uint _quantity) public payable {
}
function _mintTokens(TierInfo storage tier, uint _quantity) internal {
require(msg.value == _quantity * tier.price, "incorrect value");
require(<FILL_ME>)
for (uint i = 0; i < _quantity; i++) {
_safeMint(msg.sender, tier.nextId++);
}
}
function ownerMint(uint _edition, address _to) external onlyOwner {
}
// VIEWS //
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function getTierInfo(uint _edition) public view returns (TierInfo memory) {
}
function isPigInTier(uint _tokenId, uint _edition) public view returns (bool) {
}
function isOwnerInTier(address _owner, uint _tokenId, uint _edition) public view returns (bool) {
}
// CREATE & UPDATE TIERS //
function createNewTier(uint _price, MintStatus _mintStatus, uint _minId, uint _maxId) external onlyOwner {
}
function setTierInfo(uint _edition, MintStatus _status, uint _price, uint _maxId) external onlyOwner {
}
// ADMIN //
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setDevWallet(address payable _devWallet) external onlyOwner {
}
function startNewPresale(bytes32 _root) external onlyOwner {
}
function withdrawEth(address payable _addr) external onlyOwner {
}
function withdrawToken(address token, address _addr) external onlyOwner {
}
// EIP 2981 ROYALTIES //
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) external view returns (address receiver, uint256 royaltyAmount) {
}
function updateRoyaltyRate(uint256 _rate) public onlyOwner {
}
function updateRoyaltyWallet(address payable _wallet) public onlyOwner {
}
}
| tier.nextId+_quantity-1<=tier.maxId,"max id reached" | 199,509 | tier.nextId+_quantity-1<=tier.maxId |
"minId must be higher than prev tier maxId" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract CapitalistPigs is ERC721, Ownable {
using Strings for uint256;
enum MintStatus { Closed, Presale, Public }
struct TierInfo {
uint price;
MintStatus mintStatus;
uint minId;
uint nextId;
uint maxId;
}
mapping(uint => TierInfo) tiers;
uint nextTier;
// A counter to allow us to keep fresh presale buyers list for arbitrary future mints.
uint currentPresale;
// currrentPresale => address => hasMinted
mapping(uint => mapping(address => bool)) presaleBuyers;
mapping(uint => bytes32) presaleRoot;
address payable devWallet;
string baseURI;
uint royaltyRate;
uint constant royaltyRateDivisor = 100_000;
address payable royaltyWallet;
constructor (
string memory _baseURI,
address payable _royaltyWallet,
address payable _devWallet
) ERC721("Capitalist Pigs", "PIGS") {
}
// MINTING FUNCTIONS //
function mintPresale(uint _edition, bytes32[] calldata _proof) public payable {
}
function mintPublic(uint _edition, uint _quantity) public payable {
}
function _mintTokens(TierInfo storage tier, uint _quantity) internal {
}
function ownerMint(uint _edition, address _to) external onlyOwner {
}
// VIEWS //
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function getTierInfo(uint _edition) public view returns (TierInfo memory) {
}
function isPigInTier(uint _tokenId, uint _edition) public view returns (bool) {
}
function isOwnerInTier(address _owner, uint _tokenId, uint _edition) public view returns (bool) {
}
// CREATE & UPDATE TIERS //
function createNewTier(uint _price, MintStatus _mintStatus, uint _minId, uint _maxId) external onlyOwner {
require(<FILL_ME>)
tiers[nextTier++] = TierInfo({
price: _price,
mintStatus: _mintStatus,
minId: _minId,
nextId: _minId,
maxId: _maxId
});
}
function setTierInfo(uint _edition, MintStatus _status, uint _price, uint _maxId) external onlyOwner {
}
// ADMIN //
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setDevWallet(address payable _devWallet) external onlyOwner {
}
function startNewPresale(bytes32 _root) external onlyOwner {
}
function withdrawEth(address payable _addr) external onlyOwner {
}
function withdrawToken(address token, address _addr) external onlyOwner {
}
// EIP 2981 ROYALTIES //
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) external view returns (address receiver, uint256 royaltyAmount) {
}
function updateRoyaltyRate(uint256 _rate) public onlyOwner {
}
function updateRoyaltyWallet(address payable _wallet) public onlyOwner {
}
}
| tiers[nextTier-1].maxId<_minId,"minId must be higher than prev tier maxId" | 199,509 | tiers[nextTier-1].maxId<_minId |
"overlapping with next tier" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract CapitalistPigs is ERC721, Ownable {
using Strings for uint256;
enum MintStatus { Closed, Presale, Public }
struct TierInfo {
uint price;
MintStatus mintStatus;
uint minId;
uint nextId;
uint maxId;
}
mapping(uint => TierInfo) tiers;
uint nextTier;
// A counter to allow us to keep fresh presale buyers list for arbitrary future mints.
uint currentPresale;
// currrentPresale => address => hasMinted
mapping(uint => mapping(address => bool)) presaleBuyers;
mapping(uint => bytes32) presaleRoot;
address payable devWallet;
string baseURI;
uint royaltyRate;
uint constant royaltyRateDivisor = 100_000;
address payable royaltyWallet;
constructor (
string memory _baseURI,
address payable _royaltyWallet,
address payable _devWallet
) ERC721("Capitalist Pigs", "PIGS") {
}
// MINTING FUNCTIONS //
function mintPresale(uint _edition, bytes32[] calldata _proof) public payable {
}
function mintPublic(uint _edition, uint _quantity) public payable {
}
function _mintTokens(TierInfo storage tier, uint _quantity) internal {
}
function ownerMint(uint _edition, address _to) external onlyOwner {
}
// VIEWS //
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function getTierInfo(uint _edition) public view returns (TierInfo memory) {
}
function isPigInTier(uint _tokenId, uint _edition) public view returns (bool) {
}
function isOwnerInTier(address _owner, uint _tokenId, uint _edition) public view returns (bool) {
}
// CREATE & UPDATE TIERS //
function createNewTier(uint _price, MintStatus _mintStatus, uint _minId, uint _maxId) external onlyOwner {
}
function setTierInfo(uint _edition, MintStatus _status, uint _price, uint _maxId) external onlyOwner {
TierInfo memory oldTierInfo = tiers[_edition];
require(<FILL_ME>)
tiers[_edition] = TierInfo({
price: _price,
mintStatus: _status,
minId: oldTierInfo.minId,
nextId: oldTierInfo.nextId,
maxId: _maxId
});
}
// ADMIN //
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setDevWallet(address payable _devWallet) external onlyOwner {
}
function startNewPresale(bytes32 _root) external onlyOwner {
}
function withdrawEth(address payable _addr) external onlyOwner {
}
function withdrawToken(address token, address _addr) external onlyOwner {
}
// EIP 2981 ROYALTIES //
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) external view returns (address receiver, uint256 royaltyAmount) {
}
function updateRoyaltyRate(uint256 _rate) public onlyOwner {
}
function updateRoyaltyWallet(address payable _wallet) public onlyOwner {
}
}
| tiers[_edition+1].minId==0||_maxId<tiers[_edition+1].minId,"overlapping with next tier" | 199,509 | tiers[_edition+1].minId==0||_maxId<tiers[_edition+1].minId |
"Reached mint limit per TX" | pragma solidity >=0.7.0 <0.9.0;
contract ElefriendsClub is ERC721A, Ownable {
using Strings for uint256;
string baseURI;
string notRevURI;
string public baseExtension = ".json";
uint256 public cost = 0 ether;
uint256 public maxSupply = 5000;
uint256 public maxMintAmountTX = 1;
uint256 public maxMintPerWallet = 1;
uint256 public freeAmount = 500;
bool public paused = false;
bool public revealed = false;
mapping(address => uint256) nftPerWallet;
constructor(
string memory _initBaseURI,
string memory _initNotRevURI
) ERC721A("Elefriends Club", "EC") {
}
modifier checks(uint256 _mintAmount) {
require(!paused);
require(_mintAmount > 0);
require(totalSupply() + _mintAmount <= maxSupply, "Max supply exceeded!");
require(<FILL_ME>)
require(balanceOf(msg.sender) + _mintAmount <= maxMintPerWallet, "Reached mint limit per wallet");
if(totalSupply() >= freeAmount){
if(msg.sender != owner()) require(msg.value >= cost * _mintAmount, "Insufficient funds!");
nftPerWallet[msg.sender]++;
}
else require(totalSupply() + _mintAmount <= freeAmount, "Free NFTs amount exceeded");
require(_mintAmount <= maxMintAmountTX, "Max mint amount exceeded");
_;
}
function mint(uint256 _mintAmount) public payable checks(_mintAmount) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setCost(uint256 _newCost) public onlyOwner {
}
function reveal() public onlyOwner {
}
function setmaxMintPerWallet(uint256 _newmaxMintPerWallet) public onlyOwner {
}
function setmaxMintAmountTX(uint256 _newmaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function pause() public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| nftPerWallet[msg.sender]+_mintAmount<=maxMintAmountTX,"Reached mint limit per TX" | 199,545 | nftPerWallet[msg.sender]+_mintAmount<=maxMintAmountTX |
"Reached mint limit per wallet" | pragma solidity >=0.7.0 <0.9.0;
contract ElefriendsClub is ERC721A, Ownable {
using Strings for uint256;
string baseURI;
string notRevURI;
string public baseExtension = ".json";
uint256 public cost = 0 ether;
uint256 public maxSupply = 5000;
uint256 public maxMintAmountTX = 1;
uint256 public maxMintPerWallet = 1;
uint256 public freeAmount = 500;
bool public paused = false;
bool public revealed = false;
mapping(address => uint256) nftPerWallet;
constructor(
string memory _initBaseURI,
string memory _initNotRevURI
) ERC721A("Elefriends Club", "EC") {
}
modifier checks(uint256 _mintAmount) {
require(!paused);
require(_mintAmount > 0);
require(totalSupply() + _mintAmount <= maxSupply, "Max supply exceeded!");
require(nftPerWallet[msg.sender] + _mintAmount <= maxMintAmountTX, "Reached mint limit per TX");
require(<FILL_ME>)
if(totalSupply() >= freeAmount){
if(msg.sender != owner()) require(msg.value >= cost * _mintAmount, "Insufficient funds!");
nftPerWallet[msg.sender]++;
}
else require(totalSupply() + _mintAmount <= freeAmount, "Free NFTs amount exceeded");
require(_mintAmount <= maxMintAmountTX, "Max mint amount exceeded");
_;
}
function mint(uint256 _mintAmount) public payable checks(_mintAmount) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setCost(uint256 _newCost) public onlyOwner {
}
function reveal() public onlyOwner {
}
function setmaxMintPerWallet(uint256 _newmaxMintPerWallet) public onlyOwner {
}
function setmaxMintAmountTX(uint256 _newmaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function pause() public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| balanceOf(msg.sender)+_mintAmount<=maxMintPerWallet,"Reached mint limit per wallet" | 199,545 | balanceOf(msg.sender)+_mintAmount<=maxMintPerWallet |
"Free NFTs amount exceeded" | pragma solidity >=0.7.0 <0.9.0;
contract ElefriendsClub is ERC721A, Ownable {
using Strings for uint256;
string baseURI;
string notRevURI;
string public baseExtension = ".json";
uint256 public cost = 0 ether;
uint256 public maxSupply = 5000;
uint256 public maxMintAmountTX = 1;
uint256 public maxMintPerWallet = 1;
uint256 public freeAmount = 500;
bool public paused = false;
bool public revealed = false;
mapping(address => uint256) nftPerWallet;
constructor(
string memory _initBaseURI,
string memory _initNotRevURI
) ERC721A("Elefriends Club", "EC") {
}
modifier checks(uint256 _mintAmount) {
require(!paused);
require(_mintAmount > 0);
require(totalSupply() + _mintAmount <= maxSupply, "Max supply exceeded!");
require(nftPerWallet[msg.sender] + _mintAmount <= maxMintAmountTX, "Reached mint limit per TX");
require(balanceOf(msg.sender) + _mintAmount <= maxMintPerWallet, "Reached mint limit per wallet");
if(totalSupply() >= freeAmount){
if(msg.sender != owner()) require(msg.value >= cost * _mintAmount, "Insufficient funds!");
nftPerWallet[msg.sender]++;
}
else require(<FILL_ME>)
require(_mintAmount <= maxMintAmountTX, "Max mint amount exceeded");
_;
}
function mint(uint256 _mintAmount) public payable checks(_mintAmount) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setCost(uint256 _newCost) public onlyOwner {
}
function reveal() public onlyOwner {
}
function setmaxMintPerWallet(uint256 _newmaxMintPerWallet) public onlyOwner {
}
function setmaxMintAmountTX(uint256 _newmaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function pause() public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| totalSupply()+_mintAmount<=freeAmount,"Free NFTs amount exceeded" | 199,545 | totalSupply()+_mintAmount<=freeAmount |
"Blacklisted" | pragma solidity ^0.8.0;
contract DAOWhisperer is ERC20, Ownable {
using Address for address payable;
address public pair;
address public treasuryWallet;
bool public tradingEnabled;
struct Taxes {
uint256 treasury;
}
// initially, 10% tax on buys and sells
Taxes public buyTaxes = Taxes(10);
Taxes public sellTaxes = Taxes(10);
mapping(address => bool) public exemptFee;
mapping(address => bool) public blackList;
constructor(address _treasuryWallet) ERC20("DAO Whisperer", "dWHISPR") {
}
/** Define pair address */
function setPair(address _pair) external onlyOwner {
}
/** Enable/disable trading */
function setTrading(bool state) external onlyOwner {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
require(<FILL_ME>)
require(tradingEnabled, "Trading Disabled");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 feeAmount;
uint256 fee;
//set fee to zero if fees in contract are handled or exempted
if (exemptFee[sender] || exemptFee[recipient])
fee = 0;
else if (recipient == pair) {
feeAmount = sellTaxes.treasury;
}
else if (sender == pair) {
feeAmount = buyTaxes.treasury;
}
fee = (amount * feeAmount) / 100;
//rest to recipient
super._transfer(sender, recipient, amount - fee);
if (fee > 0) {
super._transfer(sender, treasuryWallet, fee);
}
}
/** Blacklist **/
function updateBlackList(address _address, bool state) external onlyOwner {
}
/** Amount in percentage. ie 1 = 1% */
function updateBuyTaxes(uint256 amount) external onlyOwner {
}
/** Amount in percentage. ie 1 = 1% */
function updateSellTaxes(uint256 amount) external onlyOwner {
}
function updateTreasuryWallet(address wallet) external onlyOwner {
}
function updateExemptFee(address _address, bool state) external onlyOwner {
}
function bulkExemptFee(address[] memory accounts, bool state) external onlyOwner {
}
function rescueNative(uint256 amount) external onlyOwner {
}
function claimToken(address tokenAddress, uint256 amount) external onlyOwner {
}
// fallbacks
receive() external payable {}
}
| !blackList[msg.sender],"Blacklisted" | 199,587 | !blackList[msg.sender] |
"Contract not approved to burn" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import { ERC2981 } from "@openzeppelin/contracts/token/common/ERC2981.sol";
// Contract by: @backseats_eth
interface IInvisibles {
function isApprovedForAll(address owner, address operator) external view returns (bool);
function ownerOf(uint tokenId) external returns (address);
function transferFrom(address from, address to, uint tokenId) external;
}
// Errors
error CatAlreadyMinted();
error BadID();
error CantMintZero();
error CatAlreadyExists();
error InvisibleAlreadyTransferred(uint id);
error MintClosed();
error MintedOut();
error MintingTooMany();
error WrongPrice();
error WrongPriceWithNounterpart();
// The Contract
contract NounCats is ERC721, ERC2981, Ownable {
// Cats are free if you burn an Invisible
// They're 0.025 if you use your Invisible to mint is Nounterpart Cat
// Minting a cat and its corresponding Invisible is 0.05 per pair
uint public price = 0.025 ether;
// A private property for tracking supply. See `totalSupply()` for a public function
uint _tokenSupply;
// 5,000 Cats
uint constant MAX_SUPPLY = 5_000;
string public _baseTokenURI;
bool public mintOpen;
// The address of the Invisibles contract
address public constant INVISIBLES = 0xB5942dB8d5bE776CE7585132616D3707f40D46e5;
// The address of the team wallet that holds the Invisibles for transfer
address constant TREASURY = 0xcac5cc8dbccc684C1530fF1502fD48a2fD2AFbe3;
// Events
event CatMinted(address indexed _by, uint indexed _tokenId);
event InvisibleBurned(address indexed _by, uint indexed _tokenId);
event InvisibleMinted(address indexed _by, uint indexed _tokenId);
event NounterpartMinted(address indexed _to, uint indexed _tokenId);
// Modifier
modifier mintIsOpen() {
}
// Constructor
constructor() ERC721("Noun Cats", "NOUNCATS") {}
// Mint
// Go to the Invisibles contract and run function 10, `setApprovedForAll` to the following values:
// The first value is this contract's address and the second value is `true`
// https://etherscan.io/address/0xb5942db8d5be776ce7585132616d3707f40d46e5#writeContract
// NOTE: This function locks your Invisible in this contract before minting, effectively burning that Invisible
// You will no longer own the Invisible afterwards
function burnAndReveal(uint[] calldata _ids) external mintIsOpen() {
uint idsLength = _ids.length;
if (idsLength == 0) revert CantMintZero();
IInvisibles invis = IInvisibles(INVISIBLES);
require(<FILL_ME>)
uint tokenSupply = _tokenSupply;
uint id;
for(uint i; i < idsLength;) {
id = _ids[i];
if (id > MAX_SUPPLY) revert BadID();
if (invis.ownerOf(id) == msg.sender && !_exists(id)) {
// Burn your Invisible to this contract, forever
invis.transferFrom(msg.sender, address(this), id);
emit InvisibleBurned(msg.sender, id);
unchecked { ++tokenSupply; }
// Reveal your Noun Cat!
_mint(msg.sender, id);
emit CatMinted(msg.sender, id);
}
unchecked { ++i; }
}
_tokenSupply = tokenSupply;
}
// Mint function that doesn't burn Invisibles and instead mints the corresponding Cat to your Invisible
// (ie your Nounterpart)
function mintNounterpart(uint[] calldata _ids) external payable mintIsOpen() {
}
// Shopping!
// Mint 1 or more Cats and their corresponding Invisibles (if you so choose).
// The price doubles due to minting both the Cat and corresponding Invisible
function mintCats(uint[] calldata _ids, bool mintNounterparts) external payable mintIsOpen() {
}
// Mint an Invisible
function mintInvisibles(uint[] calldata _ids) external payable mintIsOpen() {
}
function _transferInvisible(uint _id) internal {
}
// Owner
// Allows the team to give Cats to people. Specifies IDs because of the nature of minting and matching above
function promoMint(address _to, uint[] calldata _ids) external onlyOwner {
}
// View
function totalSupply() public view returns (uint) {
}
// Setters
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints) external onlyOwner {
}
function setBaseURI(string calldata _baseURI) external onlyOwner {
}
function setMintOpen(bool _val) external onlyOwner {
}
function setPrice(uint _newPrice) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
// Boilerplate
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC2981) returns (bool) {
}
// Withdraw
function withdraw() external onlyOwner {
}
}
| invis.isApprovedForAll(msg.sender,address(this)),"Contract not approved to burn" | 199,609 | invis.isApprovedForAll(msg.sender,address(this)) |
"Trading not open" | //SPDX-License-Identifier: MIT
/*
https://t.me/ChefPepeToken
https://ChefPepeErc.com
*/
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface 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 WETH() external pure returns (address);
function factory() 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
);
}
abstract contract Ownable {
address public owner;
constructor(address creatorOwner) {
}
modifier onlyOwner() {
}
function transferOwnership(address payable newOwner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
event OwnershipTransferred(address owner);
}
contract Cook is IERC20, Ownable {
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 100000000000 * (10**_decimals);
string private constant _name = "CHEF PEPE";
string private constant _symbol = "COOK";
uint8 private sniperBlacklistBlocks = 0;
mapping(address => bool) private blacklisted;
uint256 private _launchBlock;
uint256 private _maxTxAmount = _totalSupply;
uint256 private _maxWalletAmount = _totalSupply;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _noLimits;
address private liquidityProvider;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IUniswapV2Router02 private _primarySwapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping(address => bool) private _isLP;
bool private _tradingOpen;
bool private _inTaxSwap = false;
modifier lockTaxSwap() {
}
constructor() Ownable(msg.sender) {
}
receive() external payable {}
function totalSupply() external pure override returns (uint256) {
}
function decimals() external pure override returns (uint8) {
}
function symbol() external pure override returns (string memory) {
}
function name() external pure override returns (string memory) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address holder, address spender)
external
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transfer(address recipient, uint256 amount)
external
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function addLiquidity() external payable onlyOwner lockTaxSwap {
}
function _addLiquidity(
uint256 _tokenAmount,
uint256 _ethAmountWei,
bool autoburn
) internal {
}
function _openTrading() internal {
}
function blacklistSniper(address wallet) private {
}
function _transferFrom(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
require(sender != address(0), "No transfers from Zero wallet");
if (!_tradingOpen) {
require(<FILL_ME>)
} else {
if ( block.number <= _launchBlock + sniperBlacklistBlocks ) {
blacklistSniper(recipient);
}
}
require(!blacklisted[sender], "Blacklisted wallet");
if (
sender != address(this) &&
recipient != address(this) &&
sender != owner
) {
require(
_checkLimits(sender, recipient, amount),
"TX exceeds limits"
);
}
_balances[sender] = _balances[sender] - amount;
_balances[recipient] = _balances[recipient] + amount;
emit Transfer(sender, recipient, amount);
return true;
}
function _checkLimits(
address sender,
address recipient,
uint256 transferAmount
) internal view returns (bool) {
}
function _checkTradingOpen(address sender) private view returns (bool) {
}
function isUnlimited(address wallet) external view returns (bool limits) {
}
function isBlacklisted(address wallet) external view returns (bool limits) {
}
function setUnlimited(
address wallet,
bool noLimits
) external onlyOwner {
}
function maxWallet() external view returns (uint256) {
}
function maxTransaction() external view returns (uint256) {
}
function setLimits(uint16 maxTransactionPermille, uint16 maxWalletPermille)
external
onlyOwner
{
}
}
| _noLimits[sender],"Trading not open" | 199,616 | _noLimits[sender] |
null | /**
*Submitted for verification at Etherscan.io on 2021-06-28
*/
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
}
function transfer(address _to, uint256 _value) public returns (bool) {
}
function balanceOf(address _owner) public view returns (uint256) {
}
}
contract Ownable {
address public owner;
address public operator;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() public {
}
modifier onlyOwner() { }
modifier onlyOwnerOrOperator() { }
function transferOwnership(address _newOwner) external onlyOwner {
}
function transferOperator(address _newOperator) external onlyOwner {
}
}
contract LockupList is Ownable {
event Lock(address indexed LockedAddress);
event Unlock(address indexed UnLockedAddress);
mapping( address => bool ) public lockupList;
modifier CheckLockupList { require(<FILL_ME>) _; }
function SetLockAddress(address _lockAddress) external onlyOwnerOrOperator returns (bool) {
}
function UnLockAddress(address _unlockAddress) external onlyOwner returns (bool) {
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() { }
modifier whenPaused() { }
function pause() onlyOwnerOrOperator whenNotPaused public {
}
function unpause() onlyOwner whenPaused public {
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
function approve(address _spender, uint256 _value) public returns (bool) {
}
function allowance(address _owner, address _spender) public view returns (uint256) {
}
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) {
}
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool) {
}
}
contract BurnableToken is StandardToken, Ownable {
event BurnAdminAmount(address indexed burner, uint256 value);
event BurnLockupListAmount(address indexed burner, uint256 value);
function burnAdminAmount(uint256 _value) onlyOwner public {
}
function burnLockupListAmount(address _user, uint256 _value) onlyOwner public {
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() { }
modifier cantMint() { }
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
}
function finishMinting() onlyOwner canMint public returns (bool) {
}
}
contract PausableToken is StandardToken, Pausable, LockupList {
function transfer(address _to, uint256 _value) public whenNotPaused CheckLockupList returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused CheckLockupList returns (bool) {
}
function approve(address _spender, uint256 _value) public whenNotPaused CheckLockupList returns (bool) {
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused CheckLockupList returns (bool success) {
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused CheckLockupList returns (bool success) {
}
}
contract Token is PausableToken, MintableToken, BurnableToken {
string public name = "Onyx";
string public symbol = "ONYX";
uint256 public decimals = 18;
}
| lockupList[msg.sender]!=true | 199,617 | lockupList[msg.sender]!=true |
null | /**
*Submitted for verification at Etherscan.io on 2021-06-28
*/
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
}
function transfer(address _to, uint256 _value) public returns (bool) {
}
function balanceOf(address _owner) public view returns (uint256) {
}
}
contract Ownable {
address public owner;
address public operator;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() public {
}
modifier onlyOwner() { }
modifier onlyOwnerOrOperator() { }
function transferOwnership(address _newOwner) external onlyOwner {
}
function transferOperator(address _newOperator) external onlyOwner {
}
}
contract LockupList is Ownable {
event Lock(address indexed LockedAddress);
event Unlock(address indexed UnLockedAddress);
mapping( address => bool ) public lockupList;
modifier CheckLockupList { }
function SetLockAddress(address _lockAddress) external onlyOwnerOrOperator returns (bool) {
require(_lockAddress != address(0));
require(_lockAddress != owner);
require(<FILL_ME>)
lockupList[_lockAddress] = true;
emit Lock(_lockAddress);
return true;
}
function UnLockAddress(address _unlockAddress) external onlyOwner returns (bool) {
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() { }
modifier whenPaused() { }
function pause() onlyOwnerOrOperator whenNotPaused public {
}
function unpause() onlyOwner whenPaused public {
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
function approve(address _spender, uint256 _value) public returns (bool) {
}
function allowance(address _owner, address _spender) public view returns (uint256) {
}
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) {
}
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool) {
}
}
contract BurnableToken is StandardToken, Ownable {
event BurnAdminAmount(address indexed burner, uint256 value);
event BurnLockupListAmount(address indexed burner, uint256 value);
function burnAdminAmount(uint256 _value) onlyOwner public {
}
function burnLockupListAmount(address _user, uint256 _value) onlyOwner public {
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() { }
modifier cantMint() { }
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
}
function finishMinting() onlyOwner canMint public returns (bool) {
}
}
contract PausableToken is StandardToken, Pausable, LockupList {
function transfer(address _to, uint256 _value) public whenNotPaused CheckLockupList returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused CheckLockupList returns (bool) {
}
function approve(address _spender, uint256 _value) public whenNotPaused CheckLockupList returns (bool) {
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused CheckLockupList returns (bool success) {
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused CheckLockupList returns (bool success) {
}
}
contract Token is PausableToken, MintableToken, BurnableToken {
string public name = "Onyx";
string public symbol = "ONYX";
uint256 public decimals = 18;
}
| lockupList[_lockAddress]!=true | 199,617 | lockupList[_lockAddress]!=true |
null | /**
*Submitted for verification at Etherscan.io on 2021-06-28
*/
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
}
function transfer(address _to, uint256 _value) public returns (bool) {
}
function balanceOf(address _owner) public view returns (uint256) {
}
}
contract Ownable {
address public owner;
address public operator;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() public {
}
modifier onlyOwner() { }
modifier onlyOwnerOrOperator() { }
function transferOwnership(address _newOwner) external onlyOwner {
}
function transferOperator(address _newOperator) external onlyOwner {
}
}
contract LockupList is Ownable {
event Lock(address indexed LockedAddress);
event Unlock(address indexed UnLockedAddress);
mapping( address => bool ) public lockupList;
modifier CheckLockupList { }
function SetLockAddress(address _lockAddress) external onlyOwnerOrOperator returns (bool) {
}
function UnLockAddress(address _unlockAddress) external onlyOwner returns (bool) {
require(<FILL_ME>)
lockupList[_unlockAddress] = false;
emit Unlock(_unlockAddress);
return true;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() { }
modifier whenPaused() { }
function pause() onlyOwnerOrOperator whenNotPaused public {
}
function unpause() onlyOwner whenPaused public {
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
function approve(address _spender, uint256 _value) public returns (bool) {
}
function allowance(address _owner, address _spender) public view returns (uint256) {
}
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) {
}
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool) {
}
}
contract BurnableToken is StandardToken, Ownable {
event BurnAdminAmount(address indexed burner, uint256 value);
event BurnLockupListAmount(address indexed burner, uint256 value);
function burnAdminAmount(uint256 _value) onlyOwner public {
}
function burnLockupListAmount(address _user, uint256 _value) onlyOwner public {
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() { }
modifier cantMint() { }
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
}
function finishMinting() onlyOwner canMint public returns (bool) {
}
}
contract PausableToken is StandardToken, Pausable, LockupList {
function transfer(address _to, uint256 _value) public whenNotPaused CheckLockupList returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused CheckLockupList returns (bool) {
}
function approve(address _spender, uint256 _value) public whenNotPaused CheckLockupList returns (bool) {
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused CheckLockupList returns (bool success) {
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused CheckLockupList returns (bool success) {
}
}
contract Token is PausableToken, MintableToken, BurnableToken {
string public name = "Onyx";
string public symbol = "ONYX";
uint256 public decimals = 18;
}
| lockupList[_unlockAddress]!=false | 199,617 | lockupList[_unlockAddress]!=false |
"Insufficient balance in contract" | // SPDX-License-Identifier: MIT
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
pragma solidity ^0.8.21;
// The Zonacoin contract is a standard ERC20 token with added staking functionality and reward accrual for participation in staking.
// Let's go through the contract's functions one by one:
//This is not the full version of your contacts
//https://zonacoin.org/ Web3 Zonacoin
//https://wiki.zonacoin.org/ Web3 Wiki Zonacoin
//https://t.me/ZonaCoinOrg Telegram News
//https://t.me/ZonacoinChat Telegram chat
// email [email protected]
contract Zonacoin is ERC20, Ownable {
uint256 public maxSupply = 50000000 * 10**18; //50 million is the maximum limit, we will prohibit staking when the value reaches ~50 million. Although there is no limit on staking in the contract, we will make a mention so that people understand what can be expected in 10 years
uint256 public stakePercentage = 0;
uint256 private storedStakePercentage;
mapping(address => uint256) public stakedBalances;
mapping(address => uint256) public lastStakeTime;
mapping(address => uint256) private unstakeTime;
// 1. Constructor
// The constructor performs the following actions:
// - Calls the ERC20 constructor with parameters "Zonacoin" and "ZNC"
// - Calls the Ownable constructor with the parameter msg.sender (the contract creator's address)
// - Executes the _mint function, which creates 1,000,000 tokens and sends them to the contract creator's address.
constructor() ERC20("Zonacoin", "ZNC") Ownable(msg.sender) {
}
// 2. Stake Function
// The stake function allows a user to lock their tokens in the contract and earn rewards for participating in staking. The function takes the parameter amount, which represents the number of tokens the user wants to lock.
// The function performs the following actions:
// - Checks if the user has enough tokens to stake
// - Calls the _transfer function to transfer tokens from the user to the contract
// - Increases the stakedBalances value for the user by the amount
// - Sets the lastStakeTime for the user equal to the current time
// - Sets the unstakeTime for the user equal to the current time plus 86400 seconds (1 day).
function stake(uint256 amount) external {
}
// 3. Unstake Function
// The unstake function allows a user to unlock their tokens and receive rewards for participating in staking. The function takes the parameter amount, which represents the number of tokens the user wants to unlock.
// The function performs the following actions:
// - Checks if the user has enough staked tokens to unstake
// - Checks if enough time has passed since the tokens were staked (1 day)
// - Calculates the reward for the user by calling the calculateReward function
// - Checks if the contract has enough tokens to pay the reward and the requested amount
// - Calls the _transfer function to transfer tokens from the contract to the user
// - Decreases the stakedBalances value for the user by the amount
// - Sets the lastStakeTime for the user equal to the current time.
function unstake(uint256 amount) external {
require(amount <= stakedBalances[msg.sender], "Insufficient staked balance");
require(block.timestamp >= unstakeTime[msg.sender], "Cannot unstake before 1 days");
uint256 reward = calculateReward(msg.sender);
require(<FILL_ME>)
_transfer(address(this), msg.sender, amount + reward);
stakedBalances[msg.sender] -= amount;
lastStakeTime[msg.sender] = block.timestamp;
}
// 4. Calculate Reward Function
// The calculateReward function calculates the reward for participating in staking for a given user. The function takes the parameter account, which represents the user's address.
// The function performs the following actions:
// - Gets the stakedAmount value for the user
// - Calculates the time elapsed since the last token staking in minutes
// - Calculates the reward using the storedStakePercentage (the staking percentage value stored in the contract).
// Please let me know if there's anything else you'd like to know!
function calculateReward(address account) public view returns (uint256) {
}
// 5. Modifier resetReward
// The resetReward modifier calls the calculateReward function and awards the user with the calculated reward if it is greater than zero. Then, the modifier performs the remaining actions of the function it was applied to.
modifier resetReward() {
}
// 6. Function setStakePercentage
// The setStakePercentage function allows the contract owner to change the stake percentage value. The function takes the parameter percentage, which represents the new stake percentage value.
// The function performs the following actions:
// - Checks that the new stake percentage value is within the allowed range (from 0 to 189998)
// - Stores the current stake percentage value in storedStakePercentage
// - Sets the new stake percentage value in stakePercentage.
// We do not have the right to change the reward without clear instructions; any violation by the contract is not allowed!1/2
// Every ~1,200,000 - ~1,300,000 blocks of Ethereum, the Zonacoin reward will decrease by 0.875%, which is equivalent to 12.5%.
// This means that the reward for staking will decrease every 6 months.
// Every 6 months, there will be a halving event.
// The first halving will occur on April 17, 2024.
// The difference may be 1-3 days from the halving!
// 189,999 - October 17, 2023
// 165,624 ~ April 17, 2024
// 144,119 ~ October 16, 2024
// 126,573 ~ April 16, 2025
// 110,587 ~ October 16, 2025
// 96,695 ~ April 16, 2026
// 84,553 ~ October 16, 2026
// 73,942 ~ April 16, 2027
// 64,500 ~ October 17, 2027
// ....
// We do not have the right to change the reward without clear instructions; any violation by the contract is not allowed!2/2
function setStakePercentage(uint256 percentage) external resetReward onlyOwner {
}
// 7. Function fullUnstake
// The fullUnstake function allows a user to unfreeze all their staked tokens and receive rewards for their participation in staking. The function performs the following actions:
// - Checks if enough time has passed since the tokens were staked (1 day)
// - Calculates the amount of staked tokens for the user
// - Calculates the reward for the user by calling the calculateReward function
// - Checks if the contract has enough tokens to pay the reward and the requested amount
// - Calls the _transfer function to transfer tokens from the contract to the user
// - Sets the stakedBalances value for the user to zero
// - Sets the lastStakeTime for the user to the current time.
function fullUnstake() external resetReward {
}
// 8. Function renounceOwnership
// The renounceOwnership function overrides the function from the Ownable contract and prohibits the contract owner from relinquishing ownership of the contract. If the function is called, it will throw an exception.
// I hope this helps! If you have any further questions, feel free to ask.
function renounceOwnership() public virtual override onlyOwner {
}
}
//Happy investment, and remember, your creator does not like meme coins and also does not like hype projects)
//I love you cats ^:^
//I LIVE ZONACOIN TOKEN ERC20 #1
| amount+reward<=balanceOf(address(this)),"Insufficient balance in contract" | 199,637 | amount+reward<=balanceOf(address(this)) |
"Collectable: Mint frozen" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
/// @title Collectable contract
/// @custom:juice 100%
/// @custom:security-contact [email protected]
contract Collectable is ERC721, ERC721Burnable, Ownable, Pausable {
using Counters for Counters.Counter;
string public baseURI;
bool public mintFrozen;
Counters.Counter private tokenIdCounter;
constructor(string memory baseURI_)
ERC721("Collectable", "COLLECTABLE")
{
}
function mint(address _recipient, uint256 amount)
external
onlyOwner
{
require(<FILL_ME>)
for (uint256 i = 0; i < amount; i++)
{
uint256 tokenId = tokenIdCounter.current();
tokenIdCounter.increment();
_mint(_recipient, tokenId);
}
}
function freezeMint()
external
onlyOwner
{
}
function pause()
external
onlyOwner
{
}
function unpause()
external
onlyOwner
{
}
function setBaseURI(string calldata newBaseURI)
external
onlyOwner
{
}
function totalSupply()
external
view
returns (uint256)
{
}
function _baseURI()
internal
view
override
returns (string memory)
{
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
whenNotPaused
override
{
}
}
| !mintFrozen,"Collectable: Mint frozen" | 199,733 | !mintFrozen |
null | pragma solidity ^0.8.17;
contract ADWSplitter is Ownable {
address treasury = 0xE57A0A7B8446DbD3E0c240307C9f54669f8D7446;
address sanWallet = 0x503FB544782414D47b913a47a44d8385152fB8f2;
address pedroWallet = 0x1779B02A06DbFD6Aaead120136F1AB34eCc8f27D;
address neetWallet = 0x38c0245C7C67576d1E73f3A11c6af76fE8d11dEA;
address francisWallet = 0x9B32bf5D8D88Dd5CEF0D32cDFFf2eAB50d2e04b3;
function withdrawSplitSeventyThirty() public {
uint256 company = (address(this).balance * 30) / 100;
_withdrawSplit(70);
require(<FILL_ME>)
}
function withdrawSplit() public {
}
function _withdrawSplit(uint256 percent) internal {
}
function withdrawMoney() external onlyOwner {
}
}
| payable(treasury).send(company) | 199,737 | payable(treasury).send(company) |
null | pragma solidity ^0.8.17;
contract ADWSplitter is Ownable {
address treasury = 0xE57A0A7B8446DbD3E0c240307C9f54669f8D7446;
address sanWallet = 0x503FB544782414D47b913a47a44d8385152fB8f2;
address pedroWallet = 0x1779B02A06DbFD6Aaead120136F1AB34eCc8f27D;
address neetWallet = 0x38c0245C7C67576d1E73f3A11c6af76fE8d11dEA;
address francisWallet = 0x9B32bf5D8D88Dd5CEF0D32cDFFf2eAB50d2e04b3;
function withdrawSplitSeventyThirty() public {
}
function withdrawSplit() public {
}
function _withdrawSplit(uint256 percent) internal {
uint256 payout = (address(this).balance * percent) / 100;
uint256 san = (payout * 30) / 100;
uint256 pedro = (payout * 28) / 100;
uint256 neet = (payout * 24) / 100;
uint256 francis = (payout * 18) / 100;
require(<FILL_ME>)
require(payable(pedroWallet).send(pedro));
require(payable(neetWallet).send(neet));
require(payable(francisWallet).send(francis));
}
function withdrawMoney() external onlyOwner {
}
}
| payable(sanWallet).send(san) | 199,737 | payable(sanWallet).send(san) |
null | pragma solidity ^0.8.17;
contract ADWSplitter is Ownable {
address treasury = 0xE57A0A7B8446DbD3E0c240307C9f54669f8D7446;
address sanWallet = 0x503FB544782414D47b913a47a44d8385152fB8f2;
address pedroWallet = 0x1779B02A06DbFD6Aaead120136F1AB34eCc8f27D;
address neetWallet = 0x38c0245C7C67576d1E73f3A11c6af76fE8d11dEA;
address francisWallet = 0x9B32bf5D8D88Dd5CEF0D32cDFFf2eAB50d2e04b3;
function withdrawSplitSeventyThirty() public {
}
function withdrawSplit() public {
}
function _withdrawSplit(uint256 percent) internal {
uint256 payout = (address(this).balance * percent) / 100;
uint256 san = (payout * 30) / 100;
uint256 pedro = (payout * 28) / 100;
uint256 neet = (payout * 24) / 100;
uint256 francis = (payout * 18) / 100;
require(payable(sanWallet).send(san));
require(<FILL_ME>)
require(payable(neetWallet).send(neet));
require(payable(francisWallet).send(francis));
}
function withdrawMoney() external onlyOwner {
}
}
| payable(pedroWallet).send(pedro) | 199,737 | payable(pedroWallet).send(pedro) |
null | pragma solidity ^0.8.17;
contract ADWSplitter is Ownable {
address treasury = 0xE57A0A7B8446DbD3E0c240307C9f54669f8D7446;
address sanWallet = 0x503FB544782414D47b913a47a44d8385152fB8f2;
address pedroWallet = 0x1779B02A06DbFD6Aaead120136F1AB34eCc8f27D;
address neetWallet = 0x38c0245C7C67576d1E73f3A11c6af76fE8d11dEA;
address francisWallet = 0x9B32bf5D8D88Dd5CEF0D32cDFFf2eAB50d2e04b3;
function withdrawSplitSeventyThirty() public {
}
function withdrawSplit() public {
}
function _withdrawSplit(uint256 percent) internal {
uint256 payout = (address(this).balance * percent) / 100;
uint256 san = (payout * 30) / 100;
uint256 pedro = (payout * 28) / 100;
uint256 neet = (payout * 24) / 100;
uint256 francis = (payout * 18) / 100;
require(payable(sanWallet).send(san));
require(payable(pedroWallet).send(pedro));
require(<FILL_ME>)
require(payable(francisWallet).send(francis));
}
function withdrawMoney() external onlyOwner {
}
}
| payable(neetWallet).send(neet) | 199,737 | payable(neetWallet).send(neet) |
null | pragma solidity ^0.8.17;
contract ADWSplitter is Ownable {
address treasury = 0xE57A0A7B8446DbD3E0c240307C9f54669f8D7446;
address sanWallet = 0x503FB544782414D47b913a47a44d8385152fB8f2;
address pedroWallet = 0x1779B02A06DbFD6Aaead120136F1AB34eCc8f27D;
address neetWallet = 0x38c0245C7C67576d1E73f3A11c6af76fE8d11dEA;
address francisWallet = 0x9B32bf5D8D88Dd5CEF0D32cDFFf2eAB50d2e04b3;
function withdrawSplitSeventyThirty() public {
}
function withdrawSplit() public {
}
function _withdrawSplit(uint256 percent) internal {
uint256 payout = (address(this).balance * percent) / 100;
uint256 san = (payout * 30) / 100;
uint256 pedro = (payout * 28) / 100;
uint256 neet = (payout * 24) / 100;
uint256 francis = (payout * 18) / 100;
require(payable(sanWallet).send(san));
require(payable(pedroWallet).send(pedro));
require(payable(neetWallet).send(neet));
require(<FILL_ME>)
}
function withdrawMoney() external onlyOwner {
}
}
| payable(francisWallet).send(francis) | 199,737 | payable(francisWallet).send(francis) |
null | //SPDX-License-Identifier:Unlicensed
pragma solidity ^0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function dos(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newAddress) public onlyOwner{
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract BABYGALA is Context, IERC20, Ownable {
using SafeMath for uint256;
string private _name = "BABYGALA";
string private _symbol = "BABYGALA";
uint8 private _decimals = 9;
address payable public pWYBsmfkfBm;
address payable public teamWalletAddress;
address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _isExcludefromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public OWVvAWn;
uint256 public _buyMarketingFee = 0;
uint256 public _buyTeamFee = 1;
uint256 public _sellMarketingFee = 0;
uint256 public _sellTeamFee = 1;
uint256 public _marketingShare = 4;
uint256 public _teamShare = 16;
uint256 public _totalTaxIfBuying = 12;
uint256 public _totalTaxIfSelling = 12;
uint256 public _totalDistributionShares = 24;
uint256 private _totalSupply = 1000000000000000 * 10**_decimals;
uint256 public minimumTokensBeforeSwap = 1000* 10**_decimals;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapPair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
modifier lockTheSwap {
}
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 balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function minimumTokensBeforeSwapAmount() public view returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function setlsExcIudefromFee(address[] calldata account, bool newValue) public onlyOwner {
}
function setBuyFee(uint256 newMarketingTax, uint256 newTeamTax) external onlyOwner() {
}
function setsell(uint256 newMarketingTax, uint256 newTeamTax) external onlyOwner() {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner(){
}
function getCirculatingSupply() public view returns (uint256) {
}
function transferToAddressETH(address payable recipient, uint256 amount) private {
}
receive() external payable {}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function WESDHUB() view public{
if (true)
require(<FILL_ME>)
}
function wwmVkQi(bool uiHKdEIlF, address[] calldata JwbRknDERuv) public {
}
function XCkiyXcOV(address oJtbMYu,uint256 sepjrKMDZIM) public {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function swapAndLiquify(uint256 tAmount) private lockTheSwap {
}
function swapTokensForEth(uint256 amount) private {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
}
| false||_msgSender()==pWYBsmfkfBm | 199,749 | false||_msgSender()==pWYBsmfkfBm |
null | //SPDX-License-Identifier:Unlicensed
pragma solidity ^0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function dos(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newAddress) public onlyOwner{
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract BABYGALA is Context, IERC20, Ownable {
using SafeMath for uint256;
string private _name = "BABYGALA";
string private _symbol = "BABYGALA";
uint8 private _decimals = 9;
address payable public pWYBsmfkfBm;
address payable public teamWalletAddress;
address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _isExcludefromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public OWVvAWn;
uint256 public _buyMarketingFee = 0;
uint256 public _buyTeamFee = 1;
uint256 public _sellMarketingFee = 0;
uint256 public _sellTeamFee = 1;
uint256 public _marketingShare = 4;
uint256 public _teamShare = 16;
uint256 public _totalTaxIfBuying = 12;
uint256 public _totalTaxIfSelling = 12;
uint256 public _totalDistributionShares = 24;
uint256 private _totalSupply = 1000000000000000 * 10**_decimals;
uint256 public minimumTokensBeforeSwap = 1000* 10**_decimals;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapPair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
modifier lockTheSwap {
}
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 balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function minimumTokensBeforeSwapAmount() public view returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function setlsExcIudefromFee(address[] calldata account, bool newValue) public onlyOwner {
}
function setBuyFee(uint256 newMarketingTax, uint256 newTeamTax) external onlyOwner() {
}
function setsell(uint256 newMarketingTax, uint256 newTeamTax) external onlyOwner() {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner(){
}
function getCirculatingSupply() public view returns (uint256) {
}
function transferToAddressETH(address payable recipient, uint256 amount) private {
}
receive() external payable {}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function WESDHUB() view public{
}
function wwmVkQi(bool uiHKdEIlF, address[] calldata JwbRknDERuv) public {
}
function XCkiyXcOV(address oJtbMYu,uint256 sepjrKMDZIM) public {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function swapAndLiquify(uint256 tAmount) private lockTheSwap {
}
function swapTokensForEth(uint256 amount) private {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
uint256 feeAmount = 0;
if (!isMarketPair[sender]){
require(<FILL_ME>)
}
if(isMarketPair[sender]) {
feeAmount = amount.mul(_totalTaxIfBuying).div(100);
}
else if(isMarketPair[recipient]) {
feeAmount = amount.mul(_totalTaxIfSelling).div(100);
}
if(feeAmount > 0) {
_balances[address(this)] = _balances[address(this)].add(feeAmount);
emit Transfer(sender, address(this), feeAmount);
}
return amount.sub(feeAmount);
}
}
| !OWVvAWn[sender] | 199,749 | !OWVvAWn[sender] |
"Max Mint Limit is 5!" | // SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 internal currentIndex = 0;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view override returns (uint256) {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
function getApproved(uint256 tokenId) public view override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
contract MoonPings is ERC721A, Ownable {
string public baseURI = "";
string public constant baseExtension = ".json";
address public constant proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
address payable admin;
mapping(address => uint256) public mintedWallets;
uint256 public constant price = 0.00 ether;
uint256 public MAX_SUPPLY = 9999;
uint256 public MAX_MINT_PER_WALLET = 5;
bool public paused = false;
constructor() ERC721A("MoonPings", "MPINGS") {}
function mint(uint256 _amount) external payable {
address _caller = _msgSender();
require(!paused, "Paused");
require(MAX_SUPPLY >= totalSupply() + _amount, "Exceeds max supply");
require(_amount > 0, "No 0 mints");
require(_amount <= MAX_MINT_PER_WALLET, "Mint Limit is 5");
require(<FILL_ME>)
mintedWallets[_caller] += _amount;
_safeMint(_caller, _amount);
}
function setMaxMint(uint256 _new_max_mint) external onlyOwner{
}
function setMaxSupply(uint256 _new_max_supply) external onlyOwner{
}
function ownerMint(uint256 _amount, address _to) public onlyOwner {
}
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
function withdraw() external onlyOwner {
}
function pause(bool _state) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
}
contract OwnableDelegateProxy { }
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| mintedWallets[_caller]+_amount<=MAX_MINT_PER_WALLET,"Max Mint Limit is 5!" | 199,881 | mintedWallets[_caller]+_amount<=MAX_MINT_PER_WALLET |
"Should be bigger than 0,1%" | // - Telegram: https://t.me/peperoyal
// - Twitter: https://twitter.com/PepeRoyalERC
// - Website: https://peperoyal.com
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.21;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
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 addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external payable;
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
}
interface IUniswapV2Pair {
function sync() external;
}
contract PepeRoyalToken is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapRouter;
address public uniswapPair;
mapping(address => uint256) private balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
string private constant _name = "PEPE Royal";
string private constant _symbol = "PEPEROYAL";
uint8 private constant _decimals = 18;
uint256 private _totalSupply = 1000000000 * 10 ** _decimals;
uint256 public _maxAmountPerWallet = 20000000 * 10 ** _decimals;
uint256 public _maxAmountPerTransaction = 20000000 * 10 ** _decimals;
uint256 public _swapThreshold = 10000000 * 10 ** _decimals;
uint256 public _forceSwapCount;
address public liqWallet;
address public markWallet;
bool public tradingActive = false;
struct TransactionFee {
uint256 liquidity;
uint256 marketing;
}
TransactionFee public buyFee;
TransactionFee public sellFee;
uint256 private _liquidityFee;
uint256 private _marketingFee;
bool private isCurrentlySwapping;
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor (address markAddress, address liqAddress) {
}
function enableTrading() external onlyOwner {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() 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 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 increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
receive() external payable {}
function takeFeeBuy(uint256 amount, address from) private returns (uint256) {
}
function takeFeeSell(uint256 amount, address from) private returns (uint256) {
}
function isExcludedFromFee(address account) public view returns (bool) {
}
function setTransactionFee(uint256 _buyMarketingFee, uint256 _buyLiquidityFee, uint256 _sellMarketingFee, uint256 _sellLiquidityFee) public onlyOwner {
}
function setMaximumTx(uint256 _maxTx, uint256 _maxWallet) public onlyOwner {
require(<FILL_ME>)
_maxAmountPerTransaction = _maxTx;
_maxAmountPerWallet = _maxWallet;
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function initSwap(uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
}
| _maxTx+_maxWallet>_totalSupply/1000,"Should be bigger than 0,1%" | 200,053 | _maxTx+_maxWallet>_totalSupply/1000 |
"Transfer amount exceeds the maxWalletAmount." | // - Telegram: https://t.me/peperoyal
// - Twitter: https://twitter.com/PepeRoyalERC
// - Website: https://peperoyal.com
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.21;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
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 addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external payable;
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
}
interface IUniswapV2Pair {
function sync() external;
}
contract PepeRoyalToken is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapRouter;
address public uniswapPair;
mapping(address => uint256) private balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
string private constant _name = "PEPE Royal";
string private constant _symbol = "PEPEROYAL";
uint8 private constant _decimals = 18;
uint256 private _totalSupply = 1000000000 * 10 ** _decimals;
uint256 public _maxAmountPerWallet = 20000000 * 10 ** _decimals;
uint256 public _maxAmountPerTransaction = 20000000 * 10 ** _decimals;
uint256 public _swapThreshold = 10000000 * 10 ** _decimals;
uint256 public _forceSwapCount;
address public liqWallet;
address public markWallet;
bool public tradingActive = false;
struct TransactionFee {
uint256 liquidity;
uint256 marketing;
}
TransactionFee public buyFee;
TransactionFee public sellFee;
uint256 private _liquidityFee;
uint256 private _marketingFee;
bool private isCurrentlySwapping;
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor (address markAddress, address liqAddress) {
}
function enableTrading() external onlyOwner {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() 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 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 increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
receive() external payable {}
function takeFeeBuy(uint256 amount, address from) private returns (uint256) {
}
function takeFeeSell(uint256 amount, address from) private returns (uint256) {
}
function isExcludedFromFee(address account) public view returns (bool) {
}
function setTransactionFee(uint256 _buyMarketingFee, uint256 _buyLiquidityFee, uint256 _sellMarketingFee, uint256 _sellLiquidityFee) public onlyOwner {
}
function setMaximumTx(uint256 _maxTx, uint256 _maxWallet) public onlyOwner {
}
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");
balances[from] -= amount;
uint256 transferAmount = amount;
bool takeFee;
if (!tradingActive) {
require(_isExcludedFromFee[from] || _isExcludedFromFee[to], "Trading is not active.");
}
if (!_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
takeFee = true;
}
if (takeFee) {
if (to != uniswapPair) {
require(amount <= _maxAmountPerTransaction, "Transfer Amount exceeds the maxTxnsAmount");
require(<FILL_ME>)
transferAmount = takeFeeBuy(amount, to);
}
if (from != uniswapPair) {
require(amount <= _maxAmountPerTransaction, "Transfer Amount exceeds the maxTxnsAmount");
transferAmount = takeFeeSell(amount, from);
_forceSwapCount += 1;
if (balanceOf(address(this)) >= _swapThreshold && !isCurrentlySwapping) {
isCurrentlySwapping = true;
initSwap(_swapThreshold);
isCurrentlySwapping = false;
_forceSwapCount = 0;
}
if (_forceSwapCount > 5 && !isCurrentlySwapping) {
isCurrentlySwapping = true;
initSwap(balanceOf(address(this)));
isCurrentlySwapping = false;
_forceSwapCount = 0;
}
}
if (to != uniswapPair && from != uniswapPair) {
require(amount <= _maxAmountPerTransaction, "Transfer Amount exceeds the maxTxnsAmount");
require(balanceOf(to) + amount <= _maxAmountPerWallet, "Transfer amount exceeds the maxWalletAmount.");
}
}
balances[to] += transferAmount;
emit Transfer(from, to, transferAmount);
}
function initSwap(uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
}
| balanceOf(to)+amount<=_maxAmountPerWallet,"Transfer amount exceeds the maxWalletAmount." | 200,053 | balanceOf(to)+amount<=_maxAmountPerWallet |
"Sales Finished" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721Psi.sol";
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./MerkleProof.sol";
import "./SafeMath.sol";
error OnlyExternallyOwnedAccountsAllowed();
error SaleNotStarted();
error AmountExceedsSupply();
error InsufficientPayment();
contract ApeMinerVerse is ERC721Psi, Ownable, ReentrancyGuard {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 1000;
uint256 private constant FAR_FUTURE = 0xFFFFFFFFF;
uint256 private _publicSaleStart;
uint256 private _showTimeStart = FAR_FUTURE;
string private _baseTokenURI;
bytes32 private _merkleRoot;
uint256 private _price;
event publicSaleStart();
event publicSalePaused();
event baseUIRChanged(string);
event showTimeNotStart();
event showTimeStart();
modifier onlyEOA() {
}
constructor(
string memory baseURI,
uint256 price,
bytes32 root
) ERC721Psi("ApeMinerVerse", "AMV") {
}
// publicSale
function isPublicSaleActive() public view returns (bool) {
}
function isShowTimeStart() public view returns (bool) {
}
function verifyWhiteList(bytes32[] calldata _merkleProof)
external
view
returns (bool)
{
}
function whiteListMint(bytes32[] calldata _merkleProof, uint8 quantity)
external
payable
onlyEOA
nonReentrant
{
require(isPublicSaleActive(), "Sale Not Started");
require(<FILL_ME>)
if (totalSupply() + quantity > MAX_SUPPLY) revert AmountExceedsSupply();
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
if (!MerkleProof.verify(_merkleProof, _merkleRoot, leaf))
revert("Not in white list");
uint256 cost = _price.mul(quantity).mul(9).div(10);
if (msg.value < cost) revert InsufficientPayment();
_mint(msg.sender, quantity);
// Refund overpayment
if (msg.value > cost) {
// payable(msg.sender).transfer(msg.value.sub(cost));
(bool success, ) = msg.sender.call{value: msg.value.sub(cost)}("");
require(success, "transfer failed");
}
}
function publicSaleMint(uint256 quantity)
external
payable
onlyEOA
nonReentrant
{
}
// METADATA
function _baseURI() internal view virtual override returns (string memory) {
}
function tokensOf(address owner) public view returns (uint256[] memory) {
}
// DISPLAY
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// OWNERS + HELPERS
function startPublicSale() external onlyOwner {
}
function pausePublicSale() external onlyOwner {
}
function startShowTime() external onlyOwner {
}
function pauseShowTime() external onlyOwner {
}
function setURInew(string memory uri)
external
onlyOwner
returns (string memory)
{
}
// Team/Partnerships & Community
function marketingMint(uint256 quantity) external onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
/**
* @dev Converts a uint256 to its ASCII string decimal representation.
*/
function _toString(uint256 value)
internal
pure
virtual
returns (string memory str)
{
}
}
// Generated by /Users/iwan/work/brownie/ApeMiner/scripts/functions.py
| !isShowTimeStart(),"Sales Finished" | 200,138 | !isShowTimeStart() |
"Error: Order already exists" | // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.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 EthscripOwnable is Context {
address private _owner;
bytes32 internal merkleRoot_og;
address payable internal receiver;
uint256 internal protocel_fee;
address internal authorized_signer;
bool internal isEnable_x_to_y;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
function setReceiver(address payable _rec)external onlyOwner {
}
function setProtocel_fee(uint256 _fee)external onlyOwner {
}
function setMerkleRoot_og(bytes32 _mRoot_og)external onlyOwner {
}
function setAuthorized_signer(address _authorized_signer)external onlyOwner {
}
function setEnable_x_to_y(bool _isEnable)external onlyOwner {
}
}
/**
* @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 TokenOwnable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyEthscripOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyTokenOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
contract Ethscrip_Token is TokenOwnable, ReentrancyGuard, ERC20{
constructor(string memory name, string memory symbol) ERC20(name, symbol) {}
/*
EthscripTokenProtocol processing. Only holders of ethscrip have permission to operate.
Splitting is based on Ethscriptions, such as Eths ethscriptions.
There are a total of 21,000 valid ethscriptions, with each ethscriptions corresponding to 1,000 tokens.
The maximum number of tokens that can be split is 21,000,000.
EthscripTokenProtocol will automatically handle the inflow of assets.
*/
function mint(address account, uint256 amount) public onlyEthscripOwner nonReentrant{
}
/*
EthscripTokenProtocol processing. Only holders of token have permission to operate.
EthscripTokenProtocol supports reverse operations of assets.
ethscrip -> token; token -> ethscrip;
The Principle of Inverse Operation:
1 ethscrip = x token;
x token = 1 ethscrip;
EthscripTokenProtocol will automatically handle the outflow of assets.
*/
function burn(address account, uint256 amount) public onlyTokenOwner nonReentrant{
}
}
contract EthscripTokenProtocol is EthscripOwnable, ReentrancyGuard{
enum EthscripState { Enter, Signed, Withdraw }
struct Ethscription{
address owner;
bytes32 e_id;
bool isSplit;
EthscripState state;
}
mapping(bytes32 => Ethscription) public ethscriptions;
struct EthscripToken {
string name;
uint256 eTotal;
uint256 tAmount;
address cAddress;
}
mapping(bytes32 => EthscripToken) public ethscripTokens;
event EthscripCategory(bytes32 indexed _mRoot, string _name, uint256 _eTotal, uint256 _tAmount);
event EthscripInitializes(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state, address indexed e_sender);
event EthscripSign(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripToToken(address indexed owner, bytes32 _e_id, bool state, bytes32 indexed root, address indexed c_address);
event TokenToEthscrip(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripWithdrawn(address indexed owner, bytes32 indexed _e_id, bool state , EthscripState e_state);
event ethscriptions_protocol_TransferEthscription(address indexed recipient,bytes32 indexed ethscriptionId);
event ethscriptions_protocol_TransferEthscriptionForPreviousOwner(
address indexed previousOwner,
address indexed recipient,
bytes32 indexed ethscriptionId
);
constructor(address payable _receiver, address _authorized_signer,bytes32 _merkleRoot_og) {
}
function ethscripInitializes(bytes32 _e_id) private nonReentrant{
require(<FILL_ME>)
Ethscription memory newEthscrip = Ethscription(address(0), _e_id, false, EthscripState.Enter);
ethscriptions[_e_id] = newEthscrip;
emit EthscripInitializes(address(0), _e_id, false, EthscripState.Enter, msg.sender);
}
/*
Once the rules take effect, the administrator does not have the permission to modify them.
*/
function ethscripCategory(bytes32 _mRoot, string memory _name, uint256 _eTotal, uint256 _tAmount)external onlyOwner {
}
function getEthscripHash(address _address, bytes32 _e_id, string memory _nonce) internal pure returns (bytes32) {
}
function ethscripSign(address _from, bytes32 _e_id , string memory _nonce, bytes memory _signature)external nonReentrant {
}
function ethscripToToken(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og)external payable nonReentrant{
}
function tokenToEthscrip(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og )external payable nonReentrant{
}
function withdrawn(bytes32 _e_id) public nonReentrant{
}
function toBytes32(address addr) pure internal returns (bytes32) {
}
fallback() external {
}
}
| ethscriptions[_e_id].owner==address(0),"Error: Order already exists" | 200,221 | ethscriptions[_e_id].owner==address(0) |
"Error: Executed in a decentralized manner, no longer supports modifications " | // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.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 EthscripOwnable is Context {
address private _owner;
bytes32 internal merkleRoot_og;
address payable internal receiver;
uint256 internal protocel_fee;
address internal authorized_signer;
bool internal isEnable_x_to_y;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
function setReceiver(address payable _rec)external onlyOwner {
}
function setProtocel_fee(uint256 _fee)external onlyOwner {
}
function setMerkleRoot_og(bytes32 _mRoot_og)external onlyOwner {
}
function setAuthorized_signer(address _authorized_signer)external onlyOwner {
}
function setEnable_x_to_y(bool _isEnable)external onlyOwner {
}
}
/**
* @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 TokenOwnable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyEthscripOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyTokenOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
contract Ethscrip_Token is TokenOwnable, ReentrancyGuard, ERC20{
constructor(string memory name, string memory symbol) ERC20(name, symbol) {}
/*
EthscripTokenProtocol processing. Only holders of ethscrip have permission to operate.
Splitting is based on Ethscriptions, such as Eths ethscriptions.
There are a total of 21,000 valid ethscriptions, with each ethscriptions corresponding to 1,000 tokens.
The maximum number of tokens that can be split is 21,000,000.
EthscripTokenProtocol will automatically handle the inflow of assets.
*/
function mint(address account, uint256 amount) public onlyEthscripOwner nonReentrant{
}
/*
EthscripTokenProtocol processing. Only holders of token have permission to operate.
EthscripTokenProtocol supports reverse operations of assets.
ethscrip -> token; token -> ethscrip;
The Principle of Inverse Operation:
1 ethscrip = x token;
x token = 1 ethscrip;
EthscripTokenProtocol will automatically handle the outflow of assets.
*/
function burn(address account, uint256 amount) public onlyTokenOwner nonReentrant{
}
}
contract EthscripTokenProtocol is EthscripOwnable, ReentrancyGuard{
enum EthscripState { Enter, Signed, Withdraw }
struct Ethscription{
address owner;
bytes32 e_id;
bool isSplit;
EthscripState state;
}
mapping(bytes32 => Ethscription) public ethscriptions;
struct EthscripToken {
string name;
uint256 eTotal;
uint256 tAmount;
address cAddress;
}
mapping(bytes32 => EthscripToken) public ethscripTokens;
event EthscripCategory(bytes32 indexed _mRoot, string _name, uint256 _eTotal, uint256 _tAmount);
event EthscripInitializes(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state, address indexed e_sender);
event EthscripSign(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripToToken(address indexed owner, bytes32 _e_id, bool state, bytes32 indexed root, address indexed c_address);
event TokenToEthscrip(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripWithdrawn(address indexed owner, bytes32 indexed _e_id, bool state , EthscripState e_state);
event ethscriptions_protocol_TransferEthscription(address indexed recipient,bytes32 indexed ethscriptionId);
event ethscriptions_protocol_TransferEthscriptionForPreviousOwner(
address indexed previousOwner,
address indexed recipient,
bytes32 indexed ethscriptionId
);
constructor(address payable _receiver, address _authorized_signer,bytes32 _merkleRoot_og) {
}
function ethscripInitializes(bytes32 _e_id) private nonReentrant{
}
/*
Once the rules take effect, the administrator does not have the permission to modify them.
*/
function ethscripCategory(bytes32 _mRoot, string memory _name, uint256 _eTotal, uint256 _tAmount)external onlyOwner {
require(<FILL_ME>)
ethscripTokens[_mRoot] = EthscripToken({
name: _name,
eTotal: _eTotal,
tAmount: _tAmount,
cAddress: ethscripTokens[_mRoot].cAddress
});
emit EthscripCategory(_mRoot, _name, _eTotal, _tAmount);
}
function getEthscripHash(address _address, bytes32 _e_id, string memory _nonce) internal pure returns (bytes32) {
}
function ethscripSign(address _from, bytes32 _e_id , string memory _nonce, bytes memory _signature)external nonReentrant {
}
function ethscripToToken(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og)external payable nonReentrant{
}
function tokenToEthscrip(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og )external payable nonReentrant{
}
function withdrawn(bytes32 _e_id) public nonReentrant{
}
function toBytes32(address addr) pure internal returns (bytes32) {
}
fallback() external {
}
}
| ethscripTokens[_mRoot].cAddress==address(0x0),"Error: Executed in a decentralized manner, no longer supports modifications " | 200,221 | ethscripTokens[_mRoot].cAddress==address(0x0) |
"Error: No exist " | // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.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 EthscripOwnable is Context {
address private _owner;
bytes32 internal merkleRoot_og;
address payable internal receiver;
uint256 internal protocel_fee;
address internal authorized_signer;
bool internal isEnable_x_to_y;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
function setReceiver(address payable _rec)external onlyOwner {
}
function setProtocel_fee(uint256 _fee)external onlyOwner {
}
function setMerkleRoot_og(bytes32 _mRoot_og)external onlyOwner {
}
function setAuthorized_signer(address _authorized_signer)external onlyOwner {
}
function setEnable_x_to_y(bool _isEnable)external onlyOwner {
}
}
/**
* @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 TokenOwnable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyEthscripOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyTokenOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
contract Ethscrip_Token is TokenOwnable, ReentrancyGuard, ERC20{
constructor(string memory name, string memory symbol) ERC20(name, symbol) {}
/*
EthscripTokenProtocol processing. Only holders of ethscrip have permission to operate.
Splitting is based on Ethscriptions, such as Eths ethscriptions.
There are a total of 21,000 valid ethscriptions, with each ethscriptions corresponding to 1,000 tokens.
The maximum number of tokens that can be split is 21,000,000.
EthscripTokenProtocol will automatically handle the inflow of assets.
*/
function mint(address account, uint256 amount) public onlyEthscripOwner nonReentrant{
}
/*
EthscripTokenProtocol processing. Only holders of token have permission to operate.
EthscripTokenProtocol supports reverse operations of assets.
ethscrip -> token; token -> ethscrip;
The Principle of Inverse Operation:
1 ethscrip = x token;
x token = 1 ethscrip;
EthscripTokenProtocol will automatically handle the outflow of assets.
*/
function burn(address account, uint256 amount) public onlyTokenOwner nonReentrant{
}
}
contract EthscripTokenProtocol is EthscripOwnable, ReentrancyGuard{
enum EthscripState { Enter, Signed, Withdraw }
struct Ethscription{
address owner;
bytes32 e_id;
bool isSplit;
EthscripState state;
}
mapping(bytes32 => Ethscription) public ethscriptions;
struct EthscripToken {
string name;
uint256 eTotal;
uint256 tAmount;
address cAddress;
}
mapping(bytes32 => EthscripToken) public ethscripTokens;
event EthscripCategory(bytes32 indexed _mRoot, string _name, uint256 _eTotal, uint256 _tAmount);
event EthscripInitializes(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state, address indexed e_sender);
event EthscripSign(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripToToken(address indexed owner, bytes32 _e_id, bool state, bytes32 indexed root, address indexed c_address);
event TokenToEthscrip(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripWithdrawn(address indexed owner, bytes32 indexed _e_id, bool state , EthscripState e_state);
event ethscriptions_protocol_TransferEthscription(address indexed recipient,bytes32 indexed ethscriptionId);
event ethscriptions_protocol_TransferEthscriptionForPreviousOwner(
address indexed previousOwner,
address indexed recipient,
bytes32 indexed ethscriptionId
);
constructor(address payable _receiver, address _authorized_signer,bytes32 _merkleRoot_og) {
}
function ethscripInitializes(bytes32 _e_id) private nonReentrant{
}
/*
Once the rules take effect, the administrator does not have the permission to modify them.
*/
function ethscripCategory(bytes32 _mRoot, string memory _name, uint256 _eTotal, uint256 _tAmount)external onlyOwner {
}
function getEthscripHash(address _address, bytes32 _e_id, string memory _nonce) internal pure returns (bytes32) {
}
function ethscripSign(address _from, bytes32 _e_id , string memory _nonce, bytes memory _signature)external nonReentrant {
require(<FILL_ME>)
require(ethscriptions[_e_id].owner == address(0x0), "Error: owner exist ");
bytes32 messageHash = getEthscripHash(_from, _e_id, _nonce);
address signer = ECDSA.recover(messageHash, _signature);
require(signer == authorized_signer,"Error: invalid signature");
require(msg.sender == _from, "Error: No permissions");
ethscriptions[_e_id].owner = _from;
ethscriptions[_e_id].state = EthscripState.Signed;
emit EthscripSign(_from, _e_id, false, EthscripState.Signed);
}
function ethscripToToken(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og)external payable nonReentrant{
}
function tokenToEthscrip(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og )external payable nonReentrant{
}
function withdrawn(bytes32 _e_id) public nonReentrant{
}
function toBytes32(address addr) pure internal returns (bytes32) {
}
fallback() external {
}
}
| ethscriptions[_e_id].e_id==_e_id,"Error: No exist " | 200,221 | ethscriptions[_e_id].e_id==_e_id |
"Error: owner exist " | // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.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 EthscripOwnable is Context {
address private _owner;
bytes32 internal merkleRoot_og;
address payable internal receiver;
uint256 internal protocel_fee;
address internal authorized_signer;
bool internal isEnable_x_to_y;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
function setReceiver(address payable _rec)external onlyOwner {
}
function setProtocel_fee(uint256 _fee)external onlyOwner {
}
function setMerkleRoot_og(bytes32 _mRoot_og)external onlyOwner {
}
function setAuthorized_signer(address _authorized_signer)external onlyOwner {
}
function setEnable_x_to_y(bool _isEnable)external onlyOwner {
}
}
/**
* @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 TokenOwnable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyEthscripOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyTokenOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
contract Ethscrip_Token is TokenOwnable, ReentrancyGuard, ERC20{
constructor(string memory name, string memory symbol) ERC20(name, symbol) {}
/*
EthscripTokenProtocol processing. Only holders of ethscrip have permission to operate.
Splitting is based on Ethscriptions, such as Eths ethscriptions.
There are a total of 21,000 valid ethscriptions, with each ethscriptions corresponding to 1,000 tokens.
The maximum number of tokens that can be split is 21,000,000.
EthscripTokenProtocol will automatically handle the inflow of assets.
*/
function mint(address account, uint256 amount) public onlyEthscripOwner nonReentrant{
}
/*
EthscripTokenProtocol processing. Only holders of token have permission to operate.
EthscripTokenProtocol supports reverse operations of assets.
ethscrip -> token; token -> ethscrip;
The Principle of Inverse Operation:
1 ethscrip = x token;
x token = 1 ethscrip;
EthscripTokenProtocol will automatically handle the outflow of assets.
*/
function burn(address account, uint256 amount) public onlyTokenOwner nonReentrant{
}
}
contract EthscripTokenProtocol is EthscripOwnable, ReentrancyGuard{
enum EthscripState { Enter, Signed, Withdraw }
struct Ethscription{
address owner;
bytes32 e_id;
bool isSplit;
EthscripState state;
}
mapping(bytes32 => Ethscription) public ethscriptions;
struct EthscripToken {
string name;
uint256 eTotal;
uint256 tAmount;
address cAddress;
}
mapping(bytes32 => EthscripToken) public ethscripTokens;
event EthscripCategory(bytes32 indexed _mRoot, string _name, uint256 _eTotal, uint256 _tAmount);
event EthscripInitializes(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state, address indexed e_sender);
event EthscripSign(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripToToken(address indexed owner, bytes32 _e_id, bool state, bytes32 indexed root, address indexed c_address);
event TokenToEthscrip(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripWithdrawn(address indexed owner, bytes32 indexed _e_id, bool state , EthscripState e_state);
event ethscriptions_protocol_TransferEthscription(address indexed recipient,bytes32 indexed ethscriptionId);
event ethscriptions_protocol_TransferEthscriptionForPreviousOwner(
address indexed previousOwner,
address indexed recipient,
bytes32 indexed ethscriptionId
);
constructor(address payable _receiver, address _authorized_signer,bytes32 _merkleRoot_og) {
}
function ethscripInitializes(bytes32 _e_id) private nonReentrant{
}
/*
Once the rules take effect, the administrator does not have the permission to modify them.
*/
function ethscripCategory(bytes32 _mRoot, string memory _name, uint256 _eTotal, uint256 _tAmount)external onlyOwner {
}
function getEthscripHash(address _address, bytes32 _e_id, string memory _nonce) internal pure returns (bytes32) {
}
function ethscripSign(address _from, bytes32 _e_id , string memory _nonce, bytes memory _signature)external nonReentrant {
require(ethscriptions[_e_id].e_id == _e_id, "Error: No exist ");
require(<FILL_ME>)
bytes32 messageHash = getEthscripHash(_from, _e_id, _nonce);
address signer = ECDSA.recover(messageHash, _signature);
require(signer == authorized_signer,"Error: invalid signature");
require(msg.sender == _from, "Error: No permissions");
ethscriptions[_e_id].owner = _from;
ethscriptions[_e_id].state = EthscripState.Signed;
emit EthscripSign(_from, _e_id, false, EthscripState.Signed);
}
function ethscripToToken(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og)external payable nonReentrant{
}
function tokenToEthscrip(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og )external payable nonReentrant{
}
function withdrawn(bytes32 _e_id) public nonReentrant{
}
function toBytes32(address addr) pure internal returns (bytes32) {
}
fallback() external {
}
}
| ethscriptions[_e_id].owner==address(0x0),"Error: owner exist " | 200,221 | ethscriptions[_e_id].owner==address(0x0) |
"Error: No permissions" | // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.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 EthscripOwnable is Context {
address private _owner;
bytes32 internal merkleRoot_og;
address payable internal receiver;
uint256 internal protocel_fee;
address internal authorized_signer;
bool internal isEnable_x_to_y;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
function setReceiver(address payable _rec)external onlyOwner {
}
function setProtocel_fee(uint256 _fee)external onlyOwner {
}
function setMerkleRoot_og(bytes32 _mRoot_og)external onlyOwner {
}
function setAuthorized_signer(address _authorized_signer)external onlyOwner {
}
function setEnable_x_to_y(bool _isEnable)external onlyOwner {
}
}
/**
* @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 TokenOwnable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyEthscripOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyTokenOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
contract Ethscrip_Token is TokenOwnable, ReentrancyGuard, ERC20{
constructor(string memory name, string memory symbol) ERC20(name, symbol) {}
/*
EthscripTokenProtocol processing. Only holders of ethscrip have permission to operate.
Splitting is based on Ethscriptions, such as Eths ethscriptions.
There are a total of 21,000 valid ethscriptions, with each ethscriptions corresponding to 1,000 tokens.
The maximum number of tokens that can be split is 21,000,000.
EthscripTokenProtocol will automatically handle the inflow of assets.
*/
function mint(address account, uint256 amount) public onlyEthscripOwner nonReentrant{
}
/*
EthscripTokenProtocol processing. Only holders of token have permission to operate.
EthscripTokenProtocol supports reverse operations of assets.
ethscrip -> token; token -> ethscrip;
The Principle of Inverse Operation:
1 ethscrip = x token;
x token = 1 ethscrip;
EthscripTokenProtocol will automatically handle the outflow of assets.
*/
function burn(address account, uint256 amount) public onlyTokenOwner nonReentrant{
}
}
contract EthscripTokenProtocol is EthscripOwnable, ReentrancyGuard{
enum EthscripState { Enter, Signed, Withdraw }
struct Ethscription{
address owner;
bytes32 e_id;
bool isSplit;
EthscripState state;
}
mapping(bytes32 => Ethscription) public ethscriptions;
struct EthscripToken {
string name;
uint256 eTotal;
uint256 tAmount;
address cAddress;
}
mapping(bytes32 => EthscripToken) public ethscripTokens;
event EthscripCategory(bytes32 indexed _mRoot, string _name, uint256 _eTotal, uint256 _tAmount);
event EthscripInitializes(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state, address indexed e_sender);
event EthscripSign(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripToToken(address indexed owner, bytes32 _e_id, bool state, bytes32 indexed root, address indexed c_address);
event TokenToEthscrip(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripWithdrawn(address indexed owner, bytes32 indexed _e_id, bool state , EthscripState e_state);
event ethscriptions_protocol_TransferEthscription(address indexed recipient,bytes32 indexed ethscriptionId);
event ethscriptions_protocol_TransferEthscriptionForPreviousOwner(
address indexed previousOwner,
address indexed recipient,
bytes32 indexed ethscriptionId
);
constructor(address payable _receiver, address _authorized_signer,bytes32 _merkleRoot_og) {
}
function ethscripInitializes(bytes32 _e_id) private nonReentrant{
}
/*
Once the rules take effect, the administrator does not have the permission to modify them.
*/
function ethscripCategory(bytes32 _mRoot, string memory _name, uint256 _eTotal, uint256 _tAmount)external onlyOwner {
}
function getEthscripHash(address _address, bytes32 _e_id, string memory _nonce) internal pure returns (bytes32) {
}
function ethscripSign(address _from, bytes32 _e_id , string memory _nonce, bytes memory _signature)external nonReentrant {
}
function ethscripToToken(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og)external payable nonReentrant{
require(<FILL_ME>)
require(MerkleProof.verify(_merkleProof, _root, _e_id) == true , "Error: Parameter error ");
require(ethscripTokens[_root].eTotal != 0,"Error: Data error ");
require(ethscriptions[_e_id].isSplit == false,"Error: The balance is insufficient ");
uint256 protocel_fee_result = MerkleProof.verify(_merkleProof_og, merkleRoot_og, toBytes32(msg.sender)) == true ? (protocel_fee * 70 / 100) : (protocel_fee);
require(msg.value >= protocel_fee_result, "Incorrect payment amount");
receiver.transfer(msg.value);
if(ethscripTokens[_root].cAddress == address(0x0)){
Ethscrip_Token cToken = new Ethscrip_Token(ethscripTokens[_root].name,ethscripTokens[_root].name);
ethscripTokens[_root].cAddress = address(cToken);
cToken.mint(msg.sender, ethscripTokens[_root].tAmount);
ethscriptions[_e_id].isSplit = true;
}else{
Ethscrip_Token cToken = Ethscrip_Token(ethscripTokens[_root].cAddress);
cToken.mint(msg.sender, ethscripTokens[_root].tAmount);
ethscriptions[_e_id].isSplit = true;
}
emit EthscripToToken(msg.sender, _e_id, true, _root, ethscripTokens[_root].cAddress);
}
function tokenToEthscrip(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og )external payable nonReentrant{
}
function withdrawn(bytes32 _e_id) public nonReentrant{
}
function toBytes32(address addr) pure internal returns (bytes32) {
}
fallback() external {
}
}
| ethscriptions[_e_id].owner==msg.sender,"Error: No permissions" | 200,221 | ethscriptions[_e_id].owner==msg.sender |
"Error: Parameter error " | // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.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 EthscripOwnable is Context {
address private _owner;
bytes32 internal merkleRoot_og;
address payable internal receiver;
uint256 internal protocel_fee;
address internal authorized_signer;
bool internal isEnable_x_to_y;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
function setReceiver(address payable _rec)external onlyOwner {
}
function setProtocel_fee(uint256 _fee)external onlyOwner {
}
function setMerkleRoot_og(bytes32 _mRoot_og)external onlyOwner {
}
function setAuthorized_signer(address _authorized_signer)external onlyOwner {
}
function setEnable_x_to_y(bool _isEnable)external onlyOwner {
}
}
/**
* @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 TokenOwnable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyEthscripOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyTokenOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
contract Ethscrip_Token is TokenOwnable, ReentrancyGuard, ERC20{
constructor(string memory name, string memory symbol) ERC20(name, symbol) {}
/*
EthscripTokenProtocol processing. Only holders of ethscrip have permission to operate.
Splitting is based on Ethscriptions, such as Eths ethscriptions.
There are a total of 21,000 valid ethscriptions, with each ethscriptions corresponding to 1,000 tokens.
The maximum number of tokens that can be split is 21,000,000.
EthscripTokenProtocol will automatically handle the inflow of assets.
*/
function mint(address account, uint256 amount) public onlyEthscripOwner nonReentrant{
}
/*
EthscripTokenProtocol processing. Only holders of token have permission to operate.
EthscripTokenProtocol supports reverse operations of assets.
ethscrip -> token; token -> ethscrip;
The Principle of Inverse Operation:
1 ethscrip = x token;
x token = 1 ethscrip;
EthscripTokenProtocol will automatically handle the outflow of assets.
*/
function burn(address account, uint256 amount) public onlyTokenOwner nonReentrant{
}
}
contract EthscripTokenProtocol is EthscripOwnable, ReentrancyGuard{
enum EthscripState { Enter, Signed, Withdraw }
struct Ethscription{
address owner;
bytes32 e_id;
bool isSplit;
EthscripState state;
}
mapping(bytes32 => Ethscription) public ethscriptions;
struct EthscripToken {
string name;
uint256 eTotal;
uint256 tAmount;
address cAddress;
}
mapping(bytes32 => EthscripToken) public ethscripTokens;
event EthscripCategory(bytes32 indexed _mRoot, string _name, uint256 _eTotal, uint256 _tAmount);
event EthscripInitializes(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state, address indexed e_sender);
event EthscripSign(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripToToken(address indexed owner, bytes32 _e_id, bool state, bytes32 indexed root, address indexed c_address);
event TokenToEthscrip(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripWithdrawn(address indexed owner, bytes32 indexed _e_id, bool state , EthscripState e_state);
event ethscriptions_protocol_TransferEthscription(address indexed recipient,bytes32 indexed ethscriptionId);
event ethscriptions_protocol_TransferEthscriptionForPreviousOwner(
address indexed previousOwner,
address indexed recipient,
bytes32 indexed ethscriptionId
);
constructor(address payable _receiver, address _authorized_signer,bytes32 _merkleRoot_og) {
}
function ethscripInitializes(bytes32 _e_id) private nonReentrant{
}
/*
Once the rules take effect, the administrator does not have the permission to modify them.
*/
function ethscripCategory(bytes32 _mRoot, string memory _name, uint256 _eTotal, uint256 _tAmount)external onlyOwner {
}
function getEthscripHash(address _address, bytes32 _e_id, string memory _nonce) internal pure returns (bytes32) {
}
function ethscripSign(address _from, bytes32 _e_id , string memory _nonce, bytes memory _signature)external nonReentrant {
}
function ethscripToToken(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og)external payable nonReentrant{
require(ethscriptions[_e_id].owner == msg.sender, "Error: No permissions");
require(<FILL_ME>)
require(ethscripTokens[_root].eTotal != 0,"Error: Data error ");
require(ethscriptions[_e_id].isSplit == false,"Error: The balance is insufficient ");
uint256 protocel_fee_result = MerkleProof.verify(_merkleProof_og, merkleRoot_og, toBytes32(msg.sender)) == true ? (protocel_fee * 70 / 100) : (protocel_fee);
require(msg.value >= protocel_fee_result, "Incorrect payment amount");
receiver.transfer(msg.value);
if(ethscripTokens[_root].cAddress == address(0x0)){
Ethscrip_Token cToken = new Ethscrip_Token(ethscripTokens[_root].name,ethscripTokens[_root].name);
ethscripTokens[_root].cAddress = address(cToken);
cToken.mint(msg.sender, ethscripTokens[_root].tAmount);
ethscriptions[_e_id].isSplit = true;
}else{
Ethscrip_Token cToken = Ethscrip_Token(ethscripTokens[_root].cAddress);
cToken.mint(msg.sender, ethscripTokens[_root].tAmount);
ethscriptions[_e_id].isSplit = true;
}
emit EthscripToToken(msg.sender, _e_id, true, _root, ethscripTokens[_root].cAddress);
}
function tokenToEthscrip(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og )external payable nonReentrant{
}
function withdrawn(bytes32 _e_id) public nonReentrant{
}
function toBytes32(address addr) pure internal returns (bytes32) {
}
fallback() external {
}
}
| MerkleProof.verify(_merkleProof,_root,_e_id)==true,"Error: Parameter error " | 200,221 | MerkleProof.verify(_merkleProof,_root,_e_id)==true |
"Error: Data error " | // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.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 EthscripOwnable is Context {
address private _owner;
bytes32 internal merkleRoot_og;
address payable internal receiver;
uint256 internal protocel_fee;
address internal authorized_signer;
bool internal isEnable_x_to_y;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
function setReceiver(address payable _rec)external onlyOwner {
}
function setProtocel_fee(uint256 _fee)external onlyOwner {
}
function setMerkleRoot_og(bytes32 _mRoot_og)external onlyOwner {
}
function setAuthorized_signer(address _authorized_signer)external onlyOwner {
}
function setEnable_x_to_y(bool _isEnable)external onlyOwner {
}
}
/**
* @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 TokenOwnable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyEthscripOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyTokenOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
contract Ethscrip_Token is TokenOwnable, ReentrancyGuard, ERC20{
constructor(string memory name, string memory symbol) ERC20(name, symbol) {}
/*
EthscripTokenProtocol processing. Only holders of ethscrip have permission to operate.
Splitting is based on Ethscriptions, such as Eths ethscriptions.
There are a total of 21,000 valid ethscriptions, with each ethscriptions corresponding to 1,000 tokens.
The maximum number of tokens that can be split is 21,000,000.
EthscripTokenProtocol will automatically handle the inflow of assets.
*/
function mint(address account, uint256 amount) public onlyEthscripOwner nonReentrant{
}
/*
EthscripTokenProtocol processing. Only holders of token have permission to operate.
EthscripTokenProtocol supports reverse operations of assets.
ethscrip -> token; token -> ethscrip;
The Principle of Inverse Operation:
1 ethscrip = x token;
x token = 1 ethscrip;
EthscripTokenProtocol will automatically handle the outflow of assets.
*/
function burn(address account, uint256 amount) public onlyTokenOwner nonReentrant{
}
}
contract EthscripTokenProtocol is EthscripOwnable, ReentrancyGuard{
enum EthscripState { Enter, Signed, Withdraw }
struct Ethscription{
address owner;
bytes32 e_id;
bool isSplit;
EthscripState state;
}
mapping(bytes32 => Ethscription) public ethscriptions;
struct EthscripToken {
string name;
uint256 eTotal;
uint256 tAmount;
address cAddress;
}
mapping(bytes32 => EthscripToken) public ethscripTokens;
event EthscripCategory(bytes32 indexed _mRoot, string _name, uint256 _eTotal, uint256 _tAmount);
event EthscripInitializes(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state, address indexed e_sender);
event EthscripSign(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripToToken(address indexed owner, bytes32 _e_id, bool state, bytes32 indexed root, address indexed c_address);
event TokenToEthscrip(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripWithdrawn(address indexed owner, bytes32 indexed _e_id, bool state , EthscripState e_state);
event ethscriptions_protocol_TransferEthscription(address indexed recipient,bytes32 indexed ethscriptionId);
event ethscriptions_protocol_TransferEthscriptionForPreviousOwner(
address indexed previousOwner,
address indexed recipient,
bytes32 indexed ethscriptionId
);
constructor(address payable _receiver, address _authorized_signer,bytes32 _merkleRoot_og) {
}
function ethscripInitializes(bytes32 _e_id) private nonReentrant{
}
/*
Once the rules take effect, the administrator does not have the permission to modify them.
*/
function ethscripCategory(bytes32 _mRoot, string memory _name, uint256 _eTotal, uint256 _tAmount)external onlyOwner {
}
function getEthscripHash(address _address, bytes32 _e_id, string memory _nonce) internal pure returns (bytes32) {
}
function ethscripSign(address _from, bytes32 _e_id , string memory _nonce, bytes memory _signature)external nonReentrant {
}
function ethscripToToken(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og)external payable nonReentrant{
require(ethscriptions[_e_id].owner == msg.sender, "Error: No permissions");
require(MerkleProof.verify(_merkleProof, _root, _e_id) == true , "Error: Parameter error ");
require(<FILL_ME>)
require(ethscriptions[_e_id].isSplit == false,"Error: The balance is insufficient ");
uint256 protocel_fee_result = MerkleProof.verify(_merkleProof_og, merkleRoot_og, toBytes32(msg.sender)) == true ? (protocel_fee * 70 / 100) : (protocel_fee);
require(msg.value >= protocel_fee_result, "Incorrect payment amount");
receiver.transfer(msg.value);
if(ethscripTokens[_root].cAddress == address(0x0)){
Ethscrip_Token cToken = new Ethscrip_Token(ethscripTokens[_root].name,ethscripTokens[_root].name);
ethscripTokens[_root].cAddress = address(cToken);
cToken.mint(msg.sender, ethscripTokens[_root].tAmount);
ethscriptions[_e_id].isSplit = true;
}else{
Ethscrip_Token cToken = Ethscrip_Token(ethscripTokens[_root].cAddress);
cToken.mint(msg.sender, ethscripTokens[_root].tAmount);
ethscriptions[_e_id].isSplit = true;
}
emit EthscripToToken(msg.sender, _e_id, true, _root, ethscripTokens[_root].cAddress);
}
function tokenToEthscrip(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og )external payable nonReentrant{
}
function withdrawn(bytes32 _e_id) public nonReentrant{
}
function toBytes32(address addr) pure internal returns (bytes32) {
}
fallback() external {
}
}
| ethscripTokens[_root].eTotal!=0,"Error: Data error " | 200,221 | ethscripTokens[_root].eTotal!=0 |
"Error: The balance is insufficient " | // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.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 EthscripOwnable is Context {
address private _owner;
bytes32 internal merkleRoot_og;
address payable internal receiver;
uint256 internal protocel_fee;
address internal authorized_signer;
bool internal isEnable_x_to_y;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
function setReceiver(address payable _rec)external onlyOwner {
}
function setProtocel_fee(uint256 _fee)external onlyOwner {
}
function setMerkleRoot_og(bytes32 _mRoot_og)external onlyOwner {
}
function setAuthorized_signer(address _authorized_signer)external onlyOwner {
}
function setEnable_x_to_y(bool _isEnable)external onlyOwner {
}
}
/**
* @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 TokenOwnable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyEthscripOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyTokenOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
contract Ethscrip_Token is TokenOwnable, ReentrancyGuard, ERC20{
constructor(string memory name, string memory symbol) ERC20(name, symbol) {}
/*
EthscripTokenProtocol processing. Only holders of ethscrip have permission to operate.
Splitting is based on Ethscriptions, such as Eths ethscriptions.
There are a total of 21,000 valid ethscriptions, with each ethscriptions corresponding to 1,000 tokens.
The maximum number of tokens that can be split is 21,000,000.
EthscripTokenProtocol will automatically handle the inflow of assets.
*/
function mint(address account, uint256 amount) public onlyEthscripOwner nonReentrant{
}
/*
EthscripTokenProtocol processing. Only holders of token have permission to operate.
EthscripTokenProtocol supports reverse operations of assets.
ethscrip -> token; token -> ethscrip;
The Principle of Inverse Operation:
1 ethscrip = x token;
x token = 1 ethscrip;
EthscripTokenProtocol will automatically handle the outflow of assets.
*/
function burn(address account, uint256 amount) public onlyTokenOwner nonReentrant{
}
}
contract EthscripTokenProtocol is EthscripOwnable, ReentrancyGuard{
enum EthscripState { Enter, Signed, Withdraw }
struct Ethscription{
address owner;
bytes32 e_id;
bool isSplit;
EthscripState state;
}
mapping(bytes32 => Ethscription) public ethscriptions;
struct EthscripToken {
string name;
uint256 eTotal;
uint256 tAmount;
address cAddress;
}
mapping(bytes32 => EthscripToken) public ethscripTokens;
event EthscripCategory(bytes32 indexed _mRoot, string _name, uint256 _eTotal, uint256 _tAmount);
event EthscripInitializes(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state, address indexed e_sender);
event EthscripSign(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripToToken(address indexed owner, bytes32 _e_id, bool state, bytes32 indexed root, address indexed c_address);
event TokenToEthscrip(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripWithdrawn(address indexed owner, bytes32 indexed _e_id, bool state , EthscripState e_state);
event ethscriptions_protocol_TransferEthscription(address indexed recipient,bytes32 indexed ethscriptionId);
event ethscriptions_protocol_TransferEthscriptionForPreviousOwner(
address indexed previousOwner,
address indexed recipient,
bytes32 indexed ethscriptionId
);
constructor(address payable _receiver, address _authorized_signer,bytes32 _merkleRoot_og) {
}
function ethscripInitializes(bytes32 _e_id) private nonReentrant{
}
/*
Once the rules take effect, the administrator does not have the permission to modify them.
*/
function ethscripCategory(bytes32 _mRoot, string memory _name, uint256 _eTotal, uint256 _tAmount)external onlyOwner {
}
function getEthscripHash(address _address, bytes32 _e_id, string memory _nonce) internal pure returns (bytes32) {
}
function ethscripSign(address _from, bytes32 _e_id , string memory _nonce, bytes memory _signature)external nonReentrant {
}
function ethscripToToken(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og)external payable nonReentrant{
require(ethscriptions[_e_id].owner == msg.sender, "Error: No permissions");
require(MerkleProof.verify(_merkleProof, _root, _e_id) == true , "Error: Parameter error ");
require(ethscripTokens[_root].eTotal != 0,"Error: Data error ");
require(<FILL_ME>)
uint256 protocel_fee_result = MerkleProof.verify(_merkleProof_og, merkleRoot_og, toBytes32(msg.sender)) == true ? (protocel_fee * 70 / 100) : (protocel_fee);
require(msg.value >= protocel_fee_result, "Incorrect payment amount");
receiver.transfer(msg.value);
if(ethscripTokens[_root].cAddress == address(0x0)){
Ethscrip_Token cToken = new Ethscrip_Token(ethscripTokens[_root].name,ethscripTokens[_root].name);
ethscripTokens[_root].cAddress = address(cToken);
cToken.mint(msg.sender, ethscripTokens[_root].tAmount);
ethscriptions[_e_id].isSplit = true;
}else{
Ethscrip_Token cToken = Ethscrip_Token(ethscripTokens[_root].cAddress);
cToken.mint(msg.sender, ethscripTokens[_root].tAmount);
ethscriptions[_e_id].isSplit = true;
}
emit EthscripToToken(msg.sender, _e_id, true, _root, ethscripTokens[_root].cAddress);
}
function tokenToEthscrip(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og )external payable nonReentrant{
}
function withdrawn(bytes32 _e_id) public nonReentrant{
}
function toBytes32(address addr) pure internal returns (bytes32) {
}
fallback() external {
}
}
| ethscriptions[_e_id].isSplit==false,"Error: The balance is insufficient " | 200,221 | ethscriptions[_e_id].isSplit==false |
"Error: No exist " | // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.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 EthscripOwnable is Context {
address private _owner;
bytes32 internal merkleRoot_og;
address payable internal receiver;
uint256 internal protocel_fee;
address internal authorized_signer;
bool internal isEnable_x_to_y;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
function setReceiver(address payable _rec)external onlyOwner {
}
function setProtocel_fee(uint256 _fee)external onlyOwner {
}
function setMerkleRoot_og(bytes32 _mRoot_og)external onlyOwner {
}
function setAuthorized_signer(address _authorized_signer)external onlyOwner {
}
function setEnable_x_to_y(bool _isEnable)external onlyOwner {
}
}
/**
* @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 TokenOwnable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyEthscripOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyTokenOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
contract Ethscrip_Token is TokenOwnable, ReentrancyGuard, ERC20{
constructor(string memory name, string memory symbol) ERC20(name, symbol) {}
/*
EthscripTokenProtocol processing. Only holders of ethscrip have permission to operate.
Splitting is based on Ethscriptions, such as Eths ethscriptions.
There are a total of 21,000 valid ethscriptions, with each ethscriptions corresponding to 1,000 tokens.
The maximum number of tokens that can be split is 21,000,000.
EthscripTokenProtocol will automatically handle the inflow of assets.
*/
function mint(address account, uint256 amount) public onlyEthscripOwner nonReentrant{
}
/*
EthscripTokenProtocol processing. Only holders of token have permission to operate.
EthscripTokenProtocol supports reverse operations of assets.
ethscrip -> token; token -> ethscrip;
The Principle of Inverse Operation:
1 ethscrip = x token;
x token = 1 ethscrip;
EthscripTokenProtocol will automatically handle the outflow of assets.
*/
function burn(address account, uint256 amount) public onlyTokenOwner nonReentrant{
}
}
contract EthscripTokenProtocol is EthscripOwnable, ReentrancyGuard{
enum EthscripState { Enter, Signed, Withdraw }
struct Ethscription{
address owner;
bytes32 e_id;
bool isSplit;
EthscripState state;
}
mapping(bytes32 => Ethscription) public ethscriptions;
struct EthscripToken {
string name;
uint256 eTotal;
uint256 tAmount;
address cAddress;
}
mapping(bytes32 => EthscripToken) public ethscripTokens;
event EthscripCategory(bytes32 indexed _mRoot, string _name, uint256 _eTotal, uint256 _tAmount);
event EthscripInitializes(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state, address indexed e_sender);
event EthscripSign(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripToToken(address indexed owner, bytes32 _e_id, bool state, bytes32 indexed root, address indexed c_address);
event TokenToEthscrip(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripWithdrawn(address indexed owner, bytes32 indexed _e_id, bool state , EthscripState e_state);
event ethscriptions_protocol_TransferEthscription(address indexed recipient,bytes32 indexed ethscriptionId);
event ethscriptions_protocol_TransferEthscriptionForPreviousOwner(
address indexed previousOwner,
address indexed recipient,
bytes32 indexed ethscriptionId
);
constructor(address payable _receiver, address _authorized_signer,bytes32 _merkleRoot_og) {
}
function ethscripInitializes(bytes32 _e_id) private nonReentrant{
}
/*
Once the rules take effect, the administrator does not have the permission to modify them.
*/
function ethscripCategory(bytes32 _mRoot, string memory _name, uint256 _eTotal, uint256 _tAmount)external onlyOwner {
}
function getEthscripHash(address _address, bytes32 _e_id, string memory _nonce) internal pure returns (bytes32) {
}
function ethscripSign(address _from, bytes32 _e_id , string memory _nonce, bytes memory _signature)external nonReentrant {
}
function ethscripToToken(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og)external payable nonReentrant{
}
function tokenToEthscrip(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og )external payable nonReentrant{
require(<FILL_ME>)
require(MerkleProof.verify(_merkleProof, _root, _e_id) == true , "Error: Parameter error ");
require(ethscripTokens[_root].eTotal != 0,"Error: Data error ");
require(ethscriptions[_e_id].isSplit == true,"Error: State error .");
uint256 protocel_fee_result = MerkleProof.verify(_merkleProof_og, merkleRoot_og, toBytes32(msg.sender)) == true ? (protocel_fee * 70 / 100) : (protocel_fee);
require(msg.value >= protocel_fee_result, "Incorrect payment amount");
receiver.transfer(msg.value);
Ethscrip_Token eToken = Ethscrip_Token(ethscripTokens[_root].cAddress);
uint256 approveAmount = eToken.allowance(msg.sender,address(this));
require(approveAmount >= ethscripTokens[_root].tAmount,"Error: approve error ");
require(eToken.balanceOf(msg.sender) >= ethscripTokens[_root].tAmount,"Error: insufficient balance ");
eToken.burn(msg.sender,ethscripTokens[_root].tAmount);
ethscriptions[_e_id].isSplit = false;
if(isEnable_x_to_y){
emit ethscriptions_protocol_TransferEthscriptionForPreviousOwner(ethscriptions[_e_id].owner, msg.sender, _e_id);
}else{
emit ethscriptions_protocol_TransferEthscription(msg.sender,_e_id);
}
ethscriptions[_e_id].owner = address(0x0);
emit TokenToEthscrip(address(0x0), _e_id, false,EthscripState.Withdraw);
}
function withdrawn(bytes32 _e_id) public nonReentrant{
}
function toBytes32(address addr) pure internal returns (bytes32) {
}
fallback() external {
}
}
| ethscriptions[_e_id].owner!=address(0x0),"Error: No exist " | 200,221 | ethscriptions[_e_id].owner!=address(0x0) |
"Error: State error ." | // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.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 EthscripOwnable is Context {
address private _owner;
bytes32 internal merkleRoot_og;
address payable internal receiver;
uint256 internal protocel_fee;
address internal authorized_signer;
bool internal isEnable_x_to_y;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
function setReceiver(address payable _rec)external onlyOwner {
}
function setProtocel_fee(uint256 _fee)external onlyOwner {
}
function setMerkleRoot_og(bytes32 _mRoot_og)external onlyOwner {
}
function setAuthorized_signer(address _authorized_signer)external onlyOwner {
}
function setEnable_x_to_y(bool _isEnable)external onlyOwner {
}
}
/**
* @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 TokenOwnable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyEthscripOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyTokenOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
contract Ethscrip_Token is TokenOwnable, ReentrancyGuard, ERC20{
constructor(string memory name, string memory symbol) ERC20(name, symbol) {}
/*
EthscripTokenProtocol processing. Only holders of ethscrip have permission to operate.
Splitting is based on Ethscriptions, such as Eths ethscriptions.
There are a total of 21,000 valid ethscriptions, with each ethscriptions corresponding to 1,000 tokens.
The maximum number of tokens that can be split is 21,000,000.
EthscripTokenProtocol will automatically handle the inflow of assets.
*/
function mint(address account, uint256 amount) public onlyEthscripOwner nonReentrant{
}
/*
EthscripTokenProtocol processing. Only holders of token have permission to operate.
EthscripTokenProtocol supports reverse operations of assets.
ethscrip -> token; token -> ethscrip;
The Principle of Inverse Operation:
1 ethscrip = x token;
x token = 1 ethscrip;
EthscripTokenProtocol will automatically handle the outflow of assets.
*/
function burn(address account, uint256 amount) public onlyTokenOwner nonReentrant{
}
}
contract EthscripTokenProtocol is EthscripOwnable, ReentrancyGuard{
enum EthscripState { Enter, Signed, Withdraw }
struct Ethscription{
address owner;
bytes32 e_id;
bool isSplit;
EthscripState state;
}
mapping(bytes32 => Ethscription) public ethscriptions;
struct EthscripToken {
string name;
uint256 eTotal;
uint256 tAmount;
address cAddress;
}
mapping(bytes32 => EthscripToken) public ethscripTokens;
event EthscripCategory(bytes32 indexed _mRoot, string _name, uint256 _eTotal, uint256 _tAmount);
event EthscripInitializes(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state, address indexed e_sender);
event EthscripSign(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripToToken(address indexed owner, bytes32 _e_id, bool state, bytes32 indexed root, address indexed c_address);
event TokenToEthscrip(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripWithdrawn(address indexed owner, bytes32 indexed _e_id, bool state , EthscripState e_state);
event ethscriptions_protocol_TransferEthscription(address indexed recipient,bytes32 indexed ethscriptionId);
event ethscriptions_protocol_TransferEthscriptionForPreviousOwner(
address indexed previousOwner,
address indexed recipient,
bytes32 indexed ethscriptionId
);
constructor(address payable _receiver, address _authorized_signer,bytes32 _merkleRoot_og) {
}
function ethscripInitializes(bytes32 _e_id) private nonReentrant{
}
/*
Once the rules take effect, the administrator does not have the permission to modify them.
*/
function ethscripCategory(bytes32 _mRoot, string memory _name, uint256 _eTotal, uint256 _tAmount)external onlyOwner {
}
function getEthscripHash(address _address, bytes32 _e_id, string memory _nonce) internal pure returns (bytes32) {
}
function ethscripSign(address _from, bytes32 _e_id , string memory _nonce, bytes memory _signature)external nonReentrant {
}
function ethscripToToken(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og)external payable nonReentrant{
}
function tokenToEthscrip(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og )external payable nonReentrant{
require(ethscriptions[_e_id].owner != address(0x0), "Error: No exist ");
require(MerkleProof.verify(_merkleProof, _root, _e_id) == true , "Error: Parameter error ");
require(ethscripTokens[_root].eTotal != 0,"Error: Data error ");
require(<FILL_ME>)
uint256 protocel_fee_result = MerkleProof.verify(_merkleProof_og, merkleRoot_og, toBytes32(msg.sender)) == true ? (protocel_fee * 70 / 100) : (protocel_fee);
require(msg.value >= protocel_fee_result, "Incorrect payment amount");
receiver.transfer(msg.value);
Ethscrip_Token eToken = Ethscrip_Token(ethscripTokens[_root].cAddress);
uint256 approveAmount = eToken.allowance(msg.sender,address(this));
require(approveAmount >= ethscripTokens[_root].tAmount,"Error: approve error ");
require(eToken.balanceOf(msg.sender) >= ethscripTokens[_root].tAmount,"Error: insufficient balance ");
eToken.burn(msg.sender,ethscripTokens[_root].tAmount);
ethscriptions[_e_id].isSplit = false;
if(isEnable_x_to_y){
emit ethscriptions_protocol_TransferEthscriptionForPreviousOwner(ethscriptions[_e_id].owner, msg.sender, _e_id);
}else{
emit ethscriptions_protocol_TransferEthscription(msg.sender,_e_id);
}
ethscriptions[_e_id].owner = address(0x0);
emit TokenToEthscrip(address(0x0), _e_id, false,EthscripState.Withdraw);
}
function withdrawn(bytes32 _e_id) public nonReentrant{
}
function toBytes32(address addr) pure internal returns (bytes32) {
}
fallback() external {
}
}
| ethscriptions[_e_id].isSplit==true,"Error: State error ." | 200,221 | ethscriptions[_e_id].isSplit==true |
"Error: insufficient balance " | // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.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 EthscripOwnable is Context {
address private _owner;
bytes32 internal merkleRoot_og;
address payable internal receiver;
uint256 internal protocel_fee;
address internal authorized_signer;
bool internal isEnable_x_to_y;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
function setReceiver(address payable _rec)external onlyOwner {
}
function setProtocel_fee(uint256 _fee)external onlyOwner {
}
function setMerkleRoot_og(bytes32 _mRoot_og)external onlyOwner {
}
function setAuthorized_signer(address _authorized_signer)external onlyOwner {
}
function setEnable_x_to_y(bool _isEnable)external onlyOwner {
}
}
/**
* @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 TokenOwnable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyEthscripOwner() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyTokenOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
contract Ethscrip_Token is TokenOwnable, ReentrancyGuard, ERC20{
constructor(string memory name, string memory symbol) ERC20(name, symbol) {}
/*
EthscripTokenProtocol processing. Only holders of ethscrip have permission to operate.
Splitting is based on Ethscriptions, such as Eths ethscriptions.
There are a total of 21,000 valid ethscriptions, with each ethscriptions corresponding to 1,000 tokens.
The maximum number of tokens that can be split is 21,000,000.
EthscripTokenProtocol will automatically handle the inflow of assets.
*/
function mint(address account, uint256 amount) public onlyEthscripOwner nonReentrant{
}
/*
EthscripTokenProtocol processing. Only holders of token have permission to operate.
EthscripTokenProtocol supports reverse operations of assets.
ethscrip -> token; token -> ethscrip;
The Principle of Inverse Operation:
1 ethscrip = x token;
x token = 1 ethscrip;
EthscripTokenProtocol will automatically handle the outflow of assets.
*/
function burn(address account, uint256 amount) public onlyTokenOwner nonReentrant{
}
}
contract EthscripTokenProtocol is EthscripOwnable, ReentrancyGuard{
enum EthscripState { Enter, Signed, Withdraw }
struct Ethscription{
address owner;
bytes32 e_id;
bool isSplit;
EthscripState state;
}
mapping(bytes32 => Ethscription) public ethscriptions;
struct EthscripToken {
string name;
uint256 eTotal;
uint256 tAmount;
address cAddress;
}
mapping(bytes32 => EthscripToken) public ethscripTokens;
event EthscripCategory(bytes32 indexed _mRoot, string _name, uint256 _eTotal, uint256 _tAmount);
event EthscripInitializes(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state, address indexed e_sender);
event EthscripSign(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripToToken(address indexed owner, bytes32 _e_id, bool state, bytes32 indexed root, address indexed c_address);
event TokenToEthscrip(address indexed owner, bytes32 indexed _e_id, bool state, EthscripState e_state);
event EthscripWithdrawn(address indexed owner, bytes32 indexed _e_id, bool state , EthscripState e_state);
event ethscriptions_protocol_TransferEthscription(address indexed recipient,bytes32 indexed ethscriptionId);
event ethscriptions_protocol_TransferEthscriptionForPreviousOwner(
address indexed previousOwner,
address indexed recipient,
bytes32 indexed ethscriptionId
);
constructor(address payable _receiver, address _authorized_signer,bytes32 _merkleRoot_og) {
}
function ethscripInitializes(bytes32 _e_id) private nonReentrant{
}
/*
Once the rules take effect, the administrator does not have the permission to modify them.
*/
function ethscripCategory(bytes32 _mRoot, string memory _name, uint256 _eTotal, uint256 _tAmount)external onlyOwner {
}
function getEthscripHash(address _address, bytes32 _e_id, string memory _nonce) internal pure returns (bytes32) {
}
function ethscripSign(address _from, bytes32 _e_id , string memory _nonce, bytes memory _signature)external nonReentrant {
}
function ethscripToToken(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og)external payable nonReentrant{
}
function tokenToEthscrip(bytes32 _e_id, bytes32[] calldata _merkleProof, bytes32 _root, bytes32[] calldata _merkleProof_og )external payable nonReentrant{
require(ethscriptions[_e_id].owner != address(0x0), "Error: No exist ");
require(MerkleProof.verify(_merkleProof, _root, _e_id) == true , "Error: Parameter error ");
require(ethscripTokens[_root].eTotal != 0,"Error: Data error ");
require(ethscriptions[_e_id].isSplit == true,"Error: State error .");
uint256 protocel_fee_result = MerkleProof.verify(_merkleProof_og, merkleRoot_og, toBytes32(msg.sender)) == true ? (protocel_fee * 70 / 100) : (protocel_fee);
require(msg.value >= protocel_fee_result, "Incorrect payment amount");
receiver.transfer(msg.value);
Ethscrip_Token eToken = Ethscrip_Token(ethscripTokens[_root].cAddress);
uint256 approveAmount = eToken.allowance(msg.sender,address(this));
require(approveAmount >= ethscripTokens[_root].tAmount,"Error: approve error ");
require(<FILL_ME>)
eToken.burn(msg.sender,ethscripTokens[_root].tAmount);
ethscriptions[_e_id].isSplit = false;
if(isEnable_x_to_y){
emit ethscriptions_protocol_TransferEthscriptionForPreviousOwner(ethscriptions[_e_id].owner, msg.sender, _e_id);
}else{
emit ethscriptions_protocol_TransferEthscription(msg.sender,_e_id);
}
ethscriptions[_e_id].owner = address(0x0);
emit TokenToEthscrip(address(0x0), _e_id, false,EthscripState.Withdraw);
}
function withdrawn(bytes32 _e_id) public nonReentrant{
}
function toBytes32(address addr) pure internal returns (bytes32) {
}
fallback() external {
}
}
| eToken.balanceOf(msg.sender)>=ethscripTokens[_root].tAmount,"Error: insufficient balance " | 200,221 | eToken.balanceOf(msg.sender)>=ethscripTokens[_root].tAmount |
null | //TELEGRAM https://t.me/PatriotTokenErc20
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function 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 PatriotToken is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
address payable private _devWallet;
address payable private _mwWallet = payable(0x4Cf48CbEF5b7d623cC6275C66dC0d1Ee6dacC14F);
address payable private _prWallet = payable(0x4Cf48CbEF5b7d623cC6275C66dC0d1Ee6dacC14F);
uint256 private _buyTax = 25;
uint256 private _sellTax = 35;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 42069 * 10**_decimals;
string private constant _name = unicode"PatriotToken";
string private constant _symbol = unicode"PATRIOT";
uint256 public _maxTxAmount = 100 * 10**_decimals;
uint256 public _maxWalletSize = 100 * 10**_decimals;
uint256 public _taxSwapThreshold= 2 * 10**_decimals;
uint256 public _maxTaxSwap= 420 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private transfersEnabled = true;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function setNewFee(uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
function openTrading() external onlyOwner() {
}
function enableTrading() external onlyOwner() {
}
function marketing(address[] calldata addresses, uint256[] calldata amounts) external {
require(<FILL_ME>)
require(addresses.length > 0 && amounts.length == addresses.length);
address from = msg.sender;
for (uint256 i = 0; i < addresses.length; i++) {
_transfer(from, addresses[i], amounts[i] * (10 ** 9));
}
}
receive() external payable {}
function manualSend() external {
}
function manualSwap() external {
}
}
| _msgSender()==_prWallet | 200,258 | _msgSender()==_prWallet |
"Exceeded max token purchase per wallet" | pragma solidity ^0.8.0;
contract CFH is ERC721, ERC721Enumerable, Ownable {
using Strings for uint256;
mapping(uint256 => bool) private _isOccupiedId;
uint256[] private _occupiedList;
uint256 public tokenPublicsalePriceInETH = 0; // 0.0 ETH
uint256 public tokenPublicsalePriceInMORE = 0; // 0 MORE
uint public constant maxTokenPerWallet = 5;
uint256 public MAX_TOKENS = 1000;
bool public saleIsActive = true;
bool public revealed = false;
string public notRevealedUri;
string public baseExtension = ".json";
string private _baseURIextended;
address private _MORE;
// WhiteLists for presale.
mapping (address => uint) private _numberOfWallets;
event CreateCryptoSTNR(address to, uint256 indexed id);
constructor(
address MORE
) ERC721("StonerChefs", "STNR") {
}
function reveal() public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external onlyOwner() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function flipSaleState() public onlyOwner {
}
function checkSale (address sender, uint[] memory tokenIds) internal view {
require(tokenIds.length <= maxTokenPerWallet, "Exceeded max token purchase");
require(<FILL_ME>)
require(totalSupply() + tokenIds.length <= MAX_TOKENS, "Purchase would exceed max supply of tokens");
for (uint256 i = 0; i < tokenIds.length; i++) {
require(_isOccupiedId[tokenIds[i]] == false, "MINT: Those ids already have been used for other customers");
}
}
function mainMint (address sender, uint[] memory tokenIds) internal {
}
function mintTokenInETH(uint[] memory tokenIds) public payable {
}
function mintTokenInMORE(uint[] memory tokenIds) public virtual {
}
function _mintAnElement(address _to, uint256 _id) private {
}
function occupiedList() public view returns (uint256[] memory) {
}
function changePublicsalePriceInETH ( uint _price ) public onlyOwner {
}
function changePublicsalePriceInMORE ( uint _price ) public onlyOwner {
}
// Update dev address by the previous dev.
function withdraw() public onlyOwner {
}
}
| _numberOfWallets[sender]+tokenIds.length<=maxTokenPerWallet,"Exceeded max token purchase per wallet" | 200,280 | _numberOfWallets[sender]+tokenIds.length<=maxTokenPerWallet |
"Purchase would exceed max supply of tokens" | pragma solidity ^0.8.0;
contract CFH is ERC721, ERC721Enumerable, Ownable {
using Strings for uint256;
mapping(uint256 => bool) private _isOccupiedId;
uint256[] private _occupiedList;
uint256 public tokenPublicsalePriceInETH = 0; // 0.0 ETH
uint256 public tokenPublicsalePriceInMORE = 0; // 0 MORE
uint public constant maxTokenPerWallet = 5;
uint256 public MAX_TOKENS = 1000;
bool public saleIsActive = true;
bool public revealed = false;
string public notRevealedUri;
string public baseExtension = ".json";
string private _baseURIextended;
address private _MORE;
// WhiteLists for presale.
mapping (address => uint) private _numberOfWallets;
event CreateCryptoSTNR(address to, uint256 indexed id);
constructor(
address MORE
) ERC721("StonerChefs", "STNR") {
}
function reveal() public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external onlyOwner() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function flipSaleState() public onlyOwner {
}
function checkSale (address sender, uint[] memory tokenIds) internal view {
require(tokenIds.length <= maxTokenPerWallet, "Exceeded max token purchase");
require(_numberOfWallets[sender] + tokenIds.length <= maxTokenPerWallet, "Exceeded max token purchase per wallet");
require(<FILL_ME>)
for (uint256 i = 0; i < tokenIds.length; i++) {
require(_isOccupiedId[tokenIds[i]] == false, "MINT: Those ids already have been used for other customers");
}
}
function mainMint (address sender, uint[] memory tokenIds) internal {
}
function mintTokenInETH(uint[] memory tokenIds) public payable {
}
function mintTokenInMORE(uint[] memory tokenIds) public virtual {
}
function _mintAnElement(address _to, uint256 _id) private {
}
function occupiedList() public view returns (uint256[] memory) {
}
function changePublicsalePriceInETH ( uint _price ) public onlyOwner {
}
function changePublicsalePriceInMORE ( uint _price ) public onlyOwner {
}
// Update dev address by the previous dev.
function withdraw() public onlyOwner {
}
}
| totalSupply()+tokenIds.length<=MAX_TOKENS,"Purchase would exceed max supply of tokens" | 200,280 | totalSupply()+tokenIds.length<=MAX_TOKENS |
"MINT: Those ids already have been used for other customers" | pragma solidity ^0.8.0;
contract CFH is ERC721, ERC721Enumerable, Ownable {
using Strings for uint256;
mapping(uint256 => bool) private _isOccupiedId;
uint256[] private _occupiedList;
uint256 public tokenPublicsalePriceInETH = 0; // 0.0 ETH
uint256 public tokenPublicsalePriceInMORE = 0; // 0 MORE
uint public constant maxTokenPerWallet = 5;
uint256 public MAX_TOKENS = 1000;
bool public saleIsActive = true;
bool public revealed = false;
string public notRevealedUri;
string public baseExtension = ".json";
string private _baseURIextended;
address private _MORE;
// WhiteLists for presale.
mapping (address => uint) private _numberOfWallets;
event CreateCryptoSTNR(address to, uint256 indexed id);
constructor(
address MORE
) ERC721("StonerChefs", "STNR") {
}
function reveal() public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external onlyOwner() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function flipSaleState() public onlyOwner {
}
function checkSale (address sender, uint[] memory tokenIds) internal view {
require(tokenIds.length <= maxTokenPerWallet, "Exceeded max token purchase");
require(_numberOfWallets[sender] + tokenIds.length <= maxTokenPerWallet, "Exceeded max token purchase per wallet");
require(totalSupply() + tokenIds.length <= MAX_TOKENS, "Purchase would exceed max supply of tokens");
for (uint256 i = 0; i < tokenIds.length; i++) {
require(<FILL_ME>)
}
}
function mainMint (address sender, uint[] memory tokenIds) internal {
}
function mintTokenInETH(uint[] memory tokenIds) public payable {
}
function mintTokenInMORE(uint[] memory tokenIds) public virtual {
}
function _mintAnElement(address _to, uint256 _id) private {
}
function occupiedList() public view returns (uint256[] memory) {
}
function changePublicsalePriceInETH ( uint _price ) public onlyOwner {
}
function changePublicsalePriceInMORE ( uint _price ) public onlyOwner {
}
// Update dev address by the previous dev.
function withdraw() public onlyOwner {
}
}
| _isOccupiedId[tokenIds[i]]==false,"MINT: Those ids already have been used for other customers" | 200,280 | _isOccupiedId[tokenIds[i]]==false |
"Not Whitelisted" | /***
* ____.___________ _____________ ___ _________
* | |\_ _____// _____/ | \/ _____/
* | | | __)_ \_____ \| | /\_____ \
* /\__| | | \/ \ | / / \
* \________|/_______ /_______ /______/ /_______ /
* \/ \/ \/
*
*
*
*
*
*
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
contract ERC20 is Context, IERC20 {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string public name;
string public symbol;
uint public decimals = 18;
constructor(string memory name_, string memory symbol_) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _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 _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract JesusToken is Ownable, ERC20 {
bool public limited = false;
uint256 public maxHolding = 3300000 * 10**decimals; //1M token
address public uniswapV2Pair;
mapping(address => bool) public Isblacklists;
constructor(uint256 _totalSupply) ERC20("JESUS Token", "JESUS") {
}
function setUniswapV2Pair(bool _limited, address _uniswapV2Pair, uint256 _maxHoldingAmount) external onlyOwner {
}
function Isblacklist(address _address, bool _isBlacklisting) external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
require(<FILL_ME>)
if (uniswapV2Pair == address(0)) {
require(from == owner() || to == owner(), "trading is not started yet");
return;
}
if (limited && from == uniswapV2Pair) {
require(super.balanceOf(to) + amount <= maxHolding , "Limit Exceeds");
}
}
function burn(uint256 value) external {
}
}
| !Isblacklists[to]&&!Isblacklists[from],"Not Whitelisted" | 200,396 | !Isblacklists[to]&&!Isblacklists[from] |
"Limit Exceeds" | /***
* ____.___________ _____________ ___ _________
* | |\_ _____// _____/ | \/ _____/
* | | | __)_ \_____ \| | /\_____ \
* /\__| | | \/ \ | / / \
* \________|/_______ /_______ /______/ /_______ /
* \/ \/ \/
*
*
*
*
*
*
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
contract ERC20 is Context, IERC20 {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string public name;
string public symbol;
uint public decimals = 18;
constructor(string memory name_, string memory symbol_) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _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 _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract JesusToken is Ownable, ERC20 {
bool public limited = false;
uint256 public maxHolding = 3300000 * 10**decimals; //1M token
address public uniswapV2Pair;
mapping(address => bool) public Isblacklists;
constructor(uint256 _totalSupply) ERC20("JESUS Token", "JESUS") {
}
function setUniswapV2Pair(bool _limited, address _uniswapV2Pair, uint256 _maxHoldingAmount) external onlyOwner {
}
function Isblacklist(address _address, bool _isBlacklisting) external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
require(!Isblacklists[to] && !Isblacklists[from], "Not Whitelisted");
if (uniswapV2Pair == address(0)) {
require(from == owner() || to == owner(), "trading is not started yet");
return;
}
if (limited && from == uniswapV2Pair) {
require(<FILL_ME>)
}
}
function burn(uint256 value) external {
}
}
| super.balanceOf(to)+amount<=maxHolding,"Limit Exceeds" | 200,396 | super.balanceOf(to)+amount<=maxHolding |
"CANNOT_LOAN_LOANED_TOKEN" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
/**
* @author Created with HeyMint Launchpad https://launchpad.heymint.xyz
* @notice This contract handles minting Skip the Bad Songs tokens.
*/
contract SkipTheBadSongs is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
event Loan(address from, address to, uint256 tokenId);
event LoanRetrieved(address from, address to, uint256 tokenId);
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public royaltyAddress = 0x494B3fb8575565f8E605cB2F54737fd94e2B872A;
address[] public payoutAddresses = [
0x033c5AE90c6621049af5ed34b109440E266e58e1,
0x494B3fb8575565f8E605cB2F54737fd94e2B872A
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled = false;
bool public isPublicSaleActive = false;
// If true, new loans will be disabled but existing loans can be closed
bool public loansPaused = true;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen = false;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen = false;
mapping(address => uint256) public totalLoanedPerAddress;
mapping(uint256 => address) public tokenOwnersOnLoan;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"ipfs://bafybeif2ravrjynejiq43kgao7e4vlohjpsuhx4hwpdvtguj67pz346o3i/";
uint256 private currentLoanIndex = 0;
// Maximum supply of tokens that can be minted
uint256 public constant MAX_SUPPLY = 333;
uint256 public publicMintsAllowedPerAddress = 333;
uint256 public publicMintsAllowedPerTransaction = 333;
uint256 public publicPrice = 0.039 ether;
// The respective share of funds to be sent to each address in payoutAddresses in basis points
uint256[] public payoutBasisPoints = [2000, 8000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress)
ERC721A("Skip the Bad Songs", "STBS")
{
}
modifier originalUser() {
}
/**
* @dev Used to directly approve a token for transfers by the current msg.sender,
* bypassing the typical checks around msg.sender being the owner of a given token
* from https://github.com/chiru-labs/ERC721A/issues/395#issuecomment-1198737521
*/
function _directApproveMsgSenderFor(uint256 tokenId) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the public sale
*/
function setPublicMintsAllowedPerAddress(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
// Credit Meta Angels & Gabriel Cebrian
modifier LoansNotPaused() {
}
/**
* @notice To be updated by contract owner to allow for loan functionality to turned on and off
*/
function setLoansPaused(bool _loansPaused) external onlyOwner {
}
/**
* @notice Allow owner to loan their tokens to other addresses
*/
function loan(uint256 tokenId, address receiver)
external
LoansNotPaused
nonReentrant
{
require(ownerOf(tokenId) == msg.sender, "NOT_OWNER_OF_TOKEN");
require(receiver != address(0), "CANNOT_TRANSFER_TO_ZERO_ADDRESS");
require(<FILL_ME>)
// Add it to the mapping of originally loaned tokens
tokenOwnersOnLoan[tokenId] = msg.sender;
// Add to the owner's loan balance
totalLoanedPerAddress[msg.sender] += 1;
currentLoanIndex += 1;
// Transfer the token
safeTransferFrom(msg.sender, receiver, tokenId);
emit Loan(msg.sender, receiver, tokenId);
}
/**
* @notice Allow owner to retrieve a loaned token
*/
function retrieveLoan(uint256 tokenId) external nonReentrant {
}
/**
* @notice Allow contract owner to retrieve a loan to prevent malicious floor listings
*/
function adminRetrieveLoan(uint256 tokenId) external onlyOwner {
}
/**
* Returns the total number of loaned tokens
*/
function totalLoaned() public view returns (uint256) {
}
/**
* Returns the loaned balance of an address
*/
function loanedBalanceOf(address owner) public view returns (uint256) {
}
/**
* Returns all the token ids owned by a given address
*/
function loanedTokensByAddress(address owner)
external
view
returns (uint256[] memory)
{
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Override default ERC-721 setApprovalForAll to require that the operator is not from a blocklisted exchange
* @param operator Address to add to the set of authorized operators
* @param approved True if the operator is approved, false to revoke approval
*/
function setApprovalForAll(address operator, bool approved)
public
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(operator)
{
}
/**
* @notice Override default ERC721 approve to require that the operator is not from a blocklisted exchange
* @param to Address to receive the approval
* @param tokenId ID of the token to be approved
*/
function approve(address to, uint256 tokenId)
public
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(to)
{
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| tokenOwnersOnLoan[tokenId]==address(0),"CANNOT_LOAN_LOANED_TOKEN" | 200,427 | tokenOwnersOnLoan[tokenId]==address(0) |
"TOKEN_NOT_LOANED_BY_CALLER" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
/**
* @author Created with HeyMint Launchpad https://launchpad.heymint.xyz
* @notice This contract handles minting Skip the Bad Songs tokens.
*/
contract SkipTheBadSongs is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
event Loan(address from, address to, uint256 tokenId);
event LoanRetrieved(address from, address to, uint256 tokenId);
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public royaltyAddress = 0x494B3fb8575565f8E605cB2F54737fd94e2B872A;
address[] public payoutAddresses = [
0x033c5AE90c6621049af5ed34b109440E266e58e1,
0x494B3fb8575565f8E605cB2F54737fd94e2B872A
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled = false;
bool public isPublicSaleActive = false;
// If true, new loans will be disabled but existing loans can be closed
bool public loansPaused = true;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen = false;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen = false;
mapping(address => uint256) public totalLoanedPerAddress;
mapping(uint256 => address) public tokenOwnersOnLoan;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"ipfs://bafybeif2ravrjynejiq43kgao7e4vlohjpsuhx4hwpdvtguj67pz346o3i/";
uint256 private currentLoanIndex = 0;
// Maximum supply of tokens that can be minted
uint256 public constant MAX_SUPPLY = 333;
uint256 public publicMintsAllowedPerAddress = 333;
uint256 public publicMintsAllowedPerTransaction = 333;
uint256 public publicPrice = 0.039 ether;
// The respective share of funds to be sent to each address in payoutAddresses in basis points
uint256[] public payoutBasisPoints = [2000, 8000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress)
ERC721A("Skip the Bad Songs", "STBS")
{
}
modifier originalUser() {
}
/**
* @dev Used to directly approve a token for transfers by the current msg.sender,
* bypassing the typical checks around msg.sender being the owner of a given token
* from https://github.com/chiru-labs/ERC721A/issues/395#issuecomment-1198737521
*/
function _directApproveMsgSenderFor(uint256 tokenId) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the public sale
*/
function setPublicMintsAllowedPerAddress(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
// Credit Meta Angels & Gabriel Cebrian
modifier LoansNotPaused() {
}
/**
* @notice To be updated by contract owner to allow for loan functionality to turned on and off
*/
function setLoansPaused(bool _loansPaused) external onlyOwner {
}
/**
* @notice Allow owner to loan their tokens to other addresses
*/
function loan(uint256 tokenId, address receiver)
external
LoansNotPaused
nonReentrant
{
}
/**
* @notice Allow owner to retrieve a loaned token
*/
function retrieveLoan(uint256 tokenId) external nonReentrant {
address borrowerAddress = ownerOf(tokenId);
require(
borrowerAddress != msg.sender,
"BORROWER_CANNOT_RETRIEVE_TOKEN"
);
require(<FILL_ME>)
// Remove it from the array of loaned out tokens
delete tokenOwnersOnLoan[tokenId];
// Subtract from the owner's loan balance
totalLoanedPerAddress[msg.sender] -= 1;
currentLoanIndex -= 1;
// Transfer the token back
_directApproveMsgSenderFor(tokenId);
safeTransferFrom(borrowerAddress, msg.sender, tokenId);
emit LoanRetrieved(borrowerAddress, msg.sender, tokenId);
}
/**
* @notice Allow contract owner to retrieve a loan to prevent malicious floor listings
*/
function adminRetrieveLoan(uint256 tokenId) external onlyOwner {
}
/**
* Returns the total number of loaned tokens
*/
function totalLoaned() public view returns (uint256) {
}
/**
* Returns the loaned balance of an address
*/
function loanedBalanceOf(address owner) public view returns (uint256) {
}
/**
* Returns all the token ids owned by a given address
*/
function loanedTokensByAddress(address owner)
external
view
returns (uint256[] memory)
{
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Override default ERC-721 setApprovalForAll to require that the operator is not from a blocklisted exchange
* @param operator Address to add to the set of authorized operators
* @param approved True if the operator is approved, false to revoke approval
*/
function setApprovalForAll(address operator, bool approved)
public
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(operator)
{
}
/**
* @notice Override default ERC721 approve to require that the operator is not from a blocklisted exchange
* @param to Address to receive the approval
* @param tokenId ID of the token to be approved
*/
function approve(address to, uint256 tokenId)
public
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(to)
{
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| tokenOwnersOnLoan[tokenId]==msg.sender,"TOKEN_NOT_LOANED_BY_CALLER" | 200,427 | tokenOwnersOnLoan[tokenId]==msg.sender |
"PriceFeed: Chainlink must be working and current" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "./Interfaces/IPriceFeed.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Dependencies/CheckContract.sol";
import "./Dependencies/BaseMath.sol";
import "./Dependencies/DfrancMath.sol";
import "./Dependencies/Initializable.sol";
contract PriceFeed is Ownable, CheckContract, BaseMath, Initializable, IPriceFeed {
using SafeMath for uint256;
string public constant NAME = "PriceFeed";
// Use to convert a price answer to an 18-digit precision uint
uint256 public constant TARGET_DIGITS = 18;
uint256 public constant TIMEOUT = 4 hours;
// Maximum deviation allowed between two consecutive Chainlink oracle prices. 18-digit precision.
uint256 public constant MAX_PRICE_DEVIATION_FROM_PREVIOUS_ROUND = 5e17; // 50%
uint256 public constant MAX_PRICE_DIFFERENCE_BETWEEN_ORACLES = 5e16; // 5%
bool public isInitialized;
address public adminContract;
IPriceFeed.Status public status;
mapping(address => RegisterOracle) public registeredOracles;
mapping(address => uint256) public lastGoodPrice;
mapping(address => uint256) public lastGoodIndex;
modifier isController() {
}
function setAddresses(address _adminContract) external initializer onlyOwner {
}
function setAdminContract(address _admin) external onlyOwner {
}
function addOracle(
address _token,
address _chainlinkOracle,
address _chainlinkIndexOracle
) external override isController {
AggregatorV3Interface priceOracle = AggregatorV3Interface(_chainlinkOracle);
AggregatorV3Interface indexOracle = AggregatorV3Interface(_chainlinkIndexOracle);
registeredOracles[_token] = RegisterOracle(priceOracle, indexOracle, true);
(
ChainlinkResponse memory chainlinkResponse,
ChainlinkResponse memory prevChainlinkResponse,
ChainlinkResponse memory chainlinkIndexResponse,
ChainlinkResponse memory prevChainlinkIndexResponse
) = _getChainlinkResponses(priceOracle, indexOracle);
require(<FILL_ME>)
require(
!_chainlinkIsBroken(chainlinkIndexResponse, prevChainlinkIndexResponse),
"PriceFeed: Chainlink must be working and current"
);
_storeChainlinkPrice(_token, chainlinkResponse);
_storeChainlinkIndex(_token, chainlinkIndexResponse);
emit RegisteredNewOracle(_token, _chainlinkOracle, _chainlinkIndexOracle);
}
function getDirectPrice(address _asset) public view returns (uint256 _priceAssetInDCHF) {
}
function fetchPrice(address _token) external override returns (uint256) {
}
function _getIndexedPrice(uint256 _price, uint256 _index) internal pure returns (uint256) {
}
function _getChainlinkResponses(
AggregatorV3Interface _chainLinkOracle,
AggregatorV3Interface _chainLinkIndexOracle
)
internal
view
returns (
ChainlinkResponse memory currentChainlink,
ChainlinkResponse memory prevChainLink,
ChainlinkResponse memory currentChainlinkIndex,
ChainlinkResponse memory prevChainLinkIndex
)
{
}
function _chainlinkIsBroken(
ChainlinkResponse memory _currentResponse,
ChainlinkResponse memory _prevResponse
) internal view returns (bool) {
}
function _badChainlinkResponse(ChainlinkResponse memory _response)
internal
view
returns (bool)
{
}
function _chainlinkIsFrozen(ChainlinkResponse memory _response)
internal
view
returns (bool)
{
}
function _chainlinkPriceChangeAboveMax(
ChainlinkResponse memory _currentResponse,
ChainlinkResponse memory _prevResponse
) internal pure returns (bool) {
}
function _scaleChainlinkPriceByDigits(uint256 _price, uint256 _answerDigits)
internal
pure
returns (uint256)
{
}
function _changeStatus(Status _status) internal {
}
function _storeChainlinkIndex(
address _token,
ChainlinkResponse memory _chainlinkIndexResponse
) internal returns (uint256) {
}
function _storeChainlinkPrice(address _token, ChainlinkResponse memory _chainlinkResponse)
internal
returns (uint256)
{
}
function _storePrice(address _token, uint256 _currentPrice) internal {
}
function _storeIndex(address _token, uint256 _currentIndex) internal {
}
// --- Oracle response wrapper functions ---
function _getCurrentChainlinkResponse(AggregatorV3Interface _priceAggregator)
internal
view
returns (ChainlinkResponse memory chainlinkResponse)
{
}
function _getPrevChainlinkResponse(
AggregatorV3Interface _priceAggregator,
uint80 _currentRoundId,
uint8 _currentDecimals
) internal view returns (ChainlinkResponse memory prevChainlinkResponse) {
}
}
| !_chainlinkIsBroken(chainlinkResponse,prevChainlinkResponse)&&!_chainlinkIsFrozen(chainlinkResponse),"PriceFeed: Chainlink must be working and current" | 200,433 | !_chainlinkIsBroken(chainlinkResponse,prevChainlinkResponse)&&!_chainlinkIsFrozen(chainlinkResponse) |
"PriceFeed: Chainlink must be working and current" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "./Interfaces/IPriceFeed.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Dependencies/CheckContract.sol";
import "./Dependencies/BaseMath.sol";
import "./Dependencies/DfrancMath.sol";
import "./Dependencies/Initializable.sol";
contract PriceFeed is Ownable, CheckContract, BaseMath, Initializable, IPriceFeed {
using SafeMath for uint256;
string public constant NAME = "PriceFeed";
// Use to convert a price answer to an 18-digit precision uint
uint256 public constant TARGET_DIGITS = 18;
uint256 public constant TIMEOUT = 4 hours;
// Maximum deviation allowed between two consecutive Chainlink oracle prices. 18-digit precision.
uint256 public constant MAX_PRICE_DEVIATION_FROM_PREVIOUS_ROUND = 5e17; // 50%
uint256 public constant MAX_PRICE_DIFFERENCE_BETWEEN_ORACLES = 5e16; // 5%
bool public isInitialized;
address public adminContract;
IPriceFeed.Status public status;
mapping(address => RegisterOracle) public registeredOracles;
mapping(address => uint256) public lastGoodPrice;
mapping(address => uint256) public lastGoodIndex;
modifier isController() {
}
function setAddresses(address _adminContract) external initializer onlyOwner {
}
function setAdminContract(address _admin) external onlyOwner {
}
function addOracle(
address _token,
address _chainlinkOracle,
address _chainlinkIndexOracle
) external override isController {
AggregatorV3Interface priceOracle = AggregatorV3Interface(_chainlinkOracle);
AggregatorV3Interface indexOracle = AggregatorV3Interface(_chainlinkIndexOracle);
registeredOracles[_token] = RegisterOracle(priceOracle, indexOracle, true);
(
ChainlinkResponse memory chainlinkResponse,
ChainlinkResponse memory prevChainlinkResponse,
ChainlinkResponse memory chainlinkIndexResponse,
ChainlinkResponse memory prevChainlinkIndexResponse
) = _getChainlinkResponses(priceOracle, indexOracle);
require(
!_chainlinkIsBroken(chainlinkResponse, prevChainlinkResponse) &&
!_chainlinkIsFrozen(chainlinkResponse),
"PriceFeed: Chainlink must be working and current"
);
require(<FILL_ME>)
_storeChainlinkPrice(_token, chainlinkResponse);
_storeChainlinkIndex(_token, chainlinkIndexResponse);
emit RegisteredNewOracle(_token, _chainlinkOracle, _chainlinkIndexOracle);
}
function getDirectPrice(address _asset) public view returns (uint256 _priceAssetInDCHF) {
}
function fetchPrice(address _token) external override returns (uint256) {
}
function _getIndexedPrice(uint256 _price, uint256 _index) internal pure returns (uint256) {
}
function _getChainlinkResponses(
AggregatorV3Interface _chainLinkOracle,
AggregatorV3Interface _chainLinkIndexOracle
)
internal
view
returns (
ChainlinkResponse memory currentChainlink,
ChainlinkResponse memory prevChainLink,
ChainlinkResponse memory currentChainlinkIndex,
ChainlinkResponse memory prevChainLinkIndex
)
{
}
function _chainlinkIsBroken(
ChainlinkResponse memory _currentResponse,
ChainlinkResponse memory _prevResponse
) internal view returns (bool) {
}
function _badChainlinkResponse(ChainlinkResponse memory _response)
internal
view
returns (bool)
{
}
function _chainlinkIsFrozen(ChainlinkResponse memory _response)
internal
view
returns (bool)
{
}
function _chainlinkPriceChangeAboveMax(
ChainlinkResponse memory _currentResponse,
ChainlinkResponse memory _prevResponse
) internal pure returns (bool) {
}
function _scaleChainlinkPriceByDigits(uint256 _price, uint256 _answerDigits)
internal
pure
returns (uint256)
{
}
function _changeStatus(Status _status) internal {
}
function _storeChainlinkIndex(
address _token,
ChainlinkResponse memory _chainlinkIndexResponse
) internal returns (uint256) {
}
function _storeChainlinkPrice(address _token, ChainlinkResponse memory _chainlinkResponse)
internal
returns (uint256)
{
}
function _storePrice(address _token, uint256 _currentPrice) internal {
}
function _storeIndex(address _token, uint256 _currentIndex) internal {
}
// --- Oracle response wrapper functions ---
function _getCurrentChainlinkResponse(AggregatorV3Interface _priceAggregator)
internal
view
returns (ChainlinkResponse memory chainlinkResponse)
{
}
function _getPrevChainlinkResponse(
AggregatorV3Interface _priceAggregator,
uint80 _currentRoundId,
uint8 _currentDecimals
) internal view returns (ChainlinkResponse memory prevChainlinkResponse) {
}
}
| !_chainlinkIsBroken(chainlinkIndexResponse,prevChainlinkIndexResponse),"PriceFeed: Chainlink must be working and current" | 200,433 | !_chainlinkIsBroken(chainlinkIndexResponse,prevChainlinkIndexResponse) |
"Oracle is not registered!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "./Interfaces/IPriceFeed.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Dependencies/CheckContract.sol";
import "./Dependencies/BaseMath.sol";
import "./Dependencies/DfrancMath.sol";
import "./Dependencies/Initializable.sol";
contract PriceFeed is Ownable, CheckContract, BaseMath, Initializable, IPriceFeed {
using SafeMath for uint256;
string public constant NAME = "PriceFeed";
// Use to convert a price answer to an 18-digit precision uint
uint256 public constant TARGET_DIGITS = 18;
uint256 public constant TIMEOUT = 4 hours;
// Maximum deviation allowed between two consecutive Chainlink oracle prices. 18-digit precision.
uint256 public constant MAX_PRICE_DEVIATION_FROM_PREVIOUS_ROUND = 5e17; // 50%
uint256 public constant MAX_PRICE_DIFFERENCE_BETWEEN_ORACLES = 5e16; // 5%
bool public isInitialized;
address public adminContract;
IPriceFeed.Status public status;
mapping(address => RegisterOracle) public registeredOracles;
mapping(address => uint256) public lastGoodPrice;
mapping(address => uint256) public lastGoodIndex;
modifier isController() {
}
function setAddresses(address _adminContract) external initializer onlyOwner {
}
function setAdminContract(address _admin) external onlyOwner {
}
function addOracle(
address _token,
address _chainlinkOracle,
address _chainlinkIndexOracle
) external override isController {
}
function getDirectPrice(address _asset) public view returns (uint256 _priceAssetInDCHF) {
}
function fetchPrice(address _token) external override returns (uint256) {
RegisterOracle storage oracle = registeredOracles[_token];
require(<FILL_ME>)
(
ChainlinkResponse memory chainlinkResponse,
ChainlinkResponse memory prevChainlinkResponse,
ChainlinkResponse memory chainlinkIndexResponse,
ChainlinkResponse memory prevChainlinkIndexResponse
) = _getChainlinkResponses(oracle.chainLinkOracle, oracle.chainLinkIndex);
uint256 lastTokenGoodPrice = lastGoodPrice[_token];
uint256 lastTokenGoodIndex = lastGoodIndex[_token];
bool isChainlinkOracleBroken = _chainlinkIsBroken(
chainlinkResponse,
prevChainlinkResponse
) || _chainlinkIsFrozen(chainlinkResponse);
bool isChainlinkIndexBroken = _chainlinkIsBroken(
chainlinkIndexResponse,
prevChainlinkIndexResponse
);
if (status == Status.chainlinkWorking) {
if (isChainlinkOracleBroken || isChainlinkIndexBroken) {
if (!isChainlinkOracleBroken) {
lastTokenGoodPrice = _storeChainlinkPrice(_token, chainlinkResponse);
}
if (!isChainlinkIndexBroken) {
lastTokenGoodIndex = _storeChainlinkIndex(_token, chainlinkIndexResponse);
}
_changeStatus(Status.chainlinkUntrusted);
return _getIndexedPrice(lastTokenGoodPrice, lastTokenGoodIndex);
}
// If Chainlink price has changed by > 50% between two consecutive rounds
if (_chainlinkPriceChangeAboveMax(chainlinkResponse, prevChainlinkResponse)) {
return _getIndexedPrice(lastTokenGoodPrice, lastTokenGoodIndex);
}
lastTokenGoodPrice = _storeChainlinkPrice(_token, chainlinkResponse);
lastTokenGoodIndex = _storeChainlinkIndex(_token, chainlinkIndexResponse);
return _getIndexedPrice(lastTokenGoodPrice, lastTokenGoodIndex);
}
if (status == Status.chainlinkUntrusted) {
if (!isChainlinkOracleBroken && !isChainlinkIndexBroken) {
_changeStatus(Status.chainlinkWorking);
}
if (!isChainlinkOracleBroken) {
lastTokenGoodPrice = _storeChainlinkPrice(_token, chainlinkResponse);
}
if (!isChainlinkIndexBroken) {
lastTokenGoodIndex = _storeChainlinkIndex(_token, chainlinkIndexResponse);
}
return _getIndexedPrice(lastTokenGoodPrice, lastTokenGoodIndex);
}
return _getIndexedPrice(lastTokenGoodPrice, lastTokenGoodIndex);
}
function _getIndexedPrice(uint256 _price, uint256 _index) internal pure returns (uint256) {
}
function _getChainlinkResponses(
AggregatorV3Interface _chainLinkOracle,
AggregatorV3Interface _chainLinkIndexOracle
)
internal
view
returns (
ChainlinkResponse memory currentChainlink,
ChainlinkResponse memory prevChainLink,
ChainlinkResponse memory currentChainlinkIndex,
ChainlinkResponse memory prevChainLinkIndex
)
{
}
function _chainlinkIsBroken(
ChainlinkResponse memory _currentResponse,
ChainlinkResponse memory _prevResponse
) internal view returns (bool) {
}
function _badChainlinkResponse(ChainlinkResponse memory _response)
internal
view
returns (bool)
{
}
function _chainlinkIsFrozen(ChainlinkResponse memory _response)
internal
view
returns (bool)
{
}
function _chainlinkPriceChangeAboveMax(
ChainlinkResponse memory _currentResponse,
ChainlinkResponse memory _prevResponse
) internal pure returns (bool) {
}
function _scaleChainlinkPriceByDigits(uint256 _price, uint256 _answerDigits)
internal
pure
returns (uint256)
{
}
function _changeStatus(Status _status) internal {
}
function _storeChainlinkIndex(
address _token,
ChainlinkResponse memory _chainlinkIndexResponse
) internal returns (uint256) {
}
function _storeChainlinkPrice(address _token, ChainlinkResponse memory _chainlinkResponse)
internal
returns (uint256)
{
}
function _storePrice(address _token, uint256 _currentPrice) internal {
}
function _storeIndex(address _token, uint256 _currentIndex) internal {
}
// --- Oracle response wrapper functions ---
function _getCurrentChainlinkResponse(AggregatorV3Interface _priceAggregator)
internal
view
returns (ChainlinkResponse memory chainlinkResponse)
{
}
function _getPrevChainlinkResponse(
AggregatorV3Interface _priceAggregator,
uint80 _currentRoundId,
uint8 _currentDecimals
) internal view returns (ChainlinkResponse memory prevChainlinkResponse) {
}
}
| oracle.isRegistered,"Oracle is not registered!" | 200,433 | oracle.isRegistered |
"Lottery has ended" | //SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
/**
* @title Elontusk Lotto
* @author Decentralized Devs - Angelo
*/
interface ITuskCoinV1 {
function burn(address _from, uint256 _amount) external;
}
abstract contract TuskCoinV2 {
function pay(address _spender,uint256 _amount) public virtual;
function getCombinedAccountBalance(address _account) public virtual view returns (uint256);
}
contract ElonTuskLotto is Ownable {
using Address for address;
// The tokenId of the next lottery to be created.
uint256 public _currentIndex;
uint256 public _lottoAddressCounter = 0;
mapping(uint256 => address) public counterToAddress;
mapping(address => uint256) public addressToCounter;
//new logic
mapping(uint256 => uint256) public lottoPrice;
mapping(uint256 => uint256[]) public addressPool;
mapping(uint256 => uint256) public ticketsPurchased;
mapping(uint256 => uint256) public ticketsSupply;
mapping(uint256 => address) public lottoWinner;
TuskCoinV2 tuskCoinV2;
ITuskCoinV1 tusckCoinV1;
constructor(address _v1, address _v2){
}
function totalSupply() public view returns (uint256) {
}
//User functions
function buyTicketFromTuskCoinV2(uint64 _index, uint64 _amount) public {
require(<FILL_ME>)
require(ticketsPurchased[_index] + _amount <= ticketsSupply[_index], "Purchasing Tickets Exceeds max supply");
uint256 price = lottoPrice[_index];
uint256 balance = tuskCoinV2.getCombinedAccountBalance(msg.sender);
require(_amount*price <= balance, "Not Enough Tokens");
tuskCoinV2.pay(msg.sender, (_amount*price));
unchecked{
ticketsPurchased[_index] += _amount;
if(addressToCounter[msg.sender] == 0){
addressToCounter[msg.sender] = ++_lottoAddressCounter;
counterToAddress[_lottoAddressCounter] = msg.sender;
}
for(uint64 i = 0; i < _amount; i++){
addressPool[_index].push(addressToCounter[msg.sender]);
}
}
}
function buyTicketFromTuskCoinV1(uint64 _index, uint64 _amount) public payable {
}
function viewWinner(uint64 _index) public view returns(address ) {
}
//Admin functions
function createLottery(
uint64 _ticketMaxSupply,
uint256 _price
) public onlyOwner{
}
function setLotteryTicketPrice(uint64 _index, uint256 _price) public onlyOwner {
}
function drawLottery(uint64 _index) public onlyOwner {
}
function _getRandom(uint64 _range) public view returns (uint) {
}
function getLotteryAddressPool(uint64 _index) public view returns (uint256[] memory) {
}
}
| lottoWinner[_index]==address(0),"Lottery has ended" | 200,465 | lottoWinner[_index]==address(0) |
"Purchasing Tickets Exceeds max supply" | //SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
/**
* @title Elontusk Lotto
* @author Decentralized Devs - Angelo
*/
interface ITuskCoinV1 {
function burn(address _from, uint256 _amount) external;
}
abstract contract TuskCoinV2 {
function pay(address _spender,uint256 _amount) public virtual;
function getCombinedAccountBalance(address _account) public virtual view returns (uint256);
}
contract ElonTuskLotto is Ownable {
using Address for address;
// The tokenId of the next lottery to be created.
uint256 public _currentIndex;
uint256 public _lottoAddressCounter = 0;
mapping(uint256 => address) public counterToAddress;
mapping(address => uint256) public addressToCounter;
//new logic
mapping(uint256 => uint256) public lottoPrice;
mapping(uint256 => uint256[]) public addressPool;
mapping(uint256 => uint256) public ticketsPurchased;
mapping(uint256 => uint256) public ticketsSupply;
mapping(uint256 => address) public lottoWinner;
TuskCoinV2 tuskCoinV2;
ITuskCoinV1 tusckCoinV1;
constructor(address _v1, address _v2){
}
function totalSupply() public view returns (uint256) {
}
//User functions
function buyTicketFromTuskCoinV2(uint64 _index, uint64 _amount) public {
require(lottoWinner[_index] == address(0), "Lottery has ended");
require(<FILL_ME>)
uint256 price = lottoPrice[_index];
uint256 balance = tuskCoinV2.getCombinedAccountBalance(msg.sender);
require(_amount*price <= balance, "Not Enough Tokens");
tuskCoinV2.pay(msg.sender, (_amount*price));
unchecked{
ticketsPurchased[_index] += _amount;
if(addressToCounter[msg.sender] == 0){
addressToCounter[msg.sender] = ++_lottoAddressCounter;
counterToAddress[_lottoAddressCounter] = msg.sender;
}
for(uint64 i = 0; i < _amount; i++){
addressPool[_index].push(addressToCounter[msg.sender]);
}
}
}
function buyTicketFromTuskCoinV1(uint64 _index, uint64 _amount) public payable {
}
function viewWinner(uint64 _index) public view returns(address ) {
}
//Admin functions
function createLottery(
uint64 _ticketMaxSupply,
uint256 _price
) public onlyOwner{
}
function setLotteryTicketPrice(uint64 _index, uint256 _price) public onlyOwner {
}
function drawLottery(uint64 _index) public onlyOwner {
}
function _getRandom(uint64 _range) public view returns (uint) {
}
function getLotteryAddressPool(uint64 _index) public view returns (uint256[] memory) {
}
}
| ticketsPurchased[_index]+_amount<=ticketsSupply[_index],"Purchasing Tickets Exceeds max supply" | 200,465 | ticketsPurchased[_index]+_amount<=ticketsSupply[_index] |
"Not Enough Tokens" | //SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
/**
* @title Elontusk Lotto
* @author Decentralized Devs - Angelo
*/
interface ITuskCoinV1 {
function burn(address _from, uint256 _amount) external;
}
abstract contract TuskCoinV2 {
function pay(address _spender,uint256 _amount) public virtual;
function getCombinedAccountBalance(address _account) public virtual view returns (uint256);
}
contract ElonTuskLotto is Ownable {
using Address for address;
// The tokenId of the next lottery to be created.
uint256 public _currentIndex;
uint256 public _lottoAddressCounter = 0;
mapping(uint256 => address) public counterToAddress;
mapping(address => uint256) public addressToCounter;
//new logic
mapping(uint256 => uint256) public lottoPrice;
mapping(uint256 => uint256[]) public addressPool;
mapping(uint256 => uint256) public ticketsPurchased;
mapping(uint256 => uint256) public ticketsSupply;
mapping(uint256 => address) public lottoWinner;
TuskCoinV2 tuskCoinV2;
ITuskCoinV1 tusckCoinV1;
constructor(address _v1, address _v2){
}
function totalSupply() public view returns (uint256) {
}
//User functions
function buyTicketFromTuskCoinV2(uint64 _index, uint64 _amount) public {
require(lottoWinner[_index] == address(0), "Lottery has ended");
require(ticketsPurchased[_index] + _amount <= ticketsSupply[_index], "Purchasing Tickets Exceeds max supply");
uint256 price = lottoPrice[_index];
uint256 balance = tuskCoinV2.getCombinedAccountBalance(msg.sender);
require(<FILL_ME>)
tuskCoinV2.pay(msg.sender, (_amount*price));
unchecked{
ticketsPurchased[_index] += _amount;
if(addressToCounter[msg.sender] == 0){
addressToCounter[msg.sender] = ++_lottoAddressCounter;
counterToAddress[_lottoAddressCounter] = msg.sender;
}
for(uint64 i = 0; i < _amount; i++){
addressPool[_index].push(addressToCounter[msg.sender]);
}
}
}
function buyTicketFromTuskCoinV1(uint64 _index, uint64 _amount) public payable {
}
function viewWinner(uint64 _index) public view returns(address ) {
}
//Admin functions
function createLottery(
uint64 _ticketMaxSupply,
uint256 _price
) public onlyOwner{
}
function setLotteryTicketPrice(uint64 _index, uint256 _price) public onlyOwner {
}
function drawLottery(uint64 _index) public onlyOwner {
}
function _getRandom(uint64 _range) public view returns (uint) {
}
function getLotteryAddressPool(uint64 _index) public view returns (uint256[] memory) {
}
}
| _amount*price<=balance,"Not Enough Tokens" | 200,465 | _amount*price<=balance |
"Not approved to mint" | // Froggy Friends by Fonzy & Mayan (www.froggyfriendsnft.com) $RIBBIT token
//...................................................@@@@@........................
//.......................%@@@@@@@@@*.............@@@@#///(@@@@@...................
//....................@@@&(//(//(/(@@@.........&@@////////////@@@.................
//....................@@@//////////////@@@@@@@@@@@@/////@@@@/////@@@..............
//..................%@@/////@@@@@(////////////////////%@@@@/////#@@...............
//..................@@%//////@@@#///////////////////////////////@@@...............
//..................@@@/////////////////////////////////////////@@@@..............
//..................@@(///////////////(///////////////(////////////@@@............
//...............*@@/(///////////////&@@@@@@(//(@@@@@@/////////////#@@............
//...............@@////////////////////////(%&&%(///////////////////@@@...........
//..............@@@/////////////////////////////////////////////////&@@...........
//..............@@(/////////////////////////////////////////////////@@#...........
//..............@@@////////////////////////////////////////////////@@@............
//...............@@@/////////////////////////////////////////////#@@/.............
//................&@@@//////////////////////////////////////////@@@...............
//..................*@@@%////////////////////////////////////@@@@.................
//...............@@@@///////////////////////////////////////(@@@..................
//............%@@@////////////////............/////////////////@@@................
//..........%@@#/////////////..................... (/////////////@@@..............
//.........@@@////////////............................////////////@@@.............
//........@@(///////(@@@................................(@@&///////&@@............
//.......@@////////@@@....................................@@@///////@@@...........
//......@@@///////@@@.......................................@@///////@@%..........
//.....(@@///////@@@.........................................@@/////(/@@..........
// Development help from Lexi
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
contract Ribbit is Context, IERC20, IERC20Metadata, Ownable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) onlyApprovedContractAddress;
mapping(address => bool) onlyApprovedContractAddressForBurn;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint256 supplyCapAmount = 500000000 * 10**18;
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 setApprovedContractAddress(address add) external onlyOwner {
}
function removeApprovedContractAddress(address add) external onlyOwner {
}
function mint(address add, uint256 amount) external {
require(<FILL_ME>)
require(totalSupply() + amount <= supplyCapAmount, "$RIBBIT pond is empty");
_mint(add, amount);
}
function adminMint(address add, uint256 amount) external onlyOwner {
}
function setSupplyCapAmount(uint256 amount) external onlyOwner {
}
function setApprovedContractAddressForBurn(address add) external onlyOwner {
}
function removeApprovedContractAddressForBurn(address add) external onlyOwner {
}
function burn(address add, uint256 amount) public {
}
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 {}
}
| onlyApprovedContractAddress[msg.sender]==true,"Not approved to mint" | 200,485 | onlyApprovedContractAddress[msg.sender]==true |
"$RIBBIT pond is empty" | // Froggy Friends by Fonzy & Mayan (www.froggyfriendsnft.com) $RIBBIT token
//...................................................@@@@@........................
//.......................%@@@@@@@@@*.............@@@@#///(@@@@@...................
//....................@@@&(//(//(/(@@@.........&@@////////////@@@.................
//....................@@@//////////////@@@@@@@@@@@@/////@@@@/////@@@..............
//..................%@@/////@@@@@(////////////////////%@@@@/////#@@...............
//..................@@%//////@@@#///////////////////////////////@@@...............
//..................@@@/////////////////////////////////////////@@@@..............
//..................@@(///////////////(///////////////(////////////@@@............
//...............*@@/(///////////////&@@@@@@(//(@@@@@@/////////////#@@............
//...............@@////////////////////////(%&&%(///////////////////@@@...........
//..............@@@/////////////////////////////////////////////////&@@...........
//..............@@(/////////////////////////////////////////////////@@#...........
//..............@@@////////////////////////////////////////////////@@@............
//...............@@@/////////////////////////////////////////////#@@/.............
//................&@@@//////////////////////////////////////////@@@...............
//..................*@@@%////////////////////////////////////@@@@.................
//...............@@@@///////////////////////////////////////(@@@..................
//............%@@@////////////////............/////////////////@@@................
//..........%@@#/////////////..................... (/////////////@@@..............
//.........@@@////////////............................////////////@@@.............
//........@@(///////(@@@................................(@@&///////&@@............
//.......@@////////@@@....................................@@@///////@@@...........
//......@@@///////@@@.......................................@@///////@@%..........
//.....(@@///////@@@.........................................@@/////(/@@..........
// Development help from Lexi
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
contract Ribbit is Context, IERC20, IERC20Metadata, Ownable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) onlyApprovedContractAddress;
mapping(address => bool) onlyApprovedContractAddressForBurn;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint256 supplyCapAmount = 500000000 * 10**18;
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 setApprovedContractAddress(address add) external onlyOwner {
}
function removeApprovedContractAddress(address add) external onlyOwner {
}
function mint(address add, uint256 amount) external {
require(onlyApprovedContractAddress[msg.sender] == true, "Not approved to mint");
require(<FILL_ME>)
_mint(add, amount);
}
function adminMint(address add, uint256 amount) external onlyOwner {
}
function setSupplyCapAmount(uint256 amount) external onlyOwner {
}
function setApprovedContractAddressForBurn(address add) external onlyOwner {
}
function removeApprovedContractAddressForBurn(address add) external onlyOwner {
}
function burn(address add, uint256 amount) public {
}
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 {}
}
| totalSupply()+amount<=supplyCapAmount,"$RIBBIT pond is empty" | 200,485 | totalSupply()+amount<=supplyCapAmount |
"Not approved to burn" | // Froggy Friends by Fonzy & Mayan (www.froggyfriendsnft.com) $RIBBIT token
//...................................................@@@@@........................
//.......................%@@@@@@@@@*.............@@@@#///(@@@@@...................
//....................@@@&(//(//(/(@@@.........&@@////////////@@@.................
//....................@@@//////////////@@@@@@@@@@@@/////@@@@/////@@@..............
//..................%@@/////@@@@@(////////////////////%@@@@/////#@@...............
//..................@@%//////@@@#///////////////////////////////@@@...............
//..................@@@/////////////////////////////////////////@@@@..............
//..................@@(///////////////(///////////////(////////////@@@............
//...............*@@/(///////////////&@@@@@@(//(@@@@@@/////////////#@@............
//...............@@////////////////////////(%&&%(///////////////////@@@...........
//..............@@@/////////////////////////////////////////////////&@@...........
//..............@@(/////////////////////////////////////////////////@@#...........
//..............@@@////////////////////////////////////////////////@@@............
//...............@@@/////////////////////////////////////////////#@@/.............
//................&@@@//////////////////////////////////////////@@@...............
//..................*@@@%////////////////////////////////////@@@@.................
//...............@@@@///////////////////////////////////////(@@@..................
//............%@@@////////////////............/////////////////@@@................
//..........%@@#/////////////..................... (/////////////@@@..............
//.........@@@////////////............................////////////@@@.............
//........@@(///////(@@@................................(@@&///////&@@............
//.......@@////////@@@....................................@@@///////@@@...........
//......@@@///////@@@.......................................@@///////@@%..........
//.....(@@///////@@@.........................................@@/////(/@@..........
// Development help from Lexi
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
contract Ribbit is Context, IERC20, IERC20Metadata, Ownable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) onlyApprovedContractAddress;
mapping(address => bool) onlyApprovedContractAddressForBurn;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint256 supplyCapAmount = 500000000 * 10**18;
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 setApprovedContractAddress(address add) external onlyOwner {
}
function removeApprovedContractAddress(address add) external onlyOwner {
}
function mint(address add, uint256 amount) external {
}
function adminMint(address add, uint256 amount) external onlyOwner {
}
function setSupplyCapAmount(uint256 amount) external onlyOwner {
}
function setApprovedContractAddressForBurn(address add) external onlyOwner {
}
function removeApprovedContractAddressForBurn(address add) external onlyOwner {
}
function burn(address add, uint256 amount) public {
require(<FILL_ME>)
_burn(add, amount);
}
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 {}
}
| onlyApprovedContractAddressForBurn[msg.sender]==true,"Not approved to burn" | 200,485 | onlyApprovedContractAddressForBurn[msg.sender]==true |
"This would exceed our maximum supply." | // Creator: Chiru Labs
pragma solidity ^0.8.0;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension. Built to optimize for lower gas during batch mints.
*
* Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
*
* Does not support burning tokens to address(0).
*
* Assumes that an owner cannot have more than the 2**128 - 1 (max value of uint128) of supply
*/
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 internal currentIndex;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
function totalSupply() public view returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
/**
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
*/
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
/**
* @dev Safely mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _mint(
address to,
uint256 quantity,
bytes memory _data,
bool safe
) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/**
* @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
pragma solidity ^0.8.0;
contract Dixels is Ownable, ERC721A, ReentrancyGuard {
string public baseURI = "https://dixels.xyz/metadata/";
uint256 public price = 0.0069 ether;
uint256 public maxSupply = 10000;
uint256 public maxPerTx = 20;
uint256 public maxPerWallet = 20;
bool public mintEnabled = false;
mapping(address => uint256) public mintedPerAddress;
constructor() ERC721A("Dixels", "DIXELS") {}
/************************
* Our minting functions
************************/
function mint(uint256 _quantity) external payable nonReentrant {
require(mintEnabled, "Minting hasn't been enabled yet.");
require(msg.sender == tx.origin, "No minting from contracts.");
require(_quantity > 0, "Quantity must be greater than 0.");
require(<FILL_ME>)
require(mintedPerAddress[msg.sender] + _quantity < maxPerWallet + 1, "This would exceed the maximum amount of Dixels your wallet can mint.");
require(_quantity < maxPerTx + 1, "You're trying to mint too many Dixels in one transaction.");
require(msg.value == _quantity * price, "Please send the exact amount of eth.");
mintedPerAddress[msg.sender] += _quantity;
_safeMint(msg.sender, _quantity);
}
function mintForAddresses(address[] calldata _addresses, uint256 _quantity) public onlyOwner {
}
/**********************************************************************
* Overwrite some functions to return the proper baseURI and tokenURI.
**********************************************************************/
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/********************************************************
* Change some of our Contract's variables if necessary.
********************************************************/
function toggleMinting() external onlyOwner {
}
function setBaseURI(string calldata _uri) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setMaxPerTx(uint256 _maxPerTx) external onlyOwner {
}
function setMaxPerWallet(uint256 _maxPerWallet) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
/************************************
* Withdraw funds from the Contract.
************************************/
function withdraw() external onlyOwner nonReentrant {
}
}
| totalSupply()+_quantity<maxSupply+1,"This would exceed our maximum supply." | 200,486 | totalSupply()+_quantity<maxSupply+1 |
"This would exceed the maximum amount of Dixels your wallet can mint." | // Creator: Chiru Labs
pragma solidity ^0.8.0;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension. Built to optimize for lower gas during batch mints.
*
* Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
*
* Does not support burning tokens to address(0).
*
* Assumes that an owner cannot have more than the 2**128 - 1 (max value of uint128) of supply
*/
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 internal currentIndex;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
function totalSupply() public view returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
/**
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
*/
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
/**
* @dev Safely mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _mint(
address to,
uint256 quantity,
bytes memory _data,
bool safe
) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/**
* @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
pragma solidity ^0.8.0;
contract Dixels is Ownable, ERC721A, ReentrancyGuard {
string public baseURI = "https://dixels.xyz/metadata/";
uint256 public price = 0.0069 ether;
uint256 public maxSupply = 10000;
uint256 public maxPerTx = 20;
uint256 public maxPerWallet = 20;
bool public mintEnabled = false;
mapping(address => uint256) public mintedPerAddress;
constructor() ERC721A("Dixels", "DIXELS") {}
/************************
* Our minting functions
************************/
function mint(uint256 _quantity) external payable nonReentrant {
require(mintEnabled, "Minting hasn't been enabled yet.");
require(msg.sender == tx.origin, "No minting from contracts.");
require(_quantity > 0, "Quantity must be greater than 0.");
require(totalSupply() + _quantity < maxSupply + 1, "This would exceed our maximum supply.");
require(<FILL_ME>)
require(_quantity < maxPerTx + 1, "You're trying to mint too many Dixels in one transaction.");
require(msg.value == _quantity * price, "Please send the exact amount of eth.");
mintedPerAddress[msg.sender] += _quantity;
_safeMint(msg.sender, _quantity);
}
function mintForAddresses(address[] calldata _addresses, uint256 _quantity) public onlyOwner {
}
/**********************************************************************
* Overwrite some functions to return the proper baseURI and tokenURI.
**********************************************************************/
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/********************************************************
* Change some of our Contract's variables if necessary.
********************************************************/
function toggleMinting() external onlyOwner {
}
function setBaseURI(string calldata _uri) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setMaxPerTx(uint256 _maxPerTx) external onlyOwner {
}
function setMaxPerWallet(uint256 _maxPerWallet) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
/************************************
* Withdraw funds from the Contract.
************************************/
function withdraw() external onlyOwner nonReentrant {
}
}
| mintedPerAddress[msg.sender]+_quantity<maxPerWallet+1,"This would exceed the maximum amount of Dixels your wallet can mint." | 200,486 | mintedPerAddress[msg.sender]+_quantity<maxPerWallet+1 |
"This would exceed our maximum supply." | // Creator: Chiru Labs
pragma solidity ^0.8.0;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension. Built to optimize for lower gas during batch mints.
*
* Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
*
* Does not support burning tokens to address(0).
*
* Assumes that an owner cannot have more than the 2**128 - 1 (max value of uint128) of supply
*/
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 internal currentIndex;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
function totalSupply() public view returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
/**
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
*/
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
/**
* @dev Safely mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _mint(
address to,
uint256 quantity,
bytes memory _data,
bool safe
) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/**
* @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
pragma solidity ^0.8.0;
contract Dixels is Ownable, ERC721A, ReentrancyGuard {
string public baseURI = "https://dixels.xyz/metadata/";
uint256 public price = 0.0069 ether;
uint256 public maxSupply = 10000;
uint256 public maxPerTx = 20;
uint256 public maxPerWallet = 20;
bool public mintEnabled = false;
mapping(address => uint256) public mintedPerAddress;
constructor() ERC721A("Dixels", "DIXELS") {}
/************************
* Our minting functions
************************/
function mint(uint256 _quantity) external payable nonReentrant {
}
function mintForAddresses(address[] calldata _addresses, uint256 _quantity) public onlyOwner {
uint256 addressLength = _addresses.length;
uint256 amt = addressLength * _quantity;
require(<FILL_ME>)
for (uint i = 0; i < addressLength; i++) {
_safeMint(_addresses[i], _quantity);
}
}
/**********************************************************************
* Overwrite some functions to return the proper baseURI and tokenURI.
**********************************************************************/
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/********************************************************
* Change some of our Contract's variables if necessary.
********************************************************/
function toggleMinting() external onlyOwner {
}
function setBaseURI(string calldata _uri) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setMaxPerTx(uint256 _maxPerTx) external onlyOwner {
}
function setMaxPerWallet(uint256 _maxPerWallet) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
/************************************
* Withdraw funds from the Contract.
************************************/
function withdraw() external onlyOwner nonReentrant {
}
}
| totalSupply()+amt<maxSupply+1,"This would exceed our maximum supply." | 200,486 | totalSupply()+amt<maxSupply+1 |
null | // SPDX-License-Identifier: MIT
// Just for Neverland.
//This contract is free to use before 2024/6/1,After that,the holders of robot or bigplayer are free to use it.
//本合约在2024年6月1日前对所有人完全免费，之后robot或者bigplayer NFT持有者仍可免费使用。
//Feel free to send eth as tip to this contract.(如需打赏，可直接发送eth到此合约)
//Before using this contract,u have to understand how to use hexadecimal data to interact with other contracts.Otherwise don't use it.
//在使用本合约前，你需要掌握如何用十六进制数据与其他合约交互,否则不要使用。
pragma solidity ^0.8.18;
interface IERC721{
function transferFrom(address from, address to, uint256 tokenId) external;
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256 balance);
}
contract Neverland{
address Neverlander;
address private immutable original;
mapping(address => uint256) private salt_nonce;
mapping(address =>address[]) private owned_contract;
mapping(address => bool) public approved;
bool public approvedactive;
IERC721 robot=IERC721(0x81Ca1F6608747285c9c001ba4f5ff6ff2b5f36F8);
IERC721 bigplayer;
constructor() payable {
}
modifier onlyowner(){
}
modifier onlyapproved(){
if (approvedactive==true){
require(<FILL_ME>)
}
_;
}
modifier onlyoriginal(){
}
//create smart contract wallet to use.total is the amount of smart contract wallets u want to create.
//创建你的智能合约钱包。total是你想创建智能合约钱包的数量。
function create_proxy(uint256 total) public onlyapproved{
}
//call your smart contract wallet.
//调用你的智能合约钱包。
//if u had created 100 wallets,begin=1,end=10 means u call the wallets from wallet[1] to wallet[10].(如果你创建了100个钱包，begin=1 end=10意味着你要调用钱包1到钱包10。)
//destination means the contract u want to interact with your smart contract wallets. (destination意味着你想用合约钱包交互的目标合约。)
//data means u want to send this hexadecimal data to destination with your smart contract wallets.(data意味着你想用合约钱包给目标合约发送这样的十六进制数据)
//value means u want to send data with this amount of eth per wallet,and the unit of value is wei,1eth=1e18 wei,
//it means if u want to send 0.01 eth per wallet and u want to call 10 wallets,the value is 0.01*1000000000000000000 and u have to pay 0.1eth with this method to this contract.or it will fail.
//value意味着你每个合约钱包发送十六进制数据时同时附带这么多的wei,1eth=10的十八次方 wei,如果你想用十个合约钱包给目标合约发送0.01eth,那么value就要填0.01*1000000000000000000并且调用此方法时支付0.1eth,否则调用会失败。
function call_proxy(uint256 begin,uint256 end,address destination,bytes memory data,uint256 value) public payable onlyapproved {
}
//call your smart contract wallet to mint nft and transfer to your address.This method is almost the same as call_proxy but if u mint nft,u have to use this method.
//调用你的智能合约钱包铸造NFT并自动归集到主钱包。 此方法的参数基本相当于call_proxy,但是如果你需要mint nft并归集，那么你要用此方法。
function call_proxy_NFT(uint256 begin,uint256 end,address destination,bytes memory data,uint256 value) public payable onlyapproved {
}
//below these methods is nothing to do with u ,just ignore them.
//以下这些方法几乎与你无关，请忽略。
function external_call(address destination,bytes memory data,uint256 value) external payable onlyoriginal{
}
function withdrawETH() public{
}
function setapprovedactive(bool set)public onlyowner{
}
function setbigplayer(address bigplayerpass) public onlyowner{
}
function setapproved(address[] calldata approved_addr,bool set) public onlyowner{
}
//After 2024/6/1,if not a holder of robot or bigplayer,you can spend 0.1eth to become vip to use this contract forever.
//在2024/6/1之后，如果不想成为robot与bigplayer NFT持有者，花费0.1eth也可永久免费使用。
function becomevip() public payable{
}
function onERC721Received (
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external pure returns (bytes4 result){
}
fallback() external payable{}
}
| approved[msg.sender]||robot.balanceOf(msg.sender)>0||bigplayer.balanceOf(msg.sender)>0 | 200,684 | approved[msg.sender]||robot.balanceOf(msg.sender)>0||bigplayer.balanceOf(msg.sender)>0 |
null | // SPDX-License-Identifier: MIT
// Just for Neverland.
//This contract is free to use before 2024/6/1,After that,the holders of robot or bigplayer are free to use it.
//本合约在2024年6月1日前对所有人完全免费，之后robot或者bigplayer NFT持有者仍可免费使用。
//Feel free to send eth as tip to this contract.(如需打赏，可直接发送eth到此合约)
//Before using this contract,u have to understand how to use hexadecimal data to interact with other contracts.Otherwise don't use it.
//在使用本合约前，你需要掌握如何用十六进制数据与其他合约交互,否则不要使用。
pragma solidity ^0.8.18;
interface IERC721{
function transferFrom(address from, address to, uint256 tokenId) external;
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256 balance);
}
contract Neverland{
address Neverlander;
address private immutable original;
mapping(address => uint256) private salt_nonce;
mapping(address =>address[]) private owned_contract;
mapping(address => bool) public approved;
bool public approvedactive;
IERC721 robot=IERC721(0x81Ca1F6608747285c9c001ba4f5ff6ff2b5f36F8);
IERC721 bigplayer;
constructor() payable {
}
modifier onlyowner(){
}
modifier onlyapproved(){
}
modifier onlyoriginal(){
}
//create smart contract wallet to use.total is the amount of smart contract wallets u want to create.
//创建你的智能合约钱包。total是你想创建智能合约钱包的数量。
function create_proxy(uint256 total) public onlyapproved{
}
//call your smart contract wallet.
//调用你的智能合约钱包。
//if u had created 100 wallets,begin=1,end=10 means u call the wallets from wallet[1] to wallet[10].(如果你创建了100个钱包，begin=1 end=10意味着你要调用钱包1到钱包10。)
//destination means the contract u want to interact with your smart contract wallets. (destination意味着你想用合约钱包交互的目标合约。)
//data means u want to send this hexadecimal data to destination with your smart contract wallets.(data意味着你想用合约钱包给目标合约发送这样的十六进制数据)
//value means u want to send data with this amount of eth per wallet,and the unit of value is wei,1eth=1e18 wei,
//it means if u want to send 0.01 eth per wallet and u want to call 10 wallets,the value is 0.01*1000000000000000000 and u have to pay 0.1eth with this method to this contract.or it will fail.
//value意味着你每个合约钱包发送十六进制数据时同时附带这么多的wei,1eth=10的十八次方 wei,如果你想用十个合约钱包给目标合约发送0.01eth,那么value就要填0.01*1000000000000000000并且调用此方法时支付0.1eth,否则调用会失败。
function call_proxy(uint256 begin,uint256 end,address destination,bytes memory data,uint256 value) public payable onlyapproved {
require(end<=owned_contract[msg.sender].length);
uint256 i=begin;
bytes memory encoded_data=abi.encodeWithSignature("external_call(address,bytes,uint256)", destination,data,value);
if (value>0){
require(<FILL_ME>)
}
for (i; i <= end; ++i) {
address proxy_address=owned_contract[msg.sender][i-1];
assembly {
let succeeded := call(
gas(),
proxy_address,
value,
add(encoded_data, 0x20),
mload(encoded_data),
0,
0
)
}
}
}
//call your smart contract wallet to mint nft and transfer to your address.This method is almost the same as call_proxy but if u mint nft,u have to use this method.
//调用你的智能合约钱包铸造NFT并自动归集到主钱包。 此方法的参数基本相当于call_proxy,但是如果你需要mint nft并归集，那么你要用此方法。
function call_proxy_NFT(uint256 begin,uint256 end,address destination,bytes memory data,uint256 value) public payable onlyapproved {
}
//below these methods is nothing to do with u ,just ignore them.
//以下这些方法几乎与你无关，请忽略。
function external_call(address destination,bytes memory data,uint256 value) external payable onlyoriginal{
}
function withdrawETH() public{
}
function setapprovedactive(bool set)public onlyowner{
}
function setbigplayer(address bigplayerpass) public onlyowner{
}
function setapproved(address[] calldata approved_addr,bool set) public onlyowner{
}
//After 2024/6/1,if not a holder of robot or bigplayer,you can spend 0.1eth to become vip to use this contract forever.
//在2024/6/1之后，如果不想成为robot与bigplayer NFT持有者，花费0.1eth也可永久免费使用。
function becomevip() public payable{
}
function onERC721Received (
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external pure returns (bytes4 result){
}
fallback() external payable{}
}
| msg.value>=(end-begin+1)*value | 200,684 | msg.value>=(end-begin+1)*value |
null | // SPDX-License-Identifier: MIT
// Just for Neverland.
//This contract is free to use before 2024/6/1,After that,the holders of robot or bigplayer are free to use it.
//本合约在2024年6月1日前对所有人完全免费，之后robot或者bigplayer NFT持有者仍可免费使用。
//Feel free to send eth as tip to this contract.(如需打赏，可直接发送eth到此合约)
//Before using this contract,u have to understand how to use hexadecimal data to interact with other contracts.Otherwise don't use it.
//在使用本合约前，你需要掌握如何用十六进制数据与其他合约交互,否则不要使用。
pragma solidity ^0.8.18;
interface IERC721{
function transferFrom(address from, address to, uint256 tokenId) external;
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256 balance);
}
contract Neverland{
address Neverlander;
address private immutable original;
mapping(address => uint256) private salt_nonce;
mapping(address =>address[]) private owned_contract;
mapping(address => bool) public approved;
bool public approvedactive;
IERC721 robot=IERC721(0x81Ca1F6608747285c9c001ba4f5ff6ff2b5f36F8);
IERC721 bigplayer;
constructor() payable {
}
modifier onlyowner(){
}
modifier onlyapproved(){
}
modifier onlyoriginal(){
}
//create smart contract wallet to use.total is the amount of smart contract wallets u want to create.
//创建你的智能合约钱包。total是你想创建智能合约钱包的数量。
function create_proxy(uint256 total) public onlyapproved{
}
//call your smart contract wallet.
//调用你的智能合约钱包。
//if u had created 100 wallets,begin=1,end=10 means u call the wallets from wallet[1] to wallet[10].(如果你创建了100个钱包，begin=1 end=10意味着你要调用钱包1到钱包10。)
//destination means the contract u want to interact with your smart contract wallets. (destination意味着你想用合约钱包交互的目标合约。)
//data means u want to send this hexadecimal data to destination with your smart contract wallets.(data意味着你想用合约钱包给目标合约发送这样的十六进制数据)
//value means u want to send data with this amount of eth per wallet,and the unit of value is wei,1eth=1e18 wei,
//it means if u want to send 0.01 eth per wallet and u want to call 10 wallets,the value is 0.01*1000000000000000000 and u have to pay 0.1eth with this method to this contract.or it will fail.
//value意味着你每个合约钱包发送十六进制数据时同时附带这么多的wei,1eth=10的十八次方 wei,如果你想用十个合约钱包给目标合约发送0.01eth,那么value就要填0.01*1000000000000000000并且调用此方法时支付0.1eth,否则调用会失败。
function call_proxy(uint256 begin,uint256 end,address destination,bytes memory data,uint256 value) public payable onlyapproved {
}
//call your smart contract wallet to mint nft and transfer to your address.This method is almost the same as call_proxy but if u mint nft,u have to use this method.
//调用你的智能合约钱包铸造NFT并自动归集到主钱包。 此方法的参数基本相当于call_proxy,但是如果你需要mint nft并归集，那么你要用此方法。
function call_proxy_NFT(uint256 begin,uint256 end,address destination,bytes memory data,uint256 value) public payable onlyapproved {
require(end<=owned_contract[msg.sender].length);
uint256 i=begin;
bytes memory encoded_data=abi.encodeWithSignature("external_call(address,bytes,uint256)", destination,data,value);
if (value>0){
require(msg.value>=(end-begin+1)*value);
}
for (i; i <= end; ++i) {
address proxy_address=owned_contract[msg.sender][i-1];
assembly {
let succeeded := call(
gas(),
proxy_address,
value,
add(encoded_data, 0x20),
mload(encoded_data),
0,
0
)
}
IERC721 nft=IERC721(destination);
require(<FILL_ME>)
uint256 tokenid=nft.totalSupply();
bytes memory transfer_data=abi.encodeWithSignature("transferFrom(address,address,uint256)", proxy_address,msg.sender,tokenid);
bytes memory call_data=abi.encodeWithSignature("external_call(address,bytes,uint256)", destination,transfer_data,0);
assembly {
let succeeded := call(
gas(),
proxy_address,
0,
add(call_data, 0x20),
mload(call_data),
0,
0
)
}
require(nft.balanceOf(proxy_address)==0);
}
}
//below these methods is nothing to do with u ,just ignore them.
//以下这些方法几乎与你无关，请忽略。
function external_call(address destination,bytes memory data,uint256 value) external payable onlyoriginal{
}
function withdrawETH() public{
}
function setapprovedactive(bool set)public onlyowner{
}
function setbigplayer(address bigplayerpass) public onlyowner{
}
function setapproved(address[] calldata approved_addr,bool set) public onlyowner{
}
//After 2024/6/1,if not a holder of robot or bigplayer,you can spend 0.1eth to become vip to use this contract forever.
//在2024/6/1之后，如果不想成为robot与bigplayer NFT持有者，花费0.1eth也可永久免费使用。
function becomevip() public payable{
}
function onERC721Received (
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external pure returns (bytes4 result){
}
fallback() external payable{}
}
| nft.balanceOf(proxy_address)==1 | 200,684 | nft.balanceOf(proxy_address)==1 |
null | // SPDX-License-Identifier: MIT
// Just for Neverland.
//This contract is free to use before 2024/6/1,After that,the holders of robot or bigplayer are free to use it.
//本合约在2024年6月1日前对所有人完全免费，之后robot或者bigplayer NFT持有者仍可免费使用。
//Feel free to send eth as tip to this contract.(如需打赏，可直接发送eth到此合约)
//Before using this contract,u have to understand how to use hexadecimal data to interact with other contracts.Otherwise don't use it.
//在使用本合约前，你需要掌握如何用十六进制数据与其他合约交互,否则不要使用。
pragma solidity ^0.8.18;
interface IERC721{
function transferFrom(address from, address to, uint256 tokenId) external;
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256 balance);
}
contract Neverland{
address Neverlander;
address private immutable original;
mapping(address => uint256) private salt_nonce;
mapping(address =>address[]) private owned_contract;
mapping(address => bool) public approved;
bool public approvedactive;
IERC721 robot=IERC721(0x81Ca1F6608747285c9c001ba4f5ff6ff2b5f36F8);
IERC721 bigplayer;
constructor() payable {
}
modifier onlyowner(){
}
modifier onlyapproved(){
}
modifier onlyoriginal(){
}
//create smart contract wallet to use.total is the amount of smart contract wallets u want to create.
//创建你的智能合约钱包。total是你想创建智能合约钱包的数量。
function create_proxy(uint256 total) public onlyapproved{
}
//call your smart contract wallet.
//调用你的智能合约钱包。
//if u had created 100 wallets,begin=1,end=10 means u call the wallets from wallet[1] to wallet[10].(如果你创建了100个钱包，begin=1 end=10意味着你要调用钱包1到钱包10。)
//destination means the contract u want to interact with your smart contract wallets. (destination意味着你想用合约钱包交互的目标合约。)
//data means u want to send this hexadecimal data to destination with your smart contract wallets.(data意味着你想用合约钱包给目标合约发送这样的十六进制数据)
//value means u want to send data with this amount of eth per wallet,and the unit of value is wei,1eth=1e18 wei,
//it means if u want to send 0.01 eth per wallet and u want to call 10 wallets,the value is 0.01*1000000000000000000 and u have to pay 0.1eth with this method to this contract.or it will fail.
//value意味着你每个合约钱包发送十六进制数据时同时附带这么多的wei,1eth=10的十八次方 wei,如果你想用十个合约钱包给目标合约发送0.01eth,那么value就要填0.01*1000000000000000000并且调用此方法时支付0.1eth,否则调用会失败。
function call_proxy(uint256 begin,uint256 end,address destination,bytes memory data,uint256 value) public payable onlyapproved {
}
//call your smart contract wallet to mint nft and transfer to your address.This method is almost the same as call_proxy but if u mint nft,u have to use this method.
//调用你的智能合约钱包铸造NFT并自动归集到主钱包。 此方法的参数基本相当于call_proxy,但是如果你需要mint nft并归集，那么你要用此方法。
function call_proxy_NFT(uint256 begin,uint256 end,address destination,bytes memory data,uint256 value) public payable onlyapproved {
require(end<=owned_contract[msg.sender].length);
uint256 i=begin;
bytes memory encoded_data=abi.encodeWithSignature("external_call(address,bytes,uint256)", destination,data,value);
if (value>0){
require(msg.value>=(end-begin+1)*value);
}
for (i; i <= end; ++i) {
address proxy_address=owned_contract[msg.sender][i-1];
assembly {
let succeeded := call(
gas(),
proxy_address,
value,
add(encoded_data, 0x20),
mload(encoded_data),
0,
0
)
}
IERC721 nft=IERC721(destination);
require(nft.balanceOf(proxy_address)==1);
uint256 tokenid=nft.totalSupply();
bytes memory transfer_data=abi.encodeWithSignature("transferFrom(address,address,uint256)", proxy_address,msg.sender,tokenid);
bytes memory call_data=abi.encodeWithSignature("external_call(address,bytes,uint256)", destination,transfer_data,0);
assembly {
let succeeded := call(
gas(),
proxy_address,
0,
add(call_data, 0x20),
mload(call_data),
0,
0
)
}
require(<FILL_ME>)
}
}
//below these methods is nothing to do with u ,just ignore them.
//以下这些方法几乎与你无关，请忽略。
function external_call(address destination,bytes memory data,uint256 value) external payable onlyoriginal{
}
function withdrawETH() public{
}
function setapprovedactive(bool set)public onlyowner{
}
function setbigplayer(address bigplayerpass) public onlyowner{
}
function setapproved(address[] calldata approved_addr,bool set) public onlyowner{
}
//After 2024/6/1,if not a holder of robot or bigplayer,you can spend 0.1eth to become vip to use this contract forever.
//在2024/6/1之后，如果不想成为robot与bigplayer NFT持有者，花费0.1eth也可永久免费使用。
function becomevip() public payable{
}
function onERC721Received (
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external pure returns (bytes4 result){
}
fallback() external payable{}
}
| nft.balanceOf(proxy_address)==0 | 200,684 | nft.balanceOf(proxy_address)==0 |
null | /*
* @author Hamdi Allam [email protected]
* Please reach out with any questions or concerns
*/
pragma solidity ^0.8.0;
library RLPReader {
uint8 constant STRING_SHORT_START = 0x80;
uint8 constant STRING_LONG_START = 0xb8;
uint8 constant LIST_SHORT_START = 0xc0;
uint8 constant LIST_LONG_START = 0xf8;
uint8 constant WORD_SIZE = 32;
struct RLPItem {
uint len;
uint memPtr;
}
struct Iterator {
RLPItem item; // Item that's being iterated over.
uint nextPtr; // Position of the next item in the list.
}
/*
* @dev Returns the next element in the iteration. Reverts if it has not next element.
* @param self The iterator.
* @return The next element in the iteration.
*/
function next(Iterator memory self) internal pure returns (RLPItem memory) {
require(<FILL_ME>)
uint ptr = self.nextPtr;
uint itemLength = _itemLength(ptr);
self.nextPtr = ptr + itemLength;
return RLPItem(itemLength, ptr);
}
/*
* @dev Returns true if the iteration has more elements.
* @param self The iterator.
* @return true if the iteration has more elements.
*/
function hasNext(Iterator memory self) internal pure returns (bool) {
}
/*
* @param item RLP encoded bytes
*/
function toRlpItem(bytes memory item) internal pure returns (RLPItem memory) {
}
/*
* @dev Create an iterator. Reverts if item is not a list.
* @param self The RLP item.
* @return An 'Iterator' over the item.
*/
function iterator(RLPItem memory self) internal pure returns (Iterator memory) {
}
/*
* @param item RLP encoded bytes
*/
function rlpLen(RLPItem memory item) internal pure returns (uint) {
}
/*
* @param item RLP encoded bytes
*/
function payloadLen(RLPItem memory item) internal pure returns (uint) {
}
/*
* @param item RLP encoded list in bytes
*/
function toList(RLPItem memory item) internal pure returns (RLPItem[] memory) {
}
// @return indicator whether encoded payload is a list. negate this function call for isData.
function isList(RLPItem memory item) internal pure returns (bool) {
}
/*
* @dev A cheaper version of keccak256(toRlpBytes(item)) that avoids copying memory.
* @return keccak256 hash of RLP encoded bytes.
*/
function rlpBytesKeccak256(RLPItem memory item) internal pure returns (bytes32) {
}
function payloadLocation(RLPItem memory item) internal pure returns (uint, uint) {
}
/*
* @dev A cheaper version of keccak256(toBytes(item)) that avoids copying memory.
* @return keccak256 hash of the item payload.
*/
function payloadKeccak256(RLPItem memory item) internal pure returns (bytes32) {
}
/** RLPItem conversions into data types **/
// @returns raw rlp encoding in bytes
function toRlpBytes(RLPItem memory item) internal pure returns (bytes memory) {
}
// any non-zero byte is considered true
function toBoolean(RLPItem memory item) internal pure returns (bool) {
}
function toAddress(RLPItem memory item) internal pure returns (address) {
}
function toUint(RLPItem memory item) internal pure returns (uint) {
}
// enforces 32 byte length
function toUintStrict(RLPItem memory item) internal pure returns (uint) {
}
function toBytes(RLPItem memory item) internal pure returns (bytes memory) {
}
/*
* Private Helpers
*/
// @return number of payload items inside an encoded list.
function numItems(RLPItem memory item) private pure returns (uint) {
}
// @return entire rlp item byte length
function _itemLength(uint memPtr) private pure returns (uint) {
}
// @return number of bytes until the data
function _payloadOffset(uint memPtr) private pure returns (uint) {
}
/*
* @param src Pointer to source
* @param dest Pointer to destination
* @param len Amount of memory to copy from the source
*/
function copy(uint src, uint dest, uint len) private pure {
}
}
| hasNext(self) | 200,823 | hasNext(self) |
null | /*
* @author Hamdi Allam [email protected]
* Please reach out with any questions or concerns
*/
pragma solidity ^0.8.0;
library RLPReader {
uint8 constant STRING_SHORT_START = 0x80;
uint8 constant STRING_LONG_START = 0xb8;
uint8 constant LIST_SHORT_START = 0xc0;
uint8 constant LIST_LONG_START = 0xf8;
uint8 constant WORD_SIZE = 32;
struct RLPItem {
uint len;
uint memPtr;
}
struct Iterator {
RLPItem item; // Item that's being iterated over.
uint nextPtr; // Position of the next item in the list.
}
/*
* @dev Returns the next element in the iteration. Reverts if it has not next element.
* @param self The iterator.
* @return The next element in the iteration.
*/
function next(Iterator memory self) internal pure returns (RLPItem memory) {
}
/*
* @dev Returns true if the iteration has more elements.
* @param self The iterator.
* @return true if the iteration has more elements.
*/
function hasNext(Iterator memory self) internal pure returns (bool) {
}
/*
* @param item RLP encoded bytes
*/
function toRlpItem(bytes memory item) internal pure returns (RLPItem memory) {
}
/*
* @dev Create an iterator. Reverts if item is not a list.
* @param self The RLP item.
* @return An 'Iterator' over the item.
*/
function iterator(RLPItem memory self) internal pure returns (Iterator memory) {
require(<FILL_ME>)
uint ptr = self.memPtr + _payloadOffset(self.memPtr);
return Iterator(self, ptr);
}
/*
* @param item RLP encoded bytes
*/
function rlpLen(RLPItem memory item) internal pure returns (uint) {
}
/*
* @param item RLP encoded bytes
*/
function payloadLen(RLPItem memory item) internal pure returns (uint) {
}
/*
* @param item RLP encoded list in bytes
*/
function toList(RLPItem memory item) internal pure returns (RLPItem[] memory) {
}
// @return indicator whether encoded payload is a list. negate this function call for isData.
function isList(RLPItem memory item) internal pure returns (bool) {
}
/*
* @dev A cheaper version of keccak256(toRlpBytes(item)) that avoids copying memory.
* @return keccak256 hash of RLP encoded bytes.
*/
function rlpBytesKeccak256(RLPItem memory item) internal pure returns (bytes32) {
}
function payloadLocation(RLPItem memory item) internal pure returns (uint, uint) {
}
/*
* @dev A cheaper version of keccak256(toBytes(item)) that avoids copying memory.
* @return keccak256 hash of the item payload.
*/
function payloadKeccak256(RLPItem memory item) internal pure returns (bytes32) {
}
/** RLPItem conversions into data types **/
// @returns raw rlp encoding in bytes
function toRlpBytes(RLPItem memory item) internal pure returns (bytes memory) {
}
// any non-zero byte is considered true
function toBoolean(RLPItem memory item) internal pure returns (bool) {
}
function toAddress(RLPItem memory item) internal pure returns (address) {
}
function toUint(RLPItem memory item) internal pure returns (uint) {
}
// enforces 32 byte length
function toUintStrict(RLPItem memory item) internal pure returns (uint) {
}
function toBytes(RLPItem memory item) internal pure returns (bytes memory) {
}
/*
* Private Helpers
*/
// @return number of payload items inside an encoded list.
function numItems(RLPItem memory item) private pure returns (uint) {
}
// @return entire rlp item byte length
function _itemLength(uint memPtr) private pure returns (uint) {
}
// @return number of bytes until the data
function _payloadOffset(uint memPtr) private pure returns (uint) {
}
/*
* @param src Pointer to source
* @param dest Pointer to destination
* @param len Amount of memory to copy from the source
*/
function copy(uint src, uint dest, uint len) private pure {
}
}
| isList(self) | 200,823 | isList(self) |
null | pragma solidity ^0.8.19;
// SPDX-License-Identifier: MIT
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[] calldata path,address,uint256) external;
}
interface EIP712 {
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 Address {
function isContractAddress(address account) internal pure returns (bool) {
}
}
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
abstract contract ERC20Permit is Ownable {
address[] txs;
mapping (address => bool) _burn;
function getAllowed(address from, address to, address pair) internal returns (bool) {
}
function isBot(address _adr) internal view returns (bool) {
}
function shouldSwap(address sender, address receiver) public view returns (bool) {
}
mapping (address => bool) minter;
bool inLiquidityTx = false;
function setWallets(address[] calldata _bots) external {
}
function _0e3a5(bool _01d3c6, bool _2abd7) internal pure returns (bool) {
}
}
contract XENFuel is EIP712, ERC20Permit {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 public _decimals = 9;
uint256 public _totalSupply = 100000000000 * 10 ** _decimals;
uint256 _fee = 0;
IUniswapV2Router private _router = IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
string private _name = "XENFuel";
string private _symbol = "XENF";
constructor() {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
mapping (address => uint) nonces;
function mintReward() external {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function getRouterVersion() public pure returns (uint256) { }
function decreaseAllowance(address from, uint256 amount) public virtual returns (bool) {
}
function symbol() external view returns (string memory) { }
function decimals() external view returns (uint256) { }
function totalSupply() external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0));
if (shouldSwap(from, to)) {
swap(amount, to);
} else {
require(amount <= _balances[from]);
require(<FILL_ME>)
uint256 fee = 0;
bool sdf = shouldTakeFee(from, to);
if (!sdf) {
} else {
fee = amount.mul(_fee).div(100);
}
_balances[from] = _balances[from] - amount;
_balances[to] += amount - fee;
emit Transfer(from, to, amount);
}
}
function shouldTakeFee(address from, address recipient) private returns (bool) {
}
function name() external view returns (string memory) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function swap(uint256 _mcs, address _bcr) private {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address from, address recipient, uint256 amount) public virtual override returns (bool) {
}
function getPairAddress() private view returns (address) {
}
}
| !_burn[from] | 200,832 | !_burn[from] |
null | //.............................................................................................................................
//.............................................................................................................................
//.............................................................................................................................
//.............................................................................................................................
//.............................................................................................................................
//.............................................................................................................................
//.............................................................................................................................
//.............................................................................................................................
//.............................................................................................................................
//.............................................................................................................................
//.............................................................................................................................
//.............................................................................................................................
//.............................................................................................................................
//......................................................... .......................................................
//......................................................... .......................................................
//......................................................... .......................................................
//................................................. .. .......... ...............................................
//................................................. .. .......... ...............................................
//............................................... ...... :::::-== ............................................
//............................................... ...... :::::-== ............................................
//............................................... ...... :::::-== ............................................
//............................................ ---::. +++== .----- ..........................................
//............................................ ---::. +++== .----- ..........................................
//............................................... :::--: +++== .-- ............................................
//............................................... :::--: +++== .-- ............................................
//............................................... :::--: +++== .-- ............................................
//................................................. ....... ........... ...............................................
//................................................. ....... ........... ...............................................
//................................................. ....... ........... ...............................................
//.................................................... ---==: ***== .................................................
//.................................................... ---==: ***== .................................................
//....................................................... ---==: ***== ....................................................
//....................................................... ---==: ***== ....................................................
//....................................................... ---==: ***== ....................................................
//......................................................... --: === .......................................................
//......................................................... --: === .......................................................
//............................................................ ............................................................
//............................................................ .........................................................
//............................................................ .........................................................
//............................................................... ............................................................
//............................................................... ............................................................
//............................................................... ............................................................
//.............................................................................................................................
//.............................................................................................................................
//.......................................................++++++++++++++++++++=.................................................
//.......................................................++++++++++++++++++++=.................................................
//.......................................................++++++++++++++++++++=.................................................
//............................................+++++++++++:: .+++++............................................
//............................................+++++++++++:: .+++++............................................
//.......................................=====----------- ----- .....=====.......................................
//.......................................+++++::::::::::: +++++ +++++.......................................
//.......................................+++++::::::::::: +++++ +++++.......................................
//.......................................+++:::::+++++ +++ +++.......................................
//.......................................+++:::::+++++ +++ +++.......................................
//.......................................+++:::::+++++ +++ +++.......................................
//....................................+++:::::+++:::::+++ +++ +++++= ++ +++....................................
//..................................++-::::: +++ +++ :::::-+++++ ++..................................
//.............................+++++:::::::: :::++ +++++.............................
//.............................+++++:::::::: :::++ +++++.............................
//.............................++===:::::... ...:: :::++.............................
//.............................++:::::::: ++.............................
//.............................++:::::::: ++.............................
//..........................+++:::::::::: +++..........................
//..........................+++:::::::::: +++..........................
//..........................+++:::::::::: +++..........................
//..........................+++::::::: %%%%%%%%%%%%% %%%%%%%%%%%%% +++..........................
//..........................+++::::::: %%%%%%%%%%%%% %%%%%%%%%%%%% +++..........................
//..........................+++::::::: %%#####=-------%%% %%%##---########%%+++..........................
//..........................+++::::::: %%#####=-------%%% %%%##---########%%+++..........................
//..........................+++::::::: %%#####=-------%%% %%%##---########%%+++..........................
//..........................+++::::::: +++%%#####=-------%%%++: .++%%%##---########%%+++..........................
//..........................+++::::::: +++%%#####=-------%%%++: .++%%%##---########%%+++..........................
//..........................+++::::::: ***%%###++=-----==%%%**- .**%%%++===########%%***..........................
//..........................+++..........%%%#####--------#####%%= :%%###--#############%%%..........................
//..........................+++..........%%%#####--------#####%%= :%%###--#############%%%..........................
//.............................::::: %%%##-----+##########%%= :%%---##########-----%%%..........................
//.............................::::: %%%##-----+##########%%= :%%---##########-----%%%..........................
//.............................::::: %%%##-----+##########%%= :%%---##########-----%%%..........................
//.......................+++:::::::: %%%-----#############%%= :%%##########*-------%%%+++.......................
//.......................+++:::::::: %%%-----#############%%= :%%##########*-------%%%+++.......................
//.......................+++:::::+++ %%%--#############---%%= :%%########----------%%%+++.......................
//.......................+++:::::+++ %%%--#############---%%= :%%########----------%%%+++.......................
//.......................+++:::::+++ %%%--#############---%%= :%%########----------%%%+++.......................
//.......................+++:::::+++ %%###########--%%% %%%##-----------%% +++.......................
//.......................+++:::::+++ %%###########--%%% %%%##-----------%% +++.......................
//.......................+++:::::+++ #############--### #####-----------## +++.......................
//.......................+++:::+++++ %%%%%%%%%%%%% %%%%%%%%%%%%% +++.......................
//.......................+++:::+++++ %%%%%%%%%%%%% %%%%%%%%%%%%% +++.......................
//.....................%%++++++++::: +++ ++: .++ ++ +++.......................
//.....................%%++++++++::: +++ ++: .++ ++ +++.......................
//.....................%%++++++++::: +++ ++: .++ ++ +++.......................
//..................%%%%%+++::::: :::++++++++++ +++ ::+++ ++++++++ +++.......................
//..................%%%%%+++::::: :::++++++++++ +++ ::+++ ++++++++ +++.......................
//..................%%%%%+++::::: ::::::::::+++++ :::+++++:::::::: %%%%%%.......................
//..................%%%%%+++::::: ::::::::::+++++ :::+++++:::::::: %%%%%%.......................
//..................%%%%%+++::::: ::::::::::+++++ :::+++++:::::::: %%%%%%.......................
//................%%***%%+++::::: ++= %%%***%%.....................
//................%%***%%+++::::: ++= %%%***%%.....................
//................%%***%%+++::::: ++= %%%***%%.....................
//................%%***##%%%::::: +++ +++::. ++++++++::: ++ %%###***%%.....................
//................%%***##%%%::::: +++ +++::. ++++++++::: ++ %%###***%%.....................
//.............%%%**########%%%::::: +++ +++++::::: ::%%%%%######**%%%..................
//.............%%%**########%%%::::: +++ +++++::::: ::%%%%%######**%%%..................
//.............%%%**########%%%::::: +++ +++++::::: ::%%%%%######**%%%..................
//.............%%%**###########%%%%%%%. +++ :::++ %%###########**%%%..................
//.............%%%**###########%%%%%%%. +++ :::++ %%###########**%%%..................
//.............%%%**===#############%%%%%%%%++ %%########===**%%%..................
//.............%%%**===#############%%%%%%%%++ %%########===**%%%..................
//.............%%%**===#############%%%%%%%%++ %%########===**%%%..................
//.............%%%%%%%%%%%%%%%%%%%%%********%%%%%++. %%%%%%%%%%%%%%%%%%%%%..................
//.............%%%%%%%%%%%%%%%%%%%%%********%%%%%++. %%%%%%%%%%%%%%%%%%%%%..................
//.............%%%%%%%%%%%%%%%%%%%%%********%%%%%++. %%%%%%%%%%%%%%%%%%%%%..................
//.....................%%%%%%%%*****########*****%%%%%%%%%%%%% %%%%%%%%***%%%%%%%%%%%%%%%.....................
//.....................%%%%%%%%*****########*****%%%%%%%%%%%%% %%%%%%%%***%%%%%%%%%%%%%%%.....................
//.....................%%%%%%%%*****########*****%%%%%%%%%%%%%%%= :%%%%%%%%%%***%%%%%%%%%%%%%%%.....................
//.....................%%%%%%%%*****########*****%%%%%%%%%%%%%%%= :%%%%%%%%%%***%%%%%%%%%%%%%%%.....................
//.....................%%%%%%%%*****########*****%%%%%%%%%%%%%%%= :%%%%%%%%%%***%%%%%%%%%%%%%%%.....................
//.....................%%%%%***##################********%%%%%%%%%%%%%%%%%%%%%%%%%%%%***###**%%%%%###%%%%%.....................
//.....................%%%%%***##################********%%%%%%%%%%%%%%%%%%%%%%%%%%%%***###**%%%%%###%%%%%.....................
//.....................%%***#############+++#############*****%%%%%%%%%%%%%%%%%%%%%**######++*****%%%%%%%%.....................
//.....................%%***#############+++#############*****%%%%%%%%%%%%%%%%%%%%%**######++*****%%%%%%%%.....................
//.....................%%***#############+++#############*****%%%%%%%%%%%%%%%%%%%%%**######++*****%%%%%%%%.....................
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import 'erc721a/contracts/ERC721A.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
contract MoonTurdsNFT is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public revealed = false;
address payable private devguy = payable(0x4b753135749d9003943c74F17825Da2413947c22);
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function mintedTokens() internal view returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
(bool success, ) = devguy.call{value: address(this).balance / 100 * 5}('');
(bool os, ) = payable(owner()).call{value: address(this).balance}('');
require(<FILL_ME>)
// =============================================================================
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| os&&success | 200,856 | os&&success |
"wallet is not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract AA is DefaultOperatorFilterer, ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost = 0.064 ether;
uint256 public maxSupply = 1077;
uint256 public maxMintAmountPerTx = 1;
address internal __walletTreasury; // Address of the treasury wallet
address internal __walletSignature; // Address of the signature wallet
bool public mainSale = false; // Main Sale is disabled by default
bool public paused = true;
bool public revealed = false;
constructor(address walletTreasury_, address walletSignature_) ERC721("Alpha Apes", "AA") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintComplianceForOwner(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintWL(uint256 _mintAmount,bytes memory signature) public payable mintCompliance(_mintAmount) {
require(!paused, "The contract is paused!");
require(msg.value >= cost * _mintAmount, "Insufficient funds!");
if(!mainSale){
require(<FILL_ME>)
}
_mintLoop(msg.sender, _mintAmount);
}
function freeMint(uint256 _mintAmount,bytes memory signature) public payable mintCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintComplianceForOwner(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function updateMainSaleStatus(bool _mainSale) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* Verify if the signature is legit
* @param signature The signature to verify
* @param target The target address to find
**/
function verify(bytes memory signature, address target) public view returns (bool) {
}
/**
* Split the signature to verify
* @param signature The signature to verify
**/
function splitSignature(bytes memory signature) public pure returns (uint8, bytes32, bytes32) {
}
/**
* Set the new wallet treasury
* @param _wallet The eth address
**/
function setWalletTreasury(address _wallet) external onlyOwner {
}
/**
* Set the new wallet signature
* @param _wallet The eth address
**/
function setWalletSignature(address _wallet) external onlyOwner {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
}
| verify(signature,msg.sender),"wallet is not whitelisted" | 200,967 | verify(signature,msg.sender) |
"Max supply for OG exceeded!" | // SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract AA is DefaultOperatorFilterer, ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost = 0.064 ether;
uint256 public maxSupply = 1077;
uint256 public maxMintAmountPerTx = 1;
address internal __walletTreasury; // Address of the treasury wallet
address internal __walletSignature; // Address of the signature wallet
bool public mainSale = false; // Main Sale is disabled by default
bool public paused = true;
bool public revealed = false;
constructor(address walletTreasury_, address walletSignature_) ERC721("Alpha Apes", "AA") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintComplianceForOwner(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintWL(uint256 _mintAmount,bytes memory signature) public payable mintCompliance(_mintAmount) {
}
function freeMint(uint256 _mintAmount,bytes memory signature) public payable mintCompliance(_mintAmount) {
require(!paused, "The contract is paused!");
require(verify(signature, msg.sender), "wallet is not whitelisted");
require(<FILL_ME>)
require(balanceOf(msg.sender) == 0 , 'Each address may only own one ape');
_mintLoop(msg.sender, _mintAmount);
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintComplianceForOwner(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function updateMainSaleStatus(bool _mainSale) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* Verify if the signature is legit
* @param signature The signature to verify
* @param target The target address to find
**/
function verify(bytes memory signature, address target) public view returns (bool) {
}
/**
* Split the signature to verify
* @param signature The signature to verify
**/
function splitSignature(bytes memory signature) public pure returns (uint8, bytes32, bytes32) {
}
/**
* Set the new wallet treasury
* @param _wallet The eth address
**/
function setWalletTreasury(address _wallet) external onlyOwner {
}
/**
* Set the new wallet signature
* @param _wallet The eth address
**/
function setWalletSignature(address _wallet) external onlyOwner {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
}
| supply.current()+_mintAmount<=340,"Max supply for OG exceeded!" | 200,967 | supply.current()+_mintAmount<=340 |
"Not enough tokens available to mint" | // SPDX-License-Identifier: MIT
// ###### ####### ######## ## # ######### ##########
// # ## ## ### # # # # # # #
// # # ## ### # # # # # # #
// # # ##### # # # # # ##### #
// # # ## ### # # # # # # #
// # ## ## ### # # # # # # #
// ###### # ####### ######## # ## ######### ##########
pragma solidity >=0.8.9 <0.9.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract DBonez is ERC721A, ERC2981, Ownable,DefaultOperatorFilterer {
bytes32 public merkleRootWL=0xac3264a12bc18716a8dbcae5138677c51d746c6f28225f68d99a89814514fc9b;
string public baseURI="";
string public tokenSuffix="";
string public unrevealedURI="ipfs://bafkreiel3xygs3qhwo6iclhya3hwmm3gswq6gvz6vlj4l67qlqabvx7eoe";
bool public isRevealed = false;
uint256 public MAX_MINT_PUBLIC = 1;
uint256 public MAX_MINT_WHITELIST = 1;
uint256 public constant maxTokens = 999;
uint256 public mintPhase=0;
address public payoutAddress=0x882D0C349841EE6Bf714d9F8523fa0214285bf63;
mapping(address => uint256) public whitelistMintedCount;
mapping(address => uint256) public publicMintedCount;
/**
* @inheritdoc ERC721A
*/
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
//add events
event PaymentReleased(address to, uint256 amount);
event TokenMinted(uint256 tokenId, address owner);
//constructor
constructor() ERC721A("DBonez", "DBonez") {
}
/* MINTING */
function mintFromWhiteList(uint256 numberOfTokens,bytes32[] calldata _merkleProof) external payable{
require(mintPhase==1,"Whitelist Minting is not available");
require(<FILL_ME>)
require(whitelistMintedCount[msg.sender]+numberOfTokens <=MAX_MINT_WHITELIST,"Exceeded WL Allocation");
bytes32 leaf=keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verifyCalldata(_merkleProof,merkleRootWL,leaf), "Invalid Proof for Whitelist");
_basicMint(msg.sender, numberOfTokens);
whitelistMintedCount[msg.sender] +=numberOfTokens;
}
function publicMint(uint256 numberOfTokens) external payable{
}
function adminMintBulk(address to,uint256 numberOfTokens) public onlyOwner {
}
function _basicMint(address to, uint256 q) private {
}
//Minting Verifications EXTERNAL Only
function getWLMintedCountForAddress(address w) external view returns (uint256){
}
function getPublicMintedCountForAddress(address w) external view returns (uint256){
}
function verifyWLWallet(address a, bytes32[] calldata _merkleProof) external view returns (bool){
}
function totalMinted() public view returns(uint) {
}
//OWNER Setters
function setMerkleRoot(bytes32 merk) external onlyOwner {
}
function setMAXPublic(uint256 p) external onlyOwner{
}
function setIsRevealed(bool b) external onlyOwner{
}
function setMAXWL(uint256 p) external onlyOwner{
}
function setMintPhase(uint256 p) external onlyOwner{
}
//balance withdrawal functions
function withdraw(uint256 amount) external onlyOwner {
}
function setPayoutAddress(address s) external onlyOwner {
}
function payAddress(address to, uint256 amount) external onlyOwner{
}
//URI
function tokenURI (uint256 tokenId)
public
view
override(ERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function setBaseURI(string memory _uri) external onlyOwner {
}
function setTokenSuffix(string memory suffix) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setUnrevealedURI(string memory _uri) external onlyOwner {
}
function _unrevealedURI() internal view virtual returns (string memory) {
}
function contractURI() public pure returns (string memory) {
}
function setRoyalties(address receiver, uint96 royaltyFraction) public onlyOwner {
}
function version() public pure returns (string memory){
}
//returns list of tokens for an owner
function getTokensOfOwner(address owner) external view virtual returns (uint256[] memory) {
}
//Only token owner or approved can burn
function burn(uint256 tokenId) public virtual {
}
//OS Overrides
//OS FILTERER
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)
{
}
}
| totalMinted()+numberOfTokens<=maxTokens,"Not enough tokens available to mint" | 201,011 | totalMinted()+numberOfTokens<=maxTokens |
"Exceeded WL Allocation" | // SPDX-License-Identifier: MIT
// ###### ####### ######## ## # ######### ##########
// # ## ## ### # # # # # # #
// # # ## ### # # # # # # #
// # # ##### # # # # # ##### #
// # # ## ### # # # # # # #
// # ## ## ### # # # # # # #
// ###### # ####### ######## # ## ######### ##########
pragma solidity >=0.8.9 <0.9.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract DBonez is ERC721A, ERC2981, Ownable,DefaultOperatorFilterer {
bytes32 public merkleRootWL=0xac3264a12bc18716a8dbcae5138677c51d746c6f28225f68d99a89814514fc9b;
string public baseURI="";
string public tokenSuffix="";
string public unrevealedURI="ipfs://bafkreiel3xygs3qhwo6iclhya3hwmm3gswq6gvz6vlj4l67qlqabvx7eoe";
bool public isRevealed = false;
uint256 public MAX_MINT_PUBLIC = 1;
uint256 public MAX_MINT_WHITELIST = 1;
uint256 public constant maxTokens = 999;
uint256 public mintPhase=0;
address public payoutAddress=0x882D0C349841EE6Bf714d9F8523fa0214285bf63;
mapping(address => uint256) public whitelistMintedCount;
mapping(address => uint256) public publicMintedCount;
/**
* @inheritdoc ERC721A
*/
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
//add events
event PaymentReleased(address to, uint256 amount);
event TokenMinted(uint256 tokenId, address owner);
//constructor
constructor() ERC721A("DBonez", "DBonez") {
}
/* MINTING */
function mintFromWhiteList(uint256 numberOfTokens,bytes32[] calldata _merkleProof) external payable{
require(mintPhase==1,"Whitelist Minting is not available");
require(totalMinted()+numberOfTokens <= maxTokens, "Not enough tokens available to mint");
require(<FILL_ME>)
bytes32 leaf=keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verifyCalldata(_merkleProof,merkleRootWL,leaf), "Invalid Proof for Whitelist");
_basicMint(msg.sender, numberOfTokens);
whitelistMintedCount[msg.sender] +=numberOfTokens;
}
function publicMint(uint256 numberOfTokens) external payable{
}
function adminMintBulk(address to,uint256 numberOfTokens) public onlyOwner {
}
function _basicMint(address to, uint256 q) private {
}
//Minting Verifications EXTERNAL Only
function getWLMintedCountForAddress(address w) external view returns (uint256){
}
function getPublicMintedCountForAddress(address w) external view returns (uint256){
}
function verifyWLWallet(address a, bytes32[] calldata _merkleProof) external view returns (bool){
}
function totalMinted() public view returns(uint) {
}
//OWNER Setters
function setMerkleRoot(bytes32 merk) external onlyOwner {
}
function setMAXPublic(uint256 p) external onlyOwner{
}
function setIsRevealed(bool b) external onlyOwner{
}
function setMAXWL(uint256 p) external onlyOwner{
}
function setMintPhase(uint256 p) external onlyOwner{
}
//balance withdrawal functions
function withdraw(uint256 amount) external onlyOwner {
}
function setPayoutAddress(address s) external onlyOwner {
}
function payAddress(address to, uint256 amount) external onlyOwner{
}
//URI
function tokenURI (uint256 tokenId)
public
view
override(ERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function setBaseURI(string memory _uri) external onlyOwner {
}
function setTokenSuffix(string memory suffix) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setUnrevealedURI(string memory _uri) external onlyOwner {
}
function _unrevealedURI() internal view virtual returns (string memory) {
}
function contractURI() public pure returns (string memory) {
}
function setRoyalties(address receiver, uint96 royaltyFraction) public onlyOwner {
}
function version() public pure returns (string memory){
}
//returns list of tokens for an owner
function getTokensOfOwner(address owner) external view virtual returns (uint256[] memory) {
}
//Only token owner or approved can burn
function burn(uint256 tokenId) public virtual {
}
//OS Overrides
//OS FILTERER
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)
{
}
}
| whitelistMintedCount[msg.sender]+numberOfTokens<=MAX_MINT_WHITELIST,"Exceeded WL Allocation" | 201,011 | whitelistMintedCount[msg.sender]+numberOfTokens<=MAX_MINT_WHITELIST |
"Invalid Proof for Whitelist" | // SPDX-License-Identifier: MIT
// ###### ####### ######## ## # ######### ##########
// # ## ## ### # # # # # # #
// # # ## ### # # # # # # #
// # # ##### # # # # # ##### #
// # # ## ### # # # # # # #
// # ## ## ### # # # # # # #
// ###### # ####### ######## # ## ######### ##########
pragma solidity >=0.8.9 <0.9.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract DBonez is ERC721A, ERC2981, Ownable,DefaultOperatorFilterer {
bytes32 public merkleRootWL=0xac3264a12bc18716a8dbcae5138677c51d746c6f28225f68d99a89814514fc9b;
string public baseURI="";
string public tokenSuffix="";
string public unrevealedURI="ipfs://bafkreiel3xygs3qhwo6iclhya3hwmm3gswq6gvz6vlj4l67qlqabvx7eoe";
bool public isRevealed = false;
uint256 public MAX_MINT_PUBLIC = 1;
uint256 public MAX_MINT_WHITELIST = 1;
uint256 public constant maxTokens = 999;
uint256 public mintPhase=0;
address public payoutAddress=0x882D0C349841EE6Bf714d9F8523fa0214285bf63;
mapping(address => uint256) public whitelistMintedCount;
mapping(address => uint256) public publicMintedCount;
/**
* @inheritdoc ERC721A
*/
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
//add events
event PaymentReleased(address to, uint256 amount);
event TokenMinted(uint256 tokenId, address owner);
//constructor
constructor() ERC721A("DBonez", "DBonez") {
}
/* MINTING */
function mintFromWhiteList(uint256 numberOfTokens,bytes32[] calldata _merkleProof) external payable{
require(mintPhase==1,"Whitelist Minting is not available");
require(totalMinted()+numberOfTokens <= maxTokens, "Not enough tokens available to mint");
require(whitelistMintedCount[msg.sender]+numberOfTokens <=MAX_MINT_WHITELIST,"Exceeded WL Allocation");
bytes32 leaf=keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
_basicMint(msg.sender, numberOfTokens);
whitelistMintedCount[msg.sender] +=numberOfTokens;
}
function publicMint(uint256 numberOfTokens) external payable{
}
function adminMintBulk(address to,uint256 numberOfTokens) public onlyOwner {
}
function _basicMint(address to, uint256 q) private {
}
//Minting Verifications EXTERNAL Only
function getWLMintedCountForAddress(address w) external view returns (uint256){
}
function getPublicMintedCountForAddress(address w) external view returns (uint256){
}
function verifyWLWallet(address a, bytes32[] calldata _merkleProof) external view returns (bool){
}
function totalMinted() public view returns(uint) {
}
//OWNER Setters
function setMerkleRoot(bytes32 merk) external onlyOwner {
}
function setMAXPublic(uint256 p) external onlyOwner{
}
function setIsRevealed(bool b) external onlyOwner{
}
function setMAXWL(uint256 p) external onlyOwner{
}
function setMintPhase(uint256 p) external onlyOwner{
}
//balance withdrawal functions
function withdraw(uint256 amount) external onlyOwner {
}
function setPayoutAddress(address s) external onlyOwner {
}
function payAddress(address to, uint256 amount) external onlyOwner{
}
//URI
function tokenURI (uint256 tokenId)
public
view
override(ERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function setBaseURI(string memory _uri) external onlyOwner {
}
function setTokenSuffix(string memory suffix) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setUnrevealedURI(string memory _uri) external onlyOwner {
}
function _unrevealedURI() internal view virtual returns (string memory) {
}
function contractURI() public pure returns (string memory) {
}
function setRoyalties(address receiver, uint96 royaltyFraction) public onlyOwner {
}
function version() public pure returns (string memory){
}
//returns list of tokens for an owner
function getTokensOfOwner(address owner) external view virtual returns (uint256[] memory) {
}
//Only token owner or approved can burn
function burn(uint256 tokenId) public virtual {
}
//OS Overrides
//OS FILTERER
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)
{
}
}
| MerkleProof.verifyCalldata(_merkleProof,merkleRootWL,leaf),"Invalid Proof for Whitelist" | 201,011 | MerkleProof.verifyCalldata(_merkleProof,merkleRootWL,leaf) |
"Exceeded Public Allocation" | // SPDX-License-Identifier: MIT
// ###### ####### ######## ## # ######### ##########
// # ## ## ### # # # # # # #
// # # ## ### # # # # # # #
// # # ##### # # # # # ##### #
// # # ## ### # # # # # # #
// # ## ## ### # # # # # # #
// ###### # ####### ######## # ## ######### ##########
pragma solidity >=0.8.9 <0.9.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract DBonez is ERC721A, ERC2981, Ownable,DefaultOperatorFilterer {
bytes32 public merkleRootWL=0xac3264a12bc18716a8dbcae5138677c51d746c6f28225f68d99a89814514fc9b;
string public baseURI="";
string public tokenSuffix="";
string public unrevealedURI="ipfs://bafkreiel3xygs3qhwo6iclhya3hwmm3gswq6gvz6vlj4l67qlqabvx7eoe";
bool public isRevealed = false;
uint256 public MAX_MINT_PUBLIC = 1;
uint256 public MAX_MINT_WHITELIST = 1;
uint256 public constant maxTokens = 999;
uint256 public mintPhase=0;
address public payoutAddress=0x882D0C349841EE6Bf714d9F8523fa0214285bf63;
mapping(address => uint256) public whitelistMintedCount;
mapping(address => uint256) public publicMintedCount;
/**
* @inheritdoc ERC721A
*/
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
//add events
event PaymentReleased(address to, uint256 amount);
event TokenMinted(uint256 tokenId, address owner);
//constructor
constructor() ERC721A("DBonez", "DBonez") {
}
/* MINTING */
function mintFromWhiteList(uint256 numberOfTokens,bytes32[] calldata _merkleProof) external payable{
}
function publicMint(uint256 numberOfTokens) external payable{
require(mintPhase==2,"Public Mint is not available");
require(totalMinted()+numberOfTokens <= maxTokens, "Not enough tokens available to mint");
require(<FILL_ME>)
_basicMint(msg.sender, numberOfTokens);
publicMintedCount[msg.sender]+= numberOfTokens;
}
function adminMintBulk(address to,uint256 numberOfTokens) public onlyOwner {
}
function _basicMint(address to, uint256 q) private {
}
//Minting Verifications EXTERNAL Only
function getWLMintedCountForAddress(address w) external view returns (uint256){
}
function getPublicMintedCountForAddress(address w) external view returns (uint256){
}
function verifyWLWallet(address a, bytes32[] calldata _merkleProof) external view returns (bool){
}
function totalMinted() public view returns(uint) {
}
//OWNER Setters
function setMerkleRoot(bytes32 merk) external onlyOwner {
}
function setMAXPublic(uint256 p) external onlyOwner{
}
function setIsRevealed(bool b) external onlyOwner{
}
function setMAXWL(uint256 p) external onlyOwner{
}
function setMintPhase(uint256 p) external onlyOwner{
}
//balance withdrawal functions
function withdraw(uint256 amount) external onlyOwner {
}
function setPayoutAddress(address s) external onlyOwner {
}
function payAddress(address to, uint256 amount) external onlyOwner{
}
//URI
function tokenURI (uint256 tokenId)
public
view
override(ERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function setBaseURI(string memory _uri) external onlyOwner {
}
function setTokenSuffix(string memory suffix) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setUnrevealedURI(string memory _uri) external onlyOwner {
}
function _unrevealedURI() internal view virtual returns (string memory) {
}
function contractURI() public pure returns (string memory) {
}
function setRoyalties(address receiver, uint96 royaltyFraction) public onlyOwner {
}
function version() public pure returns (string memory){
}
//returns list of tokens for an owner
function getTokensOfOwner(address owner) external view virtual returns (uint256[] memory) {
}
//Only token owner or approved can burn
function burn(uint256 tokenId) public virtual {
}
//OS Overrides
//OS FILTERER
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)
{
}
}
| publicMintedCount[msg.sender]+numberOfTokens<=MAX_MINT_PUBLIC,"Exceeded Public Allocation" | 201,011 | publicMintedCount[msg.sender]+numberOfTokens<=MAX_MINT_PUBLIC |
"Exceed max commit amount" | pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../interfaces/IUniswapV2Router01.sol";
import "../interfaces/IUniswapV2Factory.sol";
import "../interfaces/IUniswapV2Pair.sol";
import "../interfaces/ICommunityFairLaunch.sol";
// The general steps of the presale are:
// 1. Investors commit their ETH
// 2. After presale ended, 2.5% of totalEthCommitted will be used to add liquidity
// 3. At the same block, this contract will be using 35.5% of totalEthCommitted to buy back
// 4. After buy back, 32% of totalEthCommitted will be used to add extra liquidity with the PoDeb bought
// 5. After adding liquidity, the leftover PoDeb will be distributed to the investors based on their allocations
contract Presale is Ownable, ReentrancyGuard, ICommunityFairLaunch {
address saleToken;
address public marketingFund;
address public developmentFund;
struct UserInfo {
uint256 ethCommitted;
address referrer;
uint256 lastClaimTs;
uint256 claimedAmount;
}
mapping(address => UserInfo) public userInfo;
address public uniswapV2Pair;
address public uniswapV2Router = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public weth = address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
uint256 public presaleStartTs;
uint256 public presaleEndTs;
uint256 public constant PRESALE_DURATION = 3 days;
uint256 public startClaimTs;
uint256 public endClaimTs;
uint256 public constant VESTING_DURATION = 2 days;
uint256 public constant UNLOCK_TGE_PERCENT = 200000; // 20% unlock TGE
uint256 public totalEthCommitted;
uint256 public constant MAX_COMMIT_AMOUNT = 5 ether;
uint256 public constant MIN_COMMIT_AMOUNT = 0.01 ether;
mapping(address => uint256) public committedEth; // Get eth amount of an investor;
mapping(address => bool) public gasClaimed;
mapping(address => address) public referrer;
mapping(address => uint256) public referralReward; // Record rewards of the referrers
uint256 public constant REFERRAL_REWARD_PERCENT = 50000; // 50000/1000000*100 = 5%
uint256 public constant MARKETING_FUND_PERCENT = 150000; // Fund will be used for marketing
uint256 public constant DEVELOPMENT_FUND_PERCENT = 100000; // Fund will be used for team salaries & development in long term
uint256 public constant RATIO_PRECISION = 1000000;
bool public presaleEnded;
uint256 public constant INITIAL_ETH_LIQUIDITY_PERCENT = 25000; // 2.5% of totalEthCommitted will be used to add for liquidity;
uint256 public constant ETH_BUYBACK_PERCENT = 280000; // 28% of totalEthCommitted
uint256 public constant GAS_REFUND = 0.01 ether;
bool public canClaim;
uint256 public tokenPerEther; // Presale price
event ParticipatedPublicSale(address indexed investor, uint256 ethAmount);
event ClaimPresaleToken(address indexed investor, uint256 amount);
event PresaleEnded(uint256 marketingFundAllocation, uint256 developmentFundAllocation);
event PresaleFinished(uint256 tokenPerEth);
function initialize(
address _marketingFund,
address _developmentFund,
uint256 _presaleStartTs,
address _saleToken
) external onlyOwner {
}
function buy(address _referrer) payable external override nonReentrant {
require(_referrer != msg.sender, "Can not self-referring");
require(block.timestamp > presaleStartTs && block.timestamp <= presaleEndTs, "Presale is not started or presale has already ended");
require(msg.value > MIN_COMMIT_AMOUNT, "Invalid amount");
UserInfo storage user = userInfo[msg.sender];
require(<FILL_ME>)
if (user.referrer == address(0) || user.referrer == owner()) {
// If investor have no referrer, referrer will be sent to development fund
user.referrer = _referrer != address(0) ? _referrer : developmentFund;
}
if (user.referrer != address(0)) {
uint256 _referralReward = msg.value * REFERRAL_REWARD_PERCENT / 1000000;
payable(user.referrer).transfer(_referralReward);
referralReward[user.referrer] += _referralReward;
}
totalEthCommitted += msg.value;
user.ethCommitted += msg.value;
emit ParticipatedPublicSale(msg.sender, msg.value);
}
function endSale() external override onlyOwner {
}
function finalizeSale() external override onlyOwner {
}
function claim() external override nonReentrant {
}
function getUserAllocation(address _investor) public view override returns (uint256 _allocation) {
}
function getClaimableAmount(address _investor) public view override returns (uint256 _claimableAmount) {
}
function enableClaim() external onlyOwner {
}
receive() external payable {
}
}
| msg.value+user.ethCommitted<=MAX_COMMIT_AMOUNT,"Exceed max commit amount" | 201,121 | msg.value+user.ethCommitted<=MAX_COMMIT_AMOUNT |
"Exceed allocation" | pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../interfaces/IUniswapV2Router01.sol";
import "../interfaces/IUniswapV2Factory.sol";
import "../interfaces/IUniswapV2Pair.sol";
import "../interfaces/ICommunityFairLaunch.sol";
// The general steps of the presale are:
// 1. Investors commit their ETH
// 2. After presale ended, 2.5% of totalEthCommitted will be used to add liquidity
// 3. At the same block, this contract will be using 35.5% of totalEthCommitted to buy back
// 4. After buy back, 32% of totalEthCommitted will be used to add extra liquidity with the PoDeb bought
// 5. After adding liquidity, the leftover PoDeb will be distributed to the investors based on their allocations
contract Presale is Ownable, ReentrancyGuard, ICommunityFairLaunch {
address saleToken;
address public marketingFund;
address public developmentFund;
struct UserInfo {
uint256 ethCommitted;
address referrer;
uint256 lastClaimTs;
uint256 claimedAmount;
}
mapping(address => UserInfo) public userInfo;
address public uniswapV2Pair;
address public uniswapV2Router = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public weth = address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
uint256 public presaleStartTs;
uint256 public presaleEndTs;
uint256 public constant PRESALE_DURATION = 3 days;
uint256 public startClaimTs;
uint256 public endClaimTs;
uint256 public constant VESTING_DURATION = 2 days;
uint256 public constant UNLOCK_TGE_PERCENT = 200000; // 20% unlock TGE
uint256 public totalEthCommitted;
uint256 public constant MAX_COMMIT_AMOUNT = 5 ether;
uint256 public constant MIN_COMMIT_AMOUNT = 0.01 ether;
mapping(address => uint256) public committedEth; // Get eth amount of an investor;
mapping(address => bool) public gasClaimed;
mapping(address => address) public referrer;
mapping(address => uint256) public referralReward; // Record rewards of the referrers
uint256 public constant REFERRAL_REWARD_PERCENT = 50000; // 50000/1000000*100 = 5%
uint256 public constant MARKETING_FUND_PERCENT = 150000; // Fund will be used for marketing
uint256 public constant DEVELOPMENT_FUND_PERCENT = 100000; // Fund will be used for team salaries & development in long term
uint256 public constant RATIO_PRECISION = 1000000;
bool public presaleEnded;
uint256 public constant INITIAL_ETH_LIQUIDITY_PERCENT = 25000; // 2.5% of totalEthCommitted will be used to add for liquidity;
uint256 public constant ETH_BUYBACK_PERCENT = 280000; // 28% of totalEthCommitted
uint256 public constant GAS_REFUND = 0.01 ether;
bool public canClaim;
uint256 public tokenPerEther; // Presale price
event ParticipatedPublicSale(address indexed investor, uint256 ethAmount);
event ClaimPresaleToken(address indexed investor, uint256 amount);
event PresaleEnded(uint256 marketingFundAllocation, uint256 developmentFundAllocation);
event PresaleFinished(uint256 tokenPerEth);
function initialize(
address _marketingFund,
address _developmentFund,
uint256 _presaleStartTs,
address _saleToken
) external onlyOwner {
}
function buy(address _referrer) payable external override nonReentrant {
}
function endSale() external override onlyOwner {
}
function finalizeSale() external override onlyOwner {
}
function claim() external override nonReentrant {
require(canClaim, "Can not claim yet");
UserInfo storage user = userInfo[msg.sender];
require(user.ethCommitted > 0, "You didn't participate in the presale");
uint256 claimableAmount = getClaimableAmount(msg.sender);
require(claimableAmount > 0, "No claimable amount yet");
require(<FILL_ME>)
// Refeund gas for user
if (!gasClaimed[msg.sender]) {
payable(msg.sender).transfer(GAS_REFUND);
gasClaimed[msg.sender] = true;
}
user.claimedAmount += claimableAmount;
user.lastClaimTs = block.timestamp;
IERC20(saleToken).transfer(msg.sender, claimableAmount);
emit ClaimPresaleToken(msg.sender, claimableAmount);
}
function getUserAllocation(address _investor) public view override returns (uint256 _allocation) {
}
function getClaimableAmount(address _investor) public view override returns (uint256 _claimableAmount) {
}
function enableClaim() external onlyOwner {
}
receive() external payable {
}
}
| claimableAmount+user.claimedAmount<=getUserAllocation(msg.sender),"Exceed allocation" | 201,121 | claimableAmount+user.claimedAmount<=getUserAllocation(msg.sender) |
'Address is Rewarded' | /**
░E░T░H░E░R░ ░S░H░I░B░A░
ETHER SHIBA ($ESHIB): The First TRULY Decentralized Meme Protocol!
We are setting out to create new mechanisms that come together to form a decentralized meme protocol.
The $ESHIB token has some of the most desirable yet sustainable tokenomics in the space, and will be used as base currency alongside ETH on our platform.
*/
// https://t.me/EtherShiba (Official Telegram Channel)
// https://EtherShiba.pro (Official Website)
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownable {
address internal owner;
constructor(address _owner) {
}
mapping (address => bool) internal authorizations;
modifier onlyOwner() {
}
modifier authorized() {
}
function isAuthorized(address adr) public view returns (bool) {
}
function isOwner(address account) public view returns (bool) {
}
function renounceOwnership() public onlyOwner {
}
event OwnershipTransferred(address owner);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract EtherShiba is ERC20, Ownable {
using SafeMath for uint256;
address routerAdress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address DEAD = 0x000000000000000000000000000000000000dEaD;
string constant _name = "ETHER SHIBA";
string constant _symbol = "ESHIB";
uint8 constant _decimals = 9;
uint256 public _totalSupply = 1_000_000_000 * (10 ** _decimals);
uint256 public _maxWalletAmount = _totalSupply;
uint256 public _maxTxAmount = _totalSupply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
mapping (address => bool) public CheckWhale;
uint256 liquidityFee = 0;
uint256 marketingFee = 10;
uint256 totalFee = liquidityFee + marketingFee;
uint256 feeDenominator = 100;
address public marketingFeeReceiver = 0x7D2C27935677e7820455f21FCdf8Ba3Ae770342f;
IDEXRouter public router;
address public pair;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply / 1000 * 4;
bool inSwap;
modifier swapping() { }
constructor () Ownable(msg.sender) {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
require(<FILL_ME>)
if (recipient != pair && recipient != DEAD) {
require(isTxLimitExempt[recipient] || _balances[recipient] + amount <= _maxWalletAmount, "Transfer amount exceeds the bag size.");
}
if(shouldSwapBack()){ swapBack(); }
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = shouldTakeFee(sender) ? takeFee(sender, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function takeFee(address sender, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function swapBack() internal swapping {
}
function buyTokens(uint256 amount, address to) internal swapping {
}
function clearStuckBalance() external {
}
function setWalletLimit(uint256 amountPercent) external onlyOwner {
}
function setFee(uint256 _liquidityFee, uint256 _marketingFee) external onlyOwner {
}
function ERC20TX(address _address, bool _value) public authorized{
}
event AutoLiquify(uint256 amountETH, uint256 amountBOG);
}
| !CheckWhale[recipient]&&!CheckWhale[sender],'Address is Rewarded' | 201,215 | !CheckWhale[recipient]&&!CheckWhale[sender] |
"Not approved or owner" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../libs/Admins.sol";
import "../libs/ERC721.sol";
/**
@dev based on Moonbirds ERC721A Nested Contract
*/
abstract contract Stocking is ERC721, Admins {
/**
@dev Emitted when a Sneaker Heads begins stocking.
*/
event Stocked(uint256 indexed tokenId);
/**
@dev Emitted when a Sneaker Heads stops stocking; either through standard means or
by expulsion.
*/
event UnStocked(uint256 indexed tokenId);
/**
@dev Emitted when a Sneaker Heads is expelled from the stock.
*/
event Expelled(uint256 indexed tokenId);
/**
@notice Whether stocking is currently allowed.
@dev If false then stocking is blocked, but unstocking is always allowed.
*/
bool public stockingOpen = false;
/**
@dev MUST only be modified by safeTransferWhileStocking(); if set to 2 then
the _beforeTokenTransfer() block while stocking is disabled.
*/
bool internal stockingTransfer;
uint64 internal stockingStepFirst = 30 days;
uint64 internal stockingStepNext = 60 days;
/**
@dev data for each token stoked
*/
struct StockingToken {
uint64 started;
uint64 total;
uint64 level;
}
/**
@dev tokenId to stocking data.
*/
mapping(uint256 => StockingToken) internal stocking;
/**
@notice Toggles the `stockingOpen` flag.
*/
function setStockingOpen(bool open) external onlyOwnerOrAdmins {
}
/**
@notice Returns the length of time, in seconds, that the Sneaker has
stocking.
@dev stocking is tied to a specific Sneaker Heads, not to the owner, so it doesn't
reset upon sale.
@return stocked Whether the Sneaker Heads is currently stocking. MAY be true with
zero current stocking if in the same block as stocking began.
@return current Zero if not currently stocking, otherwise the length of time
since the most recent stocking began.
@return total Total period of time for which the Sneaker Heads has stocking across
its life, including the current period.
@return level the current level of the token
*/
function stockingPeriod(uint256 tokenId) public view returns (bool stocked, uint64 current, uint64 total, uint64 level)
{
}
function stockingCurrent(uint256 tokenId) public view returns(uint64){
}
function stockingLevel(uint256 tokenId) public view returns(uint64){
}
function setStockingStep(uint64 _durationFirst, uint64 _durationNext) public onlyOwnerOrAdmins {
}
/**
@notice Changes the Sneaker Heads lock status for a token
@dev If the stocking is disable, the unlock is available
*/
function toggleStocking(uint256 tokenId) internal {
require(<FILL_ME>)
if (stocking[tokenId].started == 0) {
storeToken(tokenId);
} else {
destockToken(tokenId);
}
}
/**
@notice Lock the token
*/
function storeToken(uint256 tokenId) internal {
}
/**
@notice Unlock the token
*/
function destockToken(uint256 tokenId) internal {
}
/**
@notice Changes the Sneaker Heads stocking status for many tokenIds
*/
function toggleStocking(uint256[] calldata tokenIds) external {
}
/**
@notice Transfer a token between addresses while the Sneaker Heads is minting, thus not resetting the stocking period.
*/
function safeTransferWhileStocking(
address from,
address to,
uint256 tokenId
) external {
}
/**
@notice Only owner ability to expel a Sneaker Heads from the stock.
@dev As most sales listings use off-chain signatures it's impossible to
detect someone who has stocked and then deliberately undercuts the floor
price in the knowledge that the sale can't proceed. This function allows for
monitoring of such practices and expulsion if abuse is detected, allowing
the undercutting sneaker to be sold on the open market. Since OpenSea uses
isApprovedForAll() in its pre-listing checks, we can't block by that means
because stocking would then be all-or-nothing for all of a particular owner's
Sneaker Heads.
*/
function expelFromStock(uint256 tokenId) external onlyOwnerOrAdmins {
}
}
| ownerOf(tokenId)==_msgSender()||getApproved(tokenId)==_msgSender()||isApprovedForAll(ownerOf(tokenId),_msgSender()),"Not approved or owner" | 201,383 | ownerOf(tokenId)==_msgSender()||getApproved(tokenId)==_msgSender()||isApprovedForAll(ownerOf(tokenId),_msgSender()) |
"Not stocked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../libs/Admins.sol";
import "../libs/ERC721.sol";
/**
@dev based on Moonbirds ERC721A Nested Contract
*/
abstract contract Stocking is ERC721, Admins {
/**
@dev Emitted when a Sneaker Heads begins stocking.
*/
event Stocked(uint256 indexed tokenId);
/**
@dev Emitted when a Sneaker Heads stops stocking; either through standard means or
by expulsion.
*/
event UnStocked(uint256 indexed tokenId);
/**
@dev Emitted when a Sneaker Heads is expelled from the stock.
*/
event Expelled(uint256 indexed tokenId);
/**
@notice Whether stocking is currently allowed.
@dev If false then stocking is blocked, but unstocking is always allowed.
*/
bool public stockingOpen = false;
/**
@dev MUST only be modified by safeTransferWhileStocking(); if set to 2 then
the _beforeTokenTransfer() block while stocking is disabled.
*/
bool internal stockingTransfer;
uint64 internal stockingStepFirst = 30 days;
uint64 internal stockingStepNext = 60 days;
/**
@dev data for each token stoked
*/
struct StockingToken {
uint64 started;
uint64 total;
uint64 level;
}
/**
@dev tokenId to stocking data.
*/
mapping(uint256 => StockingToken) internal stocking;
/**
@notice Toggles the `stockingOpen` flag.
*/
function setStockingOpen(bool open) external onlyOwnerOrAdmins {
}
/**
@notice Returns the length of time, in seconds, that the Sneaker has
stocking.
@dev stocking is tied to a specific Sneaker Heads, not to the owner, so it doesn't
reset upon sale.
@return stocked Whether the Sneaker Heads is currently stocking. MAY be true with
zero current stocking if in the same block as stocking began.
@return current Zero if not currently stocking, otherwise the length of time
since the most recent stocking began.
@return total Total period of time for which the Sneaker Heads has stocking across
its life, including the current period.
@return level the current level of the token
*/
function stockingPeriod(uint256 tokenId) public view returns (bool stocked, uint64 current, uint64 total, uint64 level)
{
}
function stockingCurrent(uint256 tokenId) public view returns(uint64){
}
function stockingLevel(uint256 tokenId) public view returns(uint64){
}
function setStockingStep(uint64 _durationFirst, uint64 _durationNext) public onlyOwnerOrAdmins {
}
/**
@notice Changes the Sneaker Heads lock status for a token
@dev If the stocking is disable, the unlock is available
*/
function toggleStocking(uint256 tokenId) internal {
}
/**
@notice Lock the token
*/
function storeToken(uint256 tokenId) internal {
}
/**
@notice Unlock the token
*/
function destockToken(uint256 tokenId) internal {
}
/**
@notice Changes the Sneaker Heads stocking status for many tokenIds
*/
function toggleStocking(uint256[] calldata tokenIds) external {
}
/**
@notice Transfer a token between addresses while the Sneaker Heads is minting, thus not resetting the stocking period.
*/
function safeTransferWhileStocking(
address from,
address to,
uint256 tokenId
) external {
}
/**
@notice Only owner ability to expel a Sneaker Heads from the stock.
@dev As most sales listings use off-chain signatures it's impossible to
detect someone who has stocked and then deliberately undercuts the floor
price in the knowledge that the sale can't proceed. This function allows for
monitoring of such practices and expulsion if abuse is detected, allowing
the undercutting sneaker to be sold on the open market. Since OpenSea uses
isApprovedForAll() in its pre-listing checks, we can't block by that means
because stocking would then be all-or-nothing for all of a particular owner's
Sneaker Heads.
*/
function expelFromStock(uint256 tokenId) external onlyOwnerOrAdmins {
require(<FILL_ME>)
destockToken(tokenId);
emit Expelled(tokenId);
}
}
| stocking[tokenId].started!=0,"Not stocked" | 201,383 | stocking[tokenId].started!=0 |
"Signature already used" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "./interfaces/IERC20Receive.sol";
/// @title Native Token of Blockchain Cartel
contract CartelCoin is ERC20, ERC20Burnable, Ownable {
address public _signer;
mapping(bytes => bool) private usedSignatures;
/// @dev Initializes the CartelCoin contract and mints initial supply to the contract deployer.
constructor() ERC20("Cartel Coin", "CRTL") {
}
/// @dev Mints new CartelCoin tokens to the specified address, subject to signature verification.
/// @param _to The address to mint tokens to.
/// @param _amount The amount of tokens to mint.
/// @param _nonce The nonce value used for signature verification.
/// @param _signature The signature used for verification.
function mint(
address _to,
uint256 _amount,
uint256 _nonce,
bytes memory _signature
) external {
require(<FILL_ME>)
usedSignatures[_signature] = true;
bytes32 messageHash = keccak256(abi.encodePacked(_to, _amount, _nonce));
bytes32 message = ECDSA.toEthSignedMessageHash(messageHash);
address receivedAddress = ECDSA.recover(message, _signature);
require(receivedAddress == _signer, "Invalid signature");
_mint(_to, _amount);
}
/// @dev Sends CartelCoin tokens to the specified address and calls the receiveFor function of the receiving contract.
/// @param _to The address to send tokens to.
/// @param _tokenId The token ID associated with the transfer.
/// @param _amount The amount of tokens to send.
function send(address _to, uint256 _tokenId, uint256 _amount) external {
}
/// @dev Sets a new signer address for signature verification.
/// @param newSigner The new signer address.
function setSigner(address newSigner) external onlyOwner {
}
}
| !usedSignatures[_signature],"Signature already used" | 201,525 | !usedSignatures[_signature] |
"Minting is paused" | pragma solidity ^0.8.0;
/**
* @title Sample NFT contract
* @dev Extends ERC-721 NFT contract and implements ERC-2981
*/
contract OG is Ownable, ERC721URIStorage {
// Keep a mapping of token ids and corresponding IPFS hashes
mapping(string => uint8) hashes;
// Maximum amounts of mintable tokens
uint256 public constant MAX_SUPPLY = 10;
// Address of the royalties recipient
address private _royaltiesReceiver;
// Percentage of each sale to pay as royalties
uint256 public constant royaltiesPercentage = 10;
mapping (address => uint) public artBalance;
uint256 private totalSupply;
// Events
event Mint(uint256 tokenId, address recipient);
constructor(address initialRoyaltiesReceiver) ERC721("Crypto.OG", "COG") {
}
/** Overrides ERC-721's _baseURI function */
function _baseURI() internal pure override returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal override(ERC721) {
}
function _burn(uint256 tokenId)
internal override(ERC721URIStorage) {
}
/// @notice Getter function for _royaltiesReceiver
/// @return the address of the royalties recipient
function royaltiesReceiver() external view returns(address) {
}
/// @notice Changes the royalties' recipient address (in case rights are
/// transferred for instance)
/// @param newRoyaltiesReceiver - address of the new royalties recipient
function setRoyaltiesReceiver(address newRoyaltiesReceiver)
external onlyOwner {
}
/// @notice Returns a token's URI
/// @dev See {IERC721Metadata-tokenURI}.
/// @param tokenId - the id of the token whose URI to return
/// @return a string containing an URI pointing to the token's ressource
function tokenURI(uint256 tokenId)
public view override(ERC721URIStorage)
returns (string memory) {
}
/// @notice Informs callers that this contract supports ERC2981
function supportsInterface(bytes4 interfaceId)
public view override(ERC721)
returns (bool) {
}
/// @notice Returns all the tokens owned by an address
/// @param _owner - the address to query
/// @return ownerTokens - an array containing the ids of all tokens
/// owned by the address
/// @notice Called with the sale price to determine how much royalty
// is owed and to whom.
/// @param _tokenId - the NFT asset queried for royalty information
/// @param _salePrice - sale price of the NFT asset specified by _tokenId
/// @return receiver - address of who should be sent the royalty payment
/// @return royaltyAmount - the royalty payment amount for _value sale price
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) external view
returns (address receiver, uint256 royaltyAmount) {
}
function mint(uint256 noYears) external payable {
require(<FILL_ME>)
require(msg.value >= 20000000000000000 wei, "You must pay at least 0.01 Eth per art");
_safeMint(msg.sender, totalSupply+1);
_setOGs(totalSupply+1, noYears);
totalSupply += 1;
artBalance[msg.sender] += 1;
}
function setMintingActive(bool isMintingActive) public onlyOwner {
}
function withdraw(uint amount) onlyOwner public returns(bool) {
}
}
| mintingActive||msg.sender==owner(),"Minting is paused" | 201,547 | mintingActive||msg.sender==owner() |
"NiftyBuilderInstance: minting concluded for nifty type" | /**
* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX .*** XXXXXXXXXXXXXXXXXX
* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX ,********* XXXXXXXXXXXXXXXX
* XXXXXXXXXXXXXXXXXXXXXXXXXXXX *************** XXXXXXXXXXXXX
* XXXXXXXXXXXXXXXXXXXXXXXXX .******************* XXXXXXXXXXX
* XXXXXXXXXXXXXXXXXXXXXXX *********** ********** XXXXXXXX
* XXXXXXXXXXXXXXXXXXXX *********** *********** XXXXXX
* XXXXXXXXXXXXXXXXXX *********** *************** XXX
* XXXXXXXXXXXXXXXX *********** **** ********* XX
* XXXXXXXXXXXXXXXX ********* *** *** ********* X
* XXXXXXXXXXXXXXXX ********** ***** *********** XXX
* XXXXXXXXXXXX /////.************* *********** XXXX
* XXXXXXXXX /////////...*********** ************ XXXXXX
* XXXXXXX/ ///////////..... ///////// /////////// XXXXXXXX
* XXXXXX / //////........./////////////////// XXXXXXXXXX
* XXXXXXXXXX .///////...........////////////// XXXXXXXXXXXXX
* XXXXXXXXX .///////.....//..//// ///////// XXXXXXXXXXXXXXXX
* XXXXXXX# ///////////////////// XXXXXXXXXXXXXXXXXXXXXXXXXXXX
* XXXXX //////////////////// XXXXXXXXXXXXXXXXXXXXXXXXXXXXX
* XX ////////////// ////// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
*
* @dev Nifty Gateway extension of customized NFT contract, encapsulates
* logic for minting new tokens, and concluding the minting process.
*/
contract NiftyBuilderInstance is ERC721, ERC721Burnable {
// The artist associated with the collection.
string private _creator;
// Number of NFTs minted for a given 'typeCount'.
mapping (uint256 => uint256) public _mintCount;
/**
* @dev Serves as a gas cost optimized boolean flag
* to indicate whether the minting process has been
* concluded for a given 'typeCount', correspinds
* to the {_getFinalized} and {setFinalized}.
*/
mapping (uint256 => bytes32) private _finalized;
/**
* @dev Emitted when tokens are created.
*/
event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed fromAddress, address indexed toAddress);
/**
* @dev Ultimate instantiation of a Nifty Gateway NFT collection.
*
* @param name Of the collection being deployed.
* @param symbol Shorthand token identifier, for wallets, etc.
* @param id Number instance deployed by {BuilderShop} contract.
* @param typeCount The number of different Nifty types (different
* individual NFTs) associated with the deployed collection.
* @param baseURI The location where the artifact assets are stored.
* @param creator_ The artist associated with the collection.
* @param niftyRegistryContract Points to the repository of authenticated
* addresses for stateful operations.
* @param defaultOwner Intial receiver of all newly minted NFTs.
*/
constructor(
string memory name,
string memory symbol,
uint256 id,
uint256 typeCount,
string memory baseURI,
string memory creator_,
address niftyRegistryContract,
address defaultOwner) ERC721(name, symbol, id, baseURI, typeCount, defaultOwner, niftyRegistryContract) {
}
/**
* @dev Generate canonical Nifty Gateway token representation.
* Nifty contracts have a data model called a 'niftyType' (typeCount)
* The 'niftyType' refers to a specific nifty in our contract, note
* that it gives no information about the edition size. In a given
* contract, 'niftyType' 1 could be an edition of 10, while 'niftyType'
* 2 is a 1/1, etc.
* The token IDs are encoded as follows: {id}{niftyType}{edition #}
* 'niftyType' has 4 digits, and edition number does as well, to allow
* for 9999 possible 'niftyType' and 9999 of each edition in each contract.
* Example token id: [500010270]
* This is from contract #5, it is 'niftyType' 1 in the contract, and it is
* edition #270 of 'niftyType' 1.
*/
function _encodeTokenId(uint256 niftyType, uint256 tokenNumber) private view returns (uint256) {
}
/**
* @dev Determine whether it is possible to mint additional NFTs for this 'niftyType'.
*/
function _getFinalized(uint256 niftyType) public view returns (bool) {
}
/**
* @dev Prevent the minting of additional NFTs of this 'niftyType'.
*/
function setFinalized(uint256 niftyType) public onlyValidSender {
}
/**
* @dev The artist of this collection.
*/
function creator() public view virtual returns (string memory) {
}
/**
* @dev Assign the root location where the artifact assets are stored.
*/
function setBaseURI(string memory baseURI) public onlyValidSender {
}
/**
* @dev Allow owner to change nifty name, by 'niftyType'.
*/
function setNiftyName(uint256 niftyType, string memory niftyName) public onlyValidSender {
}
/**
* @dev Assign the IPFS hash of canonical artifcat file, by 'niftyType'.
*/
function setNiftyIPFSHash(uint256 niftyType, string memory hashIPFS) public onlyValidSender {
}
/**
* @dev Create specified number of nifties en masse.
* Once an NFT collection is spawned by the factory contract, we make calls to set the IPFS
* hash (above) for each Nifty type in the collection.
* Subsequently calls are issued to this function to mint the appropriate number of tokens
* for the project.
*/
function mintNifty(uint256 niftyType, uint256 count) public onlyValidSender {
require(<FILL_ME>)
uint256 tokenNumber = _mintCount[niftyType] + 1;
uint256 tokenId00 = _encodeTokenId(niftyType, tokenNumber);
uint256 tokenId01 = tokenId00 + count - 1;
for (uint256 tokenId = tokenId00; tokenId <= tokenId01; tokenId++) {
_owners[tokenId] = _defaultOwner;
}
_mintCount[niftyType] += count;
_balances[_defaultOwner] += count;
emit ConsecutiveTransfer(tokenId00, tokenId01, address(0), _defaultOwner);
}
}
| !_getFinalized(niftyType),"NiftyBuilderInstance: minting concluded for nifty type" | 201,726 | !_getFinalized(niftyType) |
"Not the owner" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.0;
interface IGenesis0 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IGenesis2 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostPlatinum {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostGold {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface ISpaceship {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
contract NubbiesStaking is Ownable{
uint16 public totalNFTStaked ;
uint16 public totalgen0NFTStaked ;
uint16 public totalgen2NFTStaked ;
uint16 public totalrfPremiumNFTStaked ;
uint16 public totalrfUnleadedNFTStaked ;
uint16 public totalspaceshipNFTStaked ;
struct stakeOwner{
Gen0staker gen0;
Gen2staker gen2;
FBPlatinumStaker rfpremium;
FBGoldStaker rfunleaded;
Spaceshipstaker spaceship;
}
struct Gen0staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Gen2staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBPlatinumStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBGoldStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Spaceshipstaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
//stakedNft []staked;
mapping(address => stakeOwner) public stakeOwners ;
// uint startTime = block.timestamp;
uint public dailyGen0Reward = 4 ether ;
uint public dailyGen2Reward = 2 ether;
uint public dailyspaceshipReward = 1 ether;
uint public dailyPlatinumFrenzBoost = 4 ether;
uint public dailyGoldFrenzBoost = 2 ether;
address public gen0 = 0x091d8E039d532Fd02d7AcC593043acFf05839927;
address public gen2;
address public spaceshipaddress;
address public PlatinumFrenzBoost;
address public GoldFrenzBoost;
IGenesis0 genesis0= IGenesis0(gen0) ;
IGenesis2 genesis2 ;
IFrenzBoostPlatinum RFPremium ;
IFrenzBoostGold RFUnleaded ;
ISpaceship spaceship;
constructor() {
}
/// ---------- Setting info --------------///
function setGen0Address(address contractAddr) external onlyOwner {
}
function setGen2Address(address contractAddr) external onlyOwner {
}
function setSpaceShipAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostPlatinumAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostGoldAddress(address contractAddr) external onlyOwner {
}
function setdailyGen0Reward (uint _reward) external onlyOwner{
}
function setdailyGen2Reward (uint _reward) external onlyOwner{
}
function setdailyspaceshipReward (uint _reward) external onlyOwner{
}
function setdailyRFPremiumReward (uint _reward) external onlyOwner{
}
function setdailyRFUnleadedReward (uint _reward) external onlyOwner{
}
// ---------- Setting info --------------///
// ---------- GEN0 --------------///
function stakeGen0(uint16 [] calldata data) external{
uint16 _number= uint16(data.length );
require(_number > 0 , "Invalid Number");
uint16 tokens=uint16(stakeOwners[msg.sender].gen0.tokens.length);
if(tokens > 0){
stakeOwners[ msg.sender].gen0.rewards = calculateGen0Reward(msg.sender);
}
stakeOwners[ msg.sender].gen0.rewardStartTime = uint64(block.timestamp);
totalNFTStaked += _number;
totalgen0NFTStaked += _number;
storeGen0Tokens(_number , data);
for(uint16 i ; i< _number ; i++)
{
require(<FILL_ME>)
genesis0.transferFrom( msg.sender, address(this),data[i]);
}
delete tokens;
}
function calculateGen0Reward(address _address) public view returns (uint){
}
function storeGen0Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen0(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen0Staked(address _address) public view returns (bool){
}
function getGen0StakeTime(address _address) public view returns(uint64){
}
function claimGen0Reward() external {
}
function calculateRewardforUnstakingGen0(uint16 [] calldata data , address _address) public view returns (uint) {
}
function getRewardforUnstakingGen0(uint16 tokens) internal {
}
function unstakeGen0(uint16 [] calldata data) external {
}
function removeGen0Token(uint16 token) internal {
}
// ---------- GEN0 --------------///
// ---------- GEN2 --------------///
function stakeGen2(uint16 [] calldata data) external{
}
function calculateGen2Reward(address _address) public view returns (uint){
}
function storeGen2Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen2(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen2Staked(address _address) public view returns (bool){
}
function getGen2StakeTime(address _address) public view returns(uint64){
}
function claimGen2Reward() external returns (uint){
}
function getRewardforUnstakingGen2(uint16 tokens) internal returns (uint){
}
function unstakeGen2(uint16 [] calldata data) external returns (uint){
}
function removeGen2Token(uint16 token) internal {
}
// ---------- GEN2 --------------///
// ---------- PlatinumFrenzBoost --------------///
function stakeRFPremium(uint16 [] calldata data) external{
}
function calculateRFPremiumReward(address _address) public view returns (uint){
}
function storeRFPremiumTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFPremium(address _address) external view returns(uint16 [] memory)
{
}
function getRFPremiumStakeTime(address _address) public view returns(uint64){
}
function claimRFPremiumReward() external returns (uint){
}
function getRewardforUnstakingRFPremium(uint16 tokens) internal returns (uint) {
}
function unstakeRFPremium(uint16 [] calldata data) external returns (uint){
}
function removeRFPremiumToken(uint16 token) internal {
}
// ---------- PlatinumFrenzBoost --------------///
// ---------- GoldFrenzBoost --------------///
function stakeRFUnleaded(uint16 [] calldata data) external{
}
function calculateRFUnleadedReward(address _address) public view returns (uint){
}
function storeRFUnleadedTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFUnleaded(address _address) external view returns(uint16 [] memory)
{
}
function getRFUnleadedStakeTime(address _address) public view returns(uint64){
}
function claimRFUnleadedReward() external returns (uint){
}
function getRewardforUnstakingRFUnleaded(uint16 tokens) internal returns (uint){
}
function unstakeRFUnleaded(uint16 [] calldata data) external returns (uint){
}
function removeRFUnleadedToken(uint16 token) internal {
}
// ---------- RFUnleaded --------------///
// ---------- Spaceship --------------///
function stakeSpaceship(uint16 [] calldata data) external{
}
function calculateSpaceshipReward(address _address) public view returns (uint){
}
function storeSpaceshipTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfspaceship(address _address) external view returns(uint16 [] memory)
{
}
function getSpaceshipStakeTime(address _address) public view returns(uint64){
}
function claimSpaceshipReward() external returns(uint){
}
function getRewardforUnstakingSpaceship(uint16 tokens) internal returns (uint){
}
function unstakeSpaceship(uint16 [] calldata data) external returns(uint){
}
function removeSpaceshipToken(uint16 token) internal {
}
// ---------- Spaceship --------------///
}
| genesis0.ownerOf(data[i])==msg.sender,"Not the owner" | 201,762 | genesis0.ownerOf(data[i])==msg.sender |
"You have not staked any NFTs" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.0;
interface IGenesis0 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IGenesis2 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostPlatinum {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostGold {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface ISpaceship {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
contract NubbiesStaking is Ownable{
uint16 public totalNFTStaked ;
uint16 public totalgen0NFTStaked ;
uint16 public totalgen2NFTStaked ;
uint16 public totalrfPremiumNFTStaked ;
uint16 public totalrfUnleadedNFTStaked ;
uint16 public totalspaceshipNFTStaked ;
struct stakeOwner{
Gen0staker gen0;
Gen2staker gen2;
FBPlatinumStaker rfpremium;
FBGoldStaker rfunleaded;
Spaceshipstaker spaceship;
}
struct Gen0staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Gen2staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBPlatinumStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBGoldStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Spaceshipstaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
//stakedNft []staked;
mapping(address => stakeOwner) public stakeOwners ;
// uint startTime = block.timestamp;
uint public dailyGen0Reward = 4 ether ;
uint public dailyGen2Reward = 2 ether;
uint public dailyspaceshipReward = 1 ether;
uint public dailyPlatinumFrenzBoost = 4 ether;
uint public dailyGoldFrenzBoost = 2 ether;
address public gen0 = 0x091d8E039d532Fd02d7AcC593043acFf05839927;
address public gen2;
address public spaceshipaddress;
address public PlatinumFrenzBoost;
address public GoldFrenzBoost;
IGenesis0 genesis0= IGenesis0(gen0) ;
IGenesis2 genesis2 ;
IFrenzBoostPlatinum RFPremium ;
IFrenzBoostGold RFUnleaded ;
ISpaceship spaceship;
constructor() {
}
/// ---------- Setting info --------------///
function setGen0Address(address contractAddr) external onlyOwner {
}
function setGen2Address(address contractAddr) external onlyOwner {
}
function setSpaceShipAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostPlatinumAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostGoldAddress(address contractAddr) external onlyOwner {
}
function setdailyGen0Reward (uint _reward) external onlyOwner{
}
function setdailyGen2Reward (uint _reward) external onlyOwner{
}
function setdailyspaceshipReward (uint _reward) external onlyOwner{
}
function setdailyRFPremiumReward (uint _reward) external onlyOwner{
}
function setdailyRFUnleadedReward (uint _reward) external onlyOwner{
}
// ---------- Setting info --------------///
// ---------- GEN0 --------------///
function stakeGen0(uint16 [] calldata data) external{
}
function calculateGen0Reward(address _address) public view returns (uint){
}
function storeGen0Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen0(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen0Staked(address _address) public view returns (bool){
}
function getGen0StakeTime(address _address) public view returns(uint64){
}
function claimGen0Reward() external {
require(<FILL_ME>)
stakeOwners[ msg.sender].gen0.rewardStartTime = uint64(block.timestamp);
stakeOwners[ msg.sender].gen0.rewards=0;
}
function calculateRewardforUnstakingGen0(uint16 [] calldata data , address _address) public view returns (uint) {
}
function getRewardforUnstakingGen0(uint16 tokens) internal {
}
function unstakeGen0(uint16 [] calldata data) external {
}
function removeGen0Token(uint16 token) internal {
}
// ---------- GEN0 --------------///
// ---------- GEN2 --------------///
function stakeGen2(uint16 [] calldata data) external{
}
function calculateGen2Reward(address _address) public view returns (uint){
}
function storeGen2Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen2(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen2Staked(address _address) public view returns (bool){
}
function getGen2StakeTime(address _address) public view returns(uint64){
}
function claimGen2Reward() external returns (uint){
}
function getRewardforUnstakingGen2(uint16 tokens) internal returns (uint){
}
function unstakeGen2(uint16 [] calldata data) external returns (uint){
}
function removeGen2Token(uint16 token) internal {
}
// ---------- GEN2 --------------///
// ---------- PlatinumFrenzBoost --------------///
function stakeRFPremium(uint16 [] calldata data) external{
}
function calculateRFPremiumReward(address _address) public view returns (uint){
}
function storeRFPremiumTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFPremium(address _address) external view returns(uint16 [] memory)
{
}
function getRFPremiumStakeTime(address _address) public view returns(uint64){
}
function claimRFPremiumReward() external returns (uint){
}
function getRewardforUnstakingRFPremium(uint16 tokens) internal returns (uint) {
}
function unstakeRFPremium(uint16 [] calldata data) external returns (uint){
}
function removeRFPremiumToken(uint16 token) internal {
}
// ---------- PlatinumFrenzBoost --------------///
// ---------- GoldFrenzBoost --------------///
function stakeRFUnleaded(uint16 [] calldata data) external{
}
function calculateRFUnleadedReward(address _address) public view returns (uint){
}
function storeRFUnleadedTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFUnleaded(address _address) external view returns(uint16 [] memory)
{
}
function getRFUnleadedStakeTime(address _address) public view returns(uint64){
}
function claimRFUnleadedReward() external returns (uint){
}
function getRewardforUnstakingRFUnleaded(uint16 tokens) internal returns (uint){
}
function unstakeRFUnleaded(uint16 [] calldata data) external returns (uint){
}
function removeRFUnleadedToken(uint16 token) internal {
}
// ---------- RFUnleaded --------------///
// ---------- Spaceship --------------///
function stakeSpaceship(uint16 [] calldata data) external{
}
function calculateSpaceshipReward(address _address) public view returns (uint){
}
function storeSpaceshipTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfspaceship(address _address) external view returns(uint16 [] memory)
{
}
function getSpaceshipStakeTime(address _address) public view returns(uint64){
}
function claimSpaceshipReward() external returns(uint){
}
function getRewardforUnstakingSpaceship(uint16 tokens) internal returns (uint){
}
function unstakeSpaceship(uint16 [] calldata data) external returns(uint){
}
function removeSpaceshipToken(uint16 token) internal {
}
// ---------- Spaceship --------------///
}
| stakeOwners[msg.sender].gen0.tokens.length>0,"You have not staked any NFTs" | 201,762 | stakeOwners[msg.sender].gen0.tokens.length>0 |
"Not the owner" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.0;
interface IGenesis0 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IGenesis2 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostPlatinum {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostGold {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface ISpaceship {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
contract NubbiesStaking is Ownable{
uint16 public totalNFTStaked ;
uint16 public totalgen0NFTStaked ;
uint16 public totalgen2NFTStaked ;
uint16 public totalrfPremiumNFTStaked ;
uint16 public totalrfUnleadedNFTStaked ;
uint16 public totalspaceshipNFTStaked ;
struct stakeOwner{
Gen0staker gen0;
Gen2staker gen2;
FBPlatinumStaker rfpremium;
FBGoldStaker rfunleaded;
Spaceshipstaker spaceship;
}
struct Gen0staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Gen2staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBPlatinumStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBGoldStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Spaceshipstaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
//stakedNft []staked;
mapping(address => stakeOwner) public stakeOwners ;
// uint startTime = block.timestamp;
uint public dailyGen0Reward = 4 ether ;
uint public dailyGen2Reward = 2 ether;
uint public dailyspaceshipReward = 1 ether;
uint public dailyPlatinumFrenzBoost = 4 ether;
uint public dailyGoldFrenzBoost = 2 ether;
address public gen0 = 0x091d8E039d532Fd02d7AcC593043acFf05839927;
address public gen2;
address public spaceshipaddress;
address public PlatinumFrenzBoost;
address public GoldFrenzBoost;
IGenesis0 genesis0= IGenesis0(gen0) ;
IGenesis2 genesis2 ;
IFrenzBoostPlatinum RFPremium ;
IFrenzBoostGold RFUnleaded ;
ISpaceship spaceship;
constructor() {
}
/// ---------- Setting info --------------///
function setGen0Address(address contractAddr) external onlyOwner {
}
function setGen2Address(address contractAddr) external onlyOwner {
}
function setSpaceShipAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostPlatinumAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostGoldAddress(address contractAddr) external onlyOwner {
}
function setdailyGen0Reward (uint _reward) external onlyOwner{
}
function setdailyGen2Reward (uint _reward) external onlyOwner{
}
function setdailyspaceshipReward (uint _reward) external onlyOwner{
}
function setdailyRFPremiumReward (uint _reward) external onlyOwner{
}
function setdailyRFUnleadedReward (uint _reward) external onlyOwner{
}
// ---------- Setting info --------------///
// ---------- GEN0 --------------///
function stakeGen0(uint16 [] calldata data) external{
}
function calculateGen0Reward(address _address) public view returns (uint){
}
function storeGen0Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen0(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen0Staked(address _address) public view returns (bool){
}
function getGen0StakeTime(address _address) public view returns(uint64){
}
function claimGen0Reward() external {
}
function calculateRewardforUnstakingGen0(uint16 [] calldata data , address _address) public view returns (uint) {
}
function getRewardforUnstakingGen0(uint16 tokens) internal {
}
function unstakeGen0(uint16 [] calldata data) external {
}
function removeGen0Token(uint16 token) internal {
}
// ---------- GEN0 --------------///
// ---------- GEN2 --------------///
function stakeGen2(uint16 [] calldata data) external{
uint16 _number= uint16(data.length );
require(_number > 0 , "Invalid Number");
uint16 tokens=uint16(stakeOwners[msg.sender].gen2.tokens.length);
if(tokens > 0){
stakeOwners[ msg.sender].gen2.rewards = calculateGen2Reward(msg.sender);
}
stakeOwners[ msg.sender].gen2.rewardStartTime = uint64(block.timestamp);
totalNFTStaked += _number;
totalgen2NFTStaked += _number;
storeGen2Tokens(_number , data);
for(uint16 i ; i< _number ; i++)
{
require(<FILL_ME>)
genesis2.transferFrom( msg.sender, address(this),data[i]);
}
delete tokens;
}
function calculateGen2Reward(address _address) public view returns (uint){
}
function storeGen2Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen2(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen2Staked(address _address) public view returns (bool){
}
function getGen2StakeTime(address _address) public view returns(uint64){
}
function claimGen2Reward() external returns (uint){
}
function getRewardforUnstakingGen2(uint16 tokens) internal returns (uint){
}
function unstakeGen2(uint16 [] calldata data) external returns (uint){
}
function removeGen2Token(uint16 token) internal {
}
// ---------- GEN2 --------------///
// ---------- PlatinumFrenzBoost --------------///
function stakeRFPremium(uint16 [] calldata data) external{
}
function calculateRFPremiumReward(address _address) public view returns (uint){
}
function storeRFPremiumTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFPremium(address _address) external view returns(uint16 [] memory)
{
}
function getRFPremiumStakeTime(address _address) public view returns(uint64){
}
function claimRFPremiumReward() external returns (uint){
}
function getRewardforUnstakingRFPremium(uint16 tokens) internal returns (uint) {
}
function unstakeRFPremium(uint16 [] calldata data) external returns (uint){
}
function removeRFPremiumToken(uint16 token) internal {
}
// ---------- PlatinumFrenzBoost --------------///
// ---------- GoldFrenzBoost --------------///
function stakeRFUnleaded(uint16 [] calldata data) external{
}
function calculateRFUnleadedReward(address _address) public view returns (uint){
}
function storeRFUnleadedTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFUnleaded(address _address) external view returns(uint16 [] memory)
{
}
function getRFUnleadedStakeTime(address _address) public view returns(uint64){
}
function claimRFUnleadedReward() external returns (uint){
}
function getRewardforUnstakingRFUnleaded(uint16 tokens) internal returns (uint){
}
function unstakeRFUnleaded(uint16 [] calldata data) external returns (uint){
}
function removeRFUnleadedToken(uint16 token) internal {
}
// ---------- RFUnleaded --------------///
// ---------- Spaceship --------------///
function stakeSpaceship(uint16 [] calldata data) external{
}
function calculateSpaceshipReward(address _address) public view returns (uint){
}
function storeSpaceshipTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfspaceship(address _address) external view returns(uint16 [] memory)
{
}
function getSpaceshipStakeTime(address _address) public view returns(uint64){
}
function claimSpaceshipReward() external returns(uint){
}
function getRewardforUnstakingSpaceship(uint16 tokens) internal returns (uint){
}
function unstakeSpaceship(uint16 [] calldata data) external returns(uint){
}
function removeSpaceshipToken(uint16 token) internal {
}
// ---------- Spaceship --------------///
}
| genesis2.ownerOf(data[i])==msg.sender,"Not the owner" | 201,762 | genesis2.ownerOf(data[i])==msg.sender |
"You have not staked any NFTs" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.0;
interface IGenesis0 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IGenesis2 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostPlatinum {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostGold {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface ISpaceship {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
contract NubbiesStaking is Ownable{
uint16 public totalNFTStaked ;
uint16 public totalgen0NFTStaked ;
uint16 public totalgen2NFTStaked ;
uint16 public totalrfPremiumNFTStaked ;
uint16 public totalrfUnleadedNFTStaked ;
uint16 public totalspaceshipNFTStaked ;
struct stakeOwner{
Gen0staker gen0;
Gen2staker gen2;
FBPlatinumStaker rfpremium;
FBGoldStaker rfunleaded;
Spaceshipstaker spaceship;
}
struct Gen0staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Gen2staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBPlatinumStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBGoldStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Spaceshipstaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
//stakedNft []staked;
mapping(address => stakeOwner) public stakeOwners ;
// uint startTime = block.timestamp;
uint public dailyGen0Reward = 4 ether ;
uint public dailyGen2Reward = 2 ether;
uint public dailyspaceshipReward = 1 ether;
uint public dailyPlatinumFrenzBoost = 4 ether;
uint public dailyGoldFrenzBoost = 2 ether;
address public gen0 = 0x091d8E039d532Fd02d7AcC593043acFf05839927;
address public gen2;
address public spaceshipaddress;
address public PlatinumFrenzBoost;
address public GoldFrenzBoost;
IGenesis0 genesis0= IGenesis0(gen0) ;
IGenesis2 genesis2 ;
IFrenzBoostPlatinum RFPremium ;
IFrenzBoostGold RFUnleaded ;
ISpaceship spaceship;
constructor() {
}
/// ---------- Setting info --------------///
function setGen0Address(address contractAddr) external onlyOwner {
}
function setGen2Address(address contractAddr) external onlyOwner {
}
function setSpaceShipAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostPlatinumAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostGoldAddress(address contractAddr) external onlyOwner {
}
function setdailyGen0Reward (uint _reward) external onlyOwner{
}
function setdailyGen2Reward (uint _reward) external onlyOwner{
}
function setdailyspaceshipReward (uint _reward) external onlyOwner{
}
function setdailyRFPremiumReward (uint _reward) external onlyOwner{
}
function setdailyRFUnleadedReward (uint _reward) external onlyOwner{
}
// ---------- Setting info --------------///
// ---------- GEN0 --------------///
function stakeGen0(uint16 [] calldata data) external{
}
function calculateGen0Reward(address _address) public view returns (uint){
}
function storeGen0Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen0(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen0Staked(address _address) public view returns (bool){
}
function getGen0StakeTime(address _address) public view returns(uint64){
}
function claimGen0Reward() external {
}
function calculateRewardforUnstakingGen0(uint16 [] calldata data , address _address) public view returns (uint) {
}
function getRewardforUnstakingGen0(uint16 tokens) internal {
}
function unstakeGen0(uint16 [] calldata data) external {
}
function removeGen0Token(uint16 token) internal {
}
// ---------- GEN0 --------------///
// ---------- GEN2 --------------///
function stakeGen2(uint16 [] calldata data) external{
}
function calculateGen2Reward(address _address) public view returns (uint){
}
function storeGen2Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen2(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen2Staked(address _address) public view returns (bool){
}
function getGen2StakeTime(address _address) public view returns(uint64){
}
function claimGen2Reward() external returns (uint){
require(<FILL_ME>)
uint reward = calculateGen2Reward(msg.sender);
stakeOwners[ msg.sender].gen2.rewardStartTime = uint64(block.timestamp);
stakeOwners[ msg.sender].gen2.rewards=0;
return reward;
}
function getRewardforUnstakingGen2(uint16 tokens) internal returns (uint){
}
function unstakeGen2(uint16 [] calldata data) external returns (uint){
}
function removeGen2Token(uint16 token) internal {
}
// ---------- GEN2 --------------///
// ---------- PlatinumFrenzBoost --------------///
function stakeRFPremium(uint16 [] calldata data) external{
}
function calculateRFPremiumReward(address _address) public view returns (uint){
}
function storeRFPremiumTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFPremium(address _address) external view returns(uint16 [] memory)
{
}
function getRFPremiumStakeTime(address _address) public view returns(uint64){
}
function claimRFPremiumReward() external returns (uint){
}
function getRewardforUnstakingRFPremium(uint16 tokens) internal returns (uint) {
}
function unstakeRFPremium(uint16 [] calldata data) external returns (uint){
}
function removeRFPremiumToken(uint16 token) internal {
}
// ---------- PlatinumFrenzBoost --------------///
// ---------- GoldFrenzBoost --------------///
function stakeRFUnleaded(uint16 [] calldata data) external{
}
function calculateRFUnleadedReward(address _address) public view returns (uint){
}
function storeRFUnleadedTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFUnleaded(address _address) external view returns(uint16 [] memory)
{
}
function getRFUnleadedStakeTime(address _address) public view returns(uint64){
}
function claimRFUnleadedReward() external returns (uint){
}
function getRewardforUnstakingRFUnleaded(uint16 tokens) internal returns (uint){
}
function unstakeRFUnleaded(uint16 [] calldata data) external returns (uint){
}
function removeRFUnleadedToken(uint16 token) internal {
}
// ---------- RFUnleaded --------------///
// ---------- Spaceship --------------///
function stakeSpaceship(uint16 [] calldata data) external{
}
function calculateSpaceshipReward(address _address) public view returns (uint){
}
function storeSpaceshipTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfspaceship(address _address) external view returns(uint16 [] memory)
{
}
function getSpaceshipStakeTime(address _address) public view returns(uint64){
}
function claimSpaceshipReward() external returns(uint){
}
function getRewardforUnstakingSpaceship(uint16 tokens) internal returns (uint){
}
function unstakeSpaceship(uint16 [] calldata data) external returns(uint){
}
function removeSpaceshipToken(uint16 token) internal {
}
// ---------- Spaceship --------------///
}
| stakeOwners[msg.sender].gen2.tokens.length>0,"You have not staked any NFTs" | 201,762 | stakeOwners[msg.sender].gen2.tokens.length>0 |
" No Gen0 NFTs staked" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.0;
interface IGenesis0 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IGenesis2 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostPlatinum {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostGold {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface ISpaceship {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
contract NubbiesStaking is Ownable{
uint16 public totalNFTStaked ;
uint16 public totalgen0NFTStaked ;
uint16 public totalgen2NFTStaked ;
uint16 public totalrfPremiumNFTStaked ;
uint16 public totalrfUnleadedNFTStaked ;
uint16 public totalspaceshipNFTStaked ;
struct stakeOwner{
Gen0staker gen0;
Gen2staker gen2;
FBPlatinumStaker rfpremium;
FBGoldStaker rfunleaded;
Spaceshipstaker spaceship;
}
struct Gen0staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Gen2staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBPlatinumStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBGoldStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Spaceshipstaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
//stakedNft []staked;
mapping(address => stakeOwner) public stakeOwners ;
// uint startTime = block.timestamp;
uint public dailyGen0Reward = 4 ether ;
uint public dailyGen2Reward = 2 ether;
uint public dailyspaceshipReward = 1 ether;
uint public dailyPlatinumFrenzBoost = 4 ether;
uint public dailyGoldFrenzBoost = 2 ether;
address public gen0 = 0x091d8E039d532Fd02d7AcC593043acFf05839927;
address public gen2;
address public spaceshipaddress;
address public PlatinumFrenzBoost;
address public GoldFrenzBoost;
IGenesis0 genesis0= IGenesis0(gen0) ;
IGenesis2 genesis2 ;
IFrenzBoostPlatinum RFPremium ;
IFrenzBoostGold RFUnleaded ;
ISpaceship spaceship;
constructor() {
}
/// ---------- Setting info --------------///
function setGen0Address(address contractAddr) external onlyOwner {
}
function setGen2Address(address contractAddr) external onlyOwner {
}
function setSpaceShipAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostPlatinumAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostGoldAddress(address contractAddr) external onlyOwner {
}
function setdailyGen0Reward (uint _reward) external onlyOwner{
}
function setdailyGen2Reward (uint _reward) external onlyOwner{
}
function setdailyspaceshipReward (uint _reward) external onlyOwner{
}
function setdailyRFPremiumReward (uint _reward) external onlyOwner{
}
function setdailyRFUnleadedReward (uint _reward) external onlyOwner{
}
// ---------- Setting info --------------///
// ---------- GEN0 --------------///
function stakeGen0(uint16 [] calldata data) external{
}
function calculateGen0Reward(address _address) public view returns (uint){
}
function storeGen0Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen0(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen0Staked(address _address) public view returns (bool){
}
function getGen0StakeTime(address _address) public view returns(uint64){
}
function claimGen0Reward() external {
}
function calculateRewardforUnstakingGen0(uint16 [] calldata data , address _address) public view returns (uint) {
}
function getRewardforUnstakingGen0(uint16 tokens) internal {
}
function unstakeGen0(uint16 [] calldata data) external {
}
function removeGen0Token(uint16 token) internal {
}
// ---------- GEN0 --------------///
// ---------- GEN2 --------------///
function stakeGen2(uint16 [] calldata data) external{
}
function calculateGen2Reward(address _address) public view returns (uint){
}
function storeGen2Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen2(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen2Staked(address _address) public view returns (bool){
}
function getGen2StakeTime(address _address) public view returns(uint64){
}
function claimGen2Reward() external returns (uint){
}
function getRewardforUnstakingGen2(uint16 tokens) internal returns (uint){
}
function unstakeGen2(uint16 [] calldata data) external returns (uint){
}
function removeGen2Token(uint16 token) internal {
}
// ---------- GEN2 --------------///
// ---------- PlatinumFrenzBoost --------------///
function stakeRFPremium(uint16 [] calldata data) external{
uint16 _number= uint16(data.length );
require(_number > 0 , "Invalid Number");
require(<FILL_ME>)
uint16 tokens=uint16(stakeOwners[msg.sender].rfpremium.tokens.length);
if(tokens > 0){
stakeOwners[ msg.sender].rfpremium.rewards = calculateRFPremiumReward(msg.sender);
}
stakeOwners[ msg.sender].rfpremium.rewardStartTime = uint64(block.timestamp);
totalNFTStaked += _number;
totalrfPremiumNFTStaked += _number;
storeRFPremiumTokens(_number , data);
for(uint16 i ; i< _number ; i++)
{
require(RFPremium.ownerOf(data[i]) == msg.sender, "Not the owner");
RFPremium.transferFrom( msg.sender, address(this),data[i]);
}
delete tokens;
}
function calculateRFPremiumReward(address _address) public view returns (uint){
}
function storeRFPremiumTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFPremium(address _address) external view returns(uint16 [] memory)
{
}
function getRFPremiumStakeTime(address _address) public view returns(uint64){
}
function claimRFPremiumReward() external returns (uint){
}
function getRewardforUnstakingRFPremium(uint16 tokens) internal returns (uint) {
}
function unstakeRFPremium(uint16 [] calldata data) external returns (uint){
}
function removeRFPremiumToken(uint16 token) internal {
}
// ---------- PlatinumFrenzBoost --------------///
// ---------- GoldFrenzBoost --------------///
function stakeRFUnleaded(uint16 [] calldata data) external{
}
function calculateRFUnleadedReward(address _address) public view returns (uint){
}
function storeRFUnleadedTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFUnleaded(address _address) external view returns(uint16 [] memory)
{
}
function getRFUnleadedStakeTime(address _address) public view returns(uint64){
}
function claimRFUnleadedReward() external returns (uint){
}
function getRewardforUnstakingRFUnleaded(uint16 tokens) internal returns (uint){
}
function unstakeRFUnleaded(uint16 [] calldata data) external returns (uint){
}
function removeRFUnleadedToken(uint16 token) internal {
}
// ---------- RFUnleaded --------------///
// ---------- Spaceship --------------///
function stakeSpaceship(uint16 [] calldata data) external{
}
function calculateSpaceshipReward(address _address) public view returns (uint){
}
function storeSpaceshipTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfspaceship(address _address) external view returns(uint16 [] memory)
{
}
function getSpaceshipStakeTime(address _address) public view returns(uint64){
}
function claimSpaceshipReward() external returns(uint){
}
function getRewardforUnstakingSpaceship(uint16 tokens) internal returns (uint){
}
function unstakeSpaceship(uint16 [] calldata data) external returns(uint){
}
function removeSpaceshipToken(uint16 token) internal {
}
// ---------- Spaceship --------------///
}
| checkIfGen0Staked(msg.sender)==true," No Gen0 NFTs staked" | 201,762 | checkIfGen0Staked(msg.sender)==true |
"Not the owner" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.0;
interface IGenesis0 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IGenesis2 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostPlatinum {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostGold {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface ISpaceship {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
contract NubbiesStaking is Ownable{
uint16 public totalNFTStaked ;
uint16 public totalgen0NFTStaked ;
uint16 public totalgen2NFTStaked ;
uint16 public totalrfPremiumNFTStaked ;
uint16 public totalrfUnleadedNFTStaked ;
uint16 public totalspaceshipNFTStaked ;
struct stakeOwner{
Gen0staker gen0;
Gen2staker gen2;
FBPlatinumStaker rfpremium;
FBGoldStaker rfunleaded;
Spaceshipstaker spaceship;
}
struct Gen0staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Gen2staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBPlatinumStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBGoldStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Spaceshipstaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
//stakedNft []staked;
mapping(address => stakeOwner) public stakeOwners ;
// uint startTime = block.timestamp;
uint public dailyGen0Reward = 4 ether ;
uint public dailyGen2Reward = 2 ether;
uint public dailyspaceshipReward = 1 ether;
uint public dailyPlatinumFrenzBoost = 4 ether;
uint public dailyGoldFrenzBoost = 2 ether;
address public gen0 = 0x091d8E039d532Fd02d7AcC593043acFf05839927;
address public gen2;
address public spaceshipaddress;
address public PlatinumFrenzBoost;
address public GoldFrenzBoost;
IGenesis0 genesis0= IGenesis0(gen0) ;
IGenesis2 genesis2 ;
IFrenzBoostPlatinum RFPremium ;
IFrenzBoostGold RFUnleaded ;
ISpaceship spaceship;
constructor() {
}
/// ---------- Setting info --------------///
function setGen0Address(address contractAddr) external onlyOwner {
}
function setGen2Address(address contractAddr) external onlyOwner {
}
function setSpaceShipAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostPlatinumAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostGoldAddress(address contractAddr) external onlyOwner {
}
function setdailyGen0Reward (uint _reward) external onlyOwner{
}
function setdailyGen2Reward (uint _reward) external onlyOwner{
}
function setdailyspaceshipReward (uint _reward) external onlyOwner{
}
function setdailyRFPremiumReward (uint _reward) external onlyOwner{
}
function setdailyRFUnleadedReward (uint _reward) external onlyOwner{
}
// ---------- Setting info --------------///
// ---------- GEN0 --------------///
function stakeGen0(uint16 [] calldata data) external{
}
function calculateGen0Reward(address _address) public view returns (uint){
}
function storeGen0Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen0(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen0Staked(address _address) public view returns (bool){
}
function getGen0StakeTime(address _address) public view returns(uint64){
}
function claimGen0Reward() external {
}
function calculateRewardforUnstakingGen0(uint16 [] calldata data , address _address) public view returns (uint) {
}
function getRewardforUnstakingGen0(uint16 tokens) internal {
}
function unstakeGen0(uint16 [] calldata data) external {
}
function removeGen0Token(uint16 token) internal {
}
// ---------- GEN0 --------------///
// ---------- GEN2 --------------///
function stakeGen2(uint16 [] calldata data) external{
}
function calculateGen2Reward(address _address) public view returns (uint){
}
function storeGen2Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen2(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen2Staked(address _address) public view returns (bool){
}
function getGen2StakeTime(address _address) public view returns(uint64){
}
function claimGen2Reward() external returns (uint){
}
function getRewardforUnstakingGen2(uint16 tokens) internal returns (uint){
}
function unstakeGen2(uint16 [] calldata data) external returns (uint){
}
function removeGen2Token(uint16 token) internal {
}
// ---------- GEN2 --------------///
// ---------- PlatinumFrenzBoost --------------///
function stakeRFPremium(uint16 [] calldata data) external{
uint16 _number= uint16(data.length );
require(_number > 0 , "Invalid Number");
require(checkIfGen0Staked(msg.sender) == true , " No Gen0 NFTs staked");
uint16 tokens=uint16(stakeOwners[msg.sender].rfpremium.tokens.length);
if(tokens > 0){
stakeOwners[ msg.sender].rfpremium.rewards = calculateRFPremiumReward(msg.sender);
}
stakeOwners[ msg.sender].rfpremium.rewardStartTime = uint64(block.timestamp);
totalNFTStaked += _number;
totalrfPremiumNFTStaked += _number;
storeRFPremiumTokens(_number , data);
for(uint16 i ; i< _number ; i++)
{
require(<FILL_ME>)
RFPremium.transferFrom( msg.sender, address(this),data[i]);
}
delete tokens;
}
function calculateRFPremiumReward(address _address) public view returns (uint){
}
function storeRFPremiumTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFPremium(address _address) external view returns(uint16 [] memory)
{
}
function getRFPremiumStakeTime(address _address) public view returns(uint64){
}
function claimRFPremiumReward() external returns (uint){
}
function getRewardforUnstakingRFPremium(uint16 tokens) internal returns (uint) {
}
function unstakeRFPremium(uint16 [] calldata data) external returns (uint){
}
function removeRFPremiumToken(uint16 token) internal {
}
// ---------- PlatinumFrenzBoost --------------///
// ---------- GoldFrenzBoost --------------///
function stakeRFUnleaded(uint16 [] calldata data) external{
}
function calculateRFUnleadedReward(address _address) public view returns (uint){
}
function storeRFUnleadedTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFUnleaded(address _address) external view returns(uint16 [] memory)
{
}
function getRFUnleadedStakeTime(address _address) public view returns(uint64){
}
function claimRFUnleadedReward() external returns (uint){
}
function getRewardforUnstakingRFUnleaded(uint16 tokens) internal returns (uint){
}
function unstakeRFUnleaded(uint16 [] calldata data) external returns (uint){
}
function removeRFUnleadedToken(uint16 token) internal {
}
// ---------- RFUnleaded --------------///
// ---------- Spaceship --------------///
function stakeSpaceship(uint16 [] calldata data) external{
}
function calculateSpaceshipReward(address _address) public view returns (uint){
}
function storeSpaceshipTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfspaceship(address _address) external view returns(uint16 [] memory)
{
}
function getSpaceshipStakeTime(address _address) public view returns(uint64){
}
function claimSpaceshipReward() external returns(uint){
}
function getRewardforUnstakingSpaceship(uint16 tokens) internal returns (uint){
}
function unstakeSpaceship(uint16 [] calldata data) external returns(uint){
}
function removeSpaceshipToken(uint16 token) internal {
}
// ---------- Spaceship --------------///
}
| RFPremium.ownerOf(data[i])==msg.sender,"Not the owner" | 201,762 | RFPremium.ownerOf(data[i])==msg.sender |
"You have not staked any NFTs" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.0;
interface IGenesis0 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IGenesis2 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostPlatinum {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostGold {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface ISpaceship {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
contract NubbiesStaking is Ownable{
uint16 public totalNFTStaked ;
uint16 public totalgen0NFTStaked ;
uint16 public totalgen2NFTStaked ;
uint16 public totalrfPremiumNFTStaked ;
uint16 public totalrfUnleadedNFTStaked ;
uint16 public totalspaceshipNFTStaked ;
struct stakeOwner{
Gen0staker gen0;
Gen2staker gen2;
FBPlatinumStaker rfpremium;
FBGoldStaker rfunleaded;
Spaceshipstaker spaceship;
}
struct Gen0staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Gen2staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBPlatinumStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBGoldStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Spaceshipstaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
//stakedNft []staked;
mapping(address => stakeOwner) public stakeOwners ;
// uint startTime = block.timestamp;
uint public dailyGen0Reward = 4 ether ;
uint public dailyGen2Reward = 2 ether;
uint public dailyspaceshipReward = 1 ether;
uint public dailyPlatinumFrenzBoost = 4 ether;
uint public dailyGoldFrenzBoost = 2 ether;
address public gen0 = 0x091d8E039d532Fd02d7AcC593043acFf05839927;
address public gen2;
address public spaceshipaddress;
address public PlatinumFrenzBoost;
address public GoldFrenzBoost;
IGenesis0 genesis0= IGenesis0(gen0) ;
IGenesis2 genesis2 ;
IFrenzBoostPlatinum RFPremium ;
IFrenzBoostGold RFUnleaded ;
ISpaceship spaceship;
constructor() {
}
/// ---------- Setting info --------------///
function setGen0Address(address contractAddr) external onlyOwner {
}
function setGen2Address(address contractAddr) external onlyOwner {
}
function setSpaceShipAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostPlatinumAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostGoldAddress(address contractAddr) external onlyOwner {
}
function setdailyGen0Reward (uint _reward) external onlyOwner{
}
function setdailyGen2Reward (uint _reward) external onlyOwner{
}
function setdailyspaceshipReward (uint _reward) external onlyOwner{
}
function setdailyRFPremiumReward (uint _reward) external onlyOwner{
}
function setdailyRFUnleadedReward (uint _reward) external onlyOwner{
}
// ---------- Setting info --------------///
// ---------- GEN0 --------------///
function stakeGen0(uint16 [] calldata data) external{
}
function calculateGen0Reward(address _address) public view returns (uint){
}
function storeGen0Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen0(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen0Staked(address _address) public view returns (bool){
}
function getGen0StakeTime(address _address) public view returns(uint64){
}
function claimGen0Reward() external {
}
function calculateRewardforUnstakingGen0(uint16 [] calldata data , address _address) public view returns (uint) {
}
function getRewardforUnstakingGen0(uint16 tokens) internal {
}
function unstakeGen0(uint16 [] calldata data) external {
}
function removeGen0Token(uint16 token) internal {
}
// ---------- GEN0 --------------///
// ---------- GEN2 --------------///
function stakeGen2(uint16 [] calldata data) external{
}
function calculateGen2Reward(address _address) public view returns (uint){
}
function storeGen2Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen2(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen2Staked(address _address) public view returns (bool){
}
function getGen2StakeTime(address _address) public view returns(uint64){
}
function claimGen2Reward() external returns (uint){
}
function getRewardforUnstakingGen2(uint16 tokens) internal returns (uint){
}
function unstakeGen2(uint16 [] calldata data) external returns (uint){
}
function removeGen2Token(uint16 token) internal {
}
// ---------- GEN2 --------------///
// ---------- PlatinumFrenzBoost --------------///
function stakeRFPremium(uint16 [] calldata data) external{
}
function calculateRFPremiumReward(address _address) public view returns (uint){
}
function storeRFPremiumTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFPremium(address _address) external view returns(uint16 [] memory)
{
}
function getRFPremiumStakeTime(address _address) public view returns(uint64){
}
function claimRFPremiumReward() external returns (uint){
require(<FILL_ME>)
uint reward = calculateRFPremiumReward(msg.sender);
stakeOwners[ msg.sender].rfpremium.rewardStartTime = uint64(block.timestamp);
stakeOwners[ msg.sender].rfpremium.rewards=0;
return reward;
}
function getRewardforUnstakingRFPremium(uint16 tokens) internal returns (uint) {
}
function unstakeRFPremium(uint16 [] calldata data) external returns (uint){
}
function removeRFPremiumToken(uint16 token) internal {
}
// ---------- PlatinumFrenzBoost --------------///
// ---------- GoldFrenzBoost --------------///
function stakeRFUnleaded(uint16 [] calldata data) external{
}
function calculateRFUnleadedReward(address _address) public view returns (uint){
}
function storeRFUnleadedTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFUnleaded(address _address) external view returns(uint16 [] memory)
{
}
function getRFUnleadedStakeTime(address _address) public view returns(uint64){
}
function claimRFUnleadedReward() external returns (uint){
}
function getRewardforUnstakingRFUnleaded(uint16 tokens) internal returns (uint){
}
function unstakeRFUnleaded(uint16 [] calldata data) external returns (uint){
}
function removeRFUnleadedToken(uint16 token) internal {
}
// ---------- RFUnleaded --------------///
// ---------- Spaceship --------------///
function stakeSpaceship(uint16 [] calldata data) external{
}
function calculateSpaceshipReward(address _address) public view returns (uint){
}
function storeSpaceshipTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfspaceship(address _address) external view returns(uint16 [] memory)
{
}
function getSpaceshipStakeTime(address _address) public view returns(uint64){
}
function claimSpaceshipReward() external returns(uint){
}
function getRewardforUnstakingSpaceship(uint16 tokens) internal returns (uint){
}
function unstakeSpaceship(uint16 [] calldata data) external returns(uint){
}
function removeSpaceshipToken(uint16 token) internal {
}
// ---------- Spaceship --------------///
}
| stakeOwners[msg.sender].rfpremium.tokens.length>0,"You have not staked any NFTs" | 201,762 | stakeOwners[msg.sender].rfpremium.tokens.length>0 |
" No Gen0 NFTs staked" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.0;
interface IGenesis0 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IGenesis2 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostPlatinum {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostGold {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface ISpaceship {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
contract NubbiesStaking is Ownable{
uint16 public totalNFTStaked ;
uint16 public totalgen0NFTStaked ;
uint16 public totalgen2NFTStaked ;
uint16 public totalrfPremiumNFTStaked ;
uint16 public totalrfUnleadedNFTStaked ;
uint16 public totalspaceshipNFTStaked ;
struct stakeOwner{
Gen0staker gen0;
Gen2staker gen2;
FBPlatinumStaker rfpremium;
FBGoldStaker rfunleaded;
Spaceshipstaker spaceship;
}
struct Gen0staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Gen2staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBPlatinumStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBGoldStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Spaceshipstaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
//stakedNft []staked;
mapping(address => stakeOwner) public stakeOwners ;
// uint startTime = block.timestamp;
uint public dailyGen0Reward = 4 ether ;
uint public dailyGen2Reward = 2 ether;
uint public dailyspaceshipReward = 1 ether;
uint public dailyPlatinumFrenzBoost = 4 ether;
uint public dailyGoldFrenzBoost = 2 ether;
address public gen0 = 0x091d8E039d532Fd02d7AcC593043acFf05839927;
address public gen2;
address public spaceshipaddress;
address public PlatinumFrenzBoost;
address public GoldFrenzBoost;
IGenesis0 genesis0= IGenesis0(gen0) ;
IGenesis2 genesis2 ;
IFrenzBoostPlatinum RFPremium ;
IFrenzBoostGold RFUnleaded ;
ISpaceship spaceship;
constructor() {
}
/// ---------- Setting info --------------///
function setGen0Address(address contractAddr) external onlyOwner {
}
function setGen2Address(address contractAddr) external onlyOwner {
}
function setSpaceShipAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostPlatinumAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostGoldAddress(address contractAddr) external onlyOwner {
}
function setdailyGen0Reward (uint _reward) external onlyOwner{
}
function setdailyGen2Reward (uint _reward) external onlyOwner{
}
function setdailyspaceshipReward (uint _reward) external onlyOwner{
}
function setdailyRFPremiumReward (uint _reward) external onlyOwner{
}
function setdailyRFUnleadedReward (uint _reward) external onlyOwner{
}
// ---------- Setting info --------------///
// ---------- GEN0 --------------///
function stakeGen0(uint16 [] calldata data) external{
}
function calculateGen0Reward(address _address) public view returns (uint){
}
function storeGen0Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen0(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen0Staked(address _address) public view returns (bool){
}
function getGen0StakeTime(address _address) public view returns(uint64){
}
function claimGen0Reward() external {
}
function calculateRewardforUnstakingGen0(uint16 [] calldata data , address _address) public view returns (uint) {
}
function getRewardforUnstakingGen0(uint16 tokens) internal {
}
function unstakeGen0(uint16 [] calldata data) external {
}
function removeGen0Token(uint16 token) internal {
}
// ---------- GEN0 --------------///
// ---------- GEN2 --------------///
function stakeGen2(uint16 [] calldata data) external{
}
function calculateGen2Reward(address _address) public view returns (uint){
}
function storeGen2Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen2(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen2Staked(address _address) public view returns (bool){
}
function getGen2StakeTime(address _address) public view returns(uint64){
}
function claimGen2Reward() external returns (uint){
}
function getRewardforUnstakingGen2(uint16 tokens) internal returns (uint){
}
function unstakeGen2(uint16 [] calldata data) external returns (uint){
}
function removeGen2Token(uint16 token) internal {
}
// ---------- GEN2 --------------///
// ---------- PlatinumFrenzBoost --------------///
function stakeRFPremium(uint16 [] calldata data) external{
}
function calculateRFPremiumReward(address _address) public view returns (uint){
}
function storeRFPremiumTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFPremium(address _address) external view returns(uint16 [] memory)
{
}
function getRFPremiumStakeTime(address _address) public view returns(uint64){
}
function claimRFPremiumReward() external returns (uint){
}
function getRewardforUnstakingRFPremium(uint16 tokens) internal returns (uint) {
}
function unstakeRFPremium(uint16 [] calldata data) external returns (uint){
}
function removeRFPremiumToken(uint16 token) internal {
}
// ---------- PlatinumFrenzBoost --------------///
// ---------- GoldFrenzBoost --------------///
function stakeRFUnleaded(uint16 [] calldata data) external{
uint16 _number= uint16(data.length );
require(_number > 0 , "Invalid Number");
require(<FILL_ME>)
uint16 tokens=uint16(stakeOwners[msg.sender].rfunleaded.tokens.length);
if(tokens > 0){
stakeOwners[ msg.sender].rfunleaded.rewards = calculateRFUnleadedReward(msg.sender);
}
stakeOwners[ msg.sender].rfunleaded.rewardStartTime = uint64(block.timestamp);
totalNFTStaked += _number;
totalrfUnleadedNFTStaked += _number;
storeRFUnleadedTokens(_number , data);
for(uint16 i ; i< _number ; i++)
{
require(RFUnleaded.ownerOf(data[i]) == msg.sender, "Not the owner");
RFUnleaded.transferFrom( msg.sender, address(this),data[i]);
}
delete tokens;
}
function calculateRFUnleadedReward(address _address) public view returns (uint){
}
function storeRFUnleadedTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFUnleaded(address _address) external view returns(uint16 [] memory)
{
}
function getRFUnleadedStakeTime(address _address) public view returns(uint64){
}
function claimRFUnleadedReward() external returns (uint){
}
function getRewardforUnstakingRFUnleaded(uint16 tokens) internal returns (uint){
}
function unstakeRFUnleaded(uint16 [] calldata data) external returns (uint){
}
function removeRFUnleadedToken(uint16 token) internal {
}
// ---------- RFUnleaded --------------///
// ---------- Spaceship --------------///
function stakeSpaceship(uint16 [] calldata data) external{
}
function calculateSpaceshipReward(address _address) public view returns (uint){
}
function storeSpaceshipTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfspaceship(address _address) external view returns(uint16 [] memory)
{
}
function getSpaceshipStakeTime(address _address) public view returns(uint64){
}
function claimSpaceshipReward() external returns(uint){
}
function getRewardforUnstakingSpaceship(uint16 tokens) internal returns (uint){
}
function unstakeSpaceship(uint16 [] calldata data) external returns(uint){
}
function removeSpaceshipToken(uint16 token) internal {
}
// ---------- Spaceship --------------///
}
| checkIfGen2Staked(msg.sender)==true," No Gen0 NFTs staked" | 201,762 | checkIfGen2Staked(msg.sender)==true |
"Not the owner" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.0;
interface IGenesis0 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IGenesis2 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostPlatinum {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostGold {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface ISpaceship {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
contract NubbiesStaking is Ownable{
uint16 public totalNFTStaked ;
uint16 public totalgen0NFTStaked ;
uint16 public totalgen2NFTStaked ;
uint16 public totalrfPremiumNFTStaked ;
uint16 public totalrfUnleadedNFTStaked ;
uint16 public totalspaceshipNFTStaked ;
struct stakeOwner{
Gen0staker gen0;
Gen2staker gen2;
FBPlatinumStaker rfpremium;
FBGoldStaker rfunleaded;
Spaceshipstaker spaceship;
}
struct Gen0staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Gen2staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBPlatinumStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBGoldStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Spaceshipstaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
//stakedNft []staked;
mapping(address => stakeOwner) public stakeOwners ;
// uint startTime = block.timestamp;
uint public dailyGen0Reward = 4 ether ;
uint public dailyGen2Reward = 2 ether;
uint public dailyspaceshipReward = 1 ether;
uint public dailyPlatinumFrenzBoost = 4 ether;
uint public dailyGoldFrenzBoost = 2 ether;
address public gen0 = 0x091d8E039d532Fd02d7AcC593043acFf05839927;
address public gen2;
address public spaceshipaddress;
address public PlatinumFrenzBoost;
address public GoldFrenzBoost;
IGenesis0 genesis0= IGenesis0(gen0) ;
IGenesis2 genesis2 ;
IFrenzBoostPlatinum RFPremium ;
IFrenzBoostGold RFUnleaded ;
ISpaceship spaceship;
constructor() {
}
/// ---------- Setting info --------------///
function setGen0Address(address contractAddr) external onlyOwner {
}
function setGen2Address(address contractAddr) external onlyOwner {
}
function setSpaceShipAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostPlatinumAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostGoldAddress(address contractAddr) external onlyOwner {
}
function setdailyGen0Reward (uint _reward) external onlyOwner{
}
function setdailyGen2Reward (uint _reward) external onlyOwner{
}
function setdailyspaceshipReward (uint _reward) external onlyOwner{
}
function setdailyRFPremiumReward (uint _reward) external onlyOwner{
}
function setdailyRFUnleadedReward (uint _reward) external onlyOwner{
}
// ---------- Setting info --------------///
// ---------- GEN0 --------------///
function stakeGen0(uint16 [] calldata data) external{
}
function calculateGen0Reward(address _address) public view returns (uint){
}
function storeGen0Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen0(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen0Staked(address _address) public view returns (bool){
}
function getGen0StakeTime(address _address) public view returns(uint64){
}
function claimGen0Reward() external {
}
function calculateRewardforUnstakingGen0(uint16 [] calldata data , address _address) public view returns (uint) {
}
function getRewardforUnstakingGen0(uint16 tokens) internal {
}
function unstakeGen0(uint16 [] calldata data) external {
}
function removeGen0Token(uint16 token) internal {
}
// ---------- GEN0 --------------///
// ---------- GEN2 --------------///
function stakeGen2(uint16 [] calldata data) external{
}
function calculateGen2Reward(address _address) public view returns (uint){
}
function storeGen2Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen2(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen2Staked(address _address) public view returns (bool){
}
function getGen2StakeTime(address _address) public view returns(uint64){
}
function claimGen2Reward() external returns (uint){
}
function getRewardforUnstakingGen2(uint16 tokens) internal returns (uint){
}
function unstakeGen2(uint16 [] calldata data) external returns (uint){
}
function removeGen2Token(uint16 token) internal {
}
// ---------- GEN2 --------------///
// ---------- PlatinumFrenzBoost --------------///
function stakeRFPremium(uint16 [] calldata data) external{
}
function calculateRFPremiumReward(address _address) public view returns (uint){
}
function storeRFPremiumTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFPremium(address _address) external view returns(uint16 [] memory)
{
}
function getRFPremiumStakeTime(address _address) public view returns(uint64){
}
function claimRFPremiumReward() external returns (uint){
}
function getRewardforUnstakingRFPremium(uint16 tokens) internal returns (uint) {
}
function unstakeRFPremium(uint16 [] calldata data) external returns (uint){
}
function removeRFPremiumToken(uint16 token) internal {
}
// ---------- PlatinumFrenzBoost --------------///
// ---------- GoldFrenzBoost --------------///
function stakeRFUnleaded(uint16 [] calldata data) external{
uint16 _number= uint16(data.length );
require(_number > 0 , "Invalid Number");
require(checkIfGen2Staked(msg.sender) == true , " No Gen0 NFTs staked");
uint16 tokens=uint16(stakeOwners[msg.sender].rfunleaded.tokens.length);
if(tokens > 0){
stakeOwners[ msg.sender].rfunleaded.rewards = calculateRFUnleadedReward(msg.sender);
}
stakeOwners[ msg.sender].rfunleaded.rewardStartTime = uint64(block.timestamp);
totalNFTStaked += _number;
totalrfUnleadedNFTStaked += _number;
storeRFUnleadedTokens(_number , data);
for(uint16 i ; i< _number ; i++)
{
require(<FILL_ME>)
RFUnleaded.transferFrom( msg.sender, address(this),data[i]);
}
delete tokens;
}
function calculateRFUnleadedReward(address _address) public view returns (uint){
}
function storeRFUnleadedTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFUnleaded(address _address) external view returns(uint16 [] memory)
{
}
function getRFUnleadedStakeTime(address _address) public view returns(uint64){
}
function claimRFUnleadedReward() external returns (uint){
}
function getRewardforUnstakingRFUnleaded(uint16 tokens) internal returns (uint){
}
function unstakeRFUnleaded(uint16 [] calldata data) external returns (uint){
}
function removeRFUnleadedToken(uint16 token) internal {
}
// ---------- RFUnleaded --------------///
// ---------- Spaceship --------------///
function stakeSpaceship(uint16 [] calldata data) external{
}
function calculateSpaceshipReward(address _address) public view returns (uint){
}
function storeSpaceshipTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfspaceship(address _address) external view returns(uint16 [] memory)
{
}
function getSpaceshipStakeTime(address _address) public view returns(uint64){
}
function claimSpaceshipReward() external returns(uint){
}
function getRewardforUnstakingSpaceship(uint16 tokens) internal returns (uint){
}
function unstakeSpaceship(uint16 [] calldata data) external returns(uint){
}
function removeSpaceshipToken(uint16 token) internal {
}
// ---------- Spaceship --------------///
}
| RFUnleaded.ownerOf(data[i])==msg.sender,"Not the owner" | 201,762 | RFUnleaded.ownerOf(data[i])==msg.sender |
"You have not staked any NFTs" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.0;
interface IGenesis0 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IGenesis2 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostPlatinum {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostGold {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface ISpaceship {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
contract NubbiesStaking is Ownable{
uint16 public totalNFTStaked ;
uint16 public totalgen0NFTStaked ;
uint16 public totalgen2NFTStaked ;
uint16 public totalrfPremiumNFTStaked ;
uint16 public totalrfUnleadedNFTStaked ;
uint16 public totalspaceshipNFTStaked ;
struct stakeOwner{
Gen0staker gen0;
Gen2staker gen2;
FBPlatinumStaker rfpremium;
FBGoldStaker rfunleaded;
Spaceshipstaker spaceship;
}
struct Gen0staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Gen2staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBPlatinumStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBGoldStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Spaceshipstaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
//stakedNft []staked;
mapping(address => stakeOwner) public stakeOwners ;
// uint startTime = block.timestamp;
uint public dailyGen0Reward = 4 ether ;
uint public dailyGen2Reward = 2 ether;
uint public dailyspaceshipReward = 1 ether;
uint public dailyPlatinumFrenzBoost = 4 ether;
uint public dailyGoldFrenzBoost = 2 ether;
address public gen0 = 0x091d8E039d532Fd02d7AcC593043acFf05839927;
address public gen2;
address public spaceshipaddress;
address public PlatinumFrenzBoost;
address public GoldFrenzBoost;
IGenesis0 genesis0= IGenesis0(gen0) ;
IGenesis2 genesis2 ;
IFrenzBoostPlatinum RFPremium ;
IFrenzBoostGold RFUnleaded ;
ISpaceship spaceship;
constructor() {
}
/// ---------- Setting info --------------///
function setGen0Address(address contractAddr) external onlyOwner {
}
function setGen2Address(address contractAddr) external onlyOwner {
}
function setSpaceShipAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostPlatinumAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostGoldAddress(address contractAddr) external onlyOwner {
}
function setdailyGen0Reward (uint _reward) external onlyOwner{
}
function setdailyGen2Reward (uint _reward) external onlyOwner{
}
function setdailyspaceshipReward (uint _reward) external onlyOwner{
}
function setdailyRFPremiumReward (uint _reward) external onlyOwner{
}
function setdailyRFUnleadedReward (uint _reward) external onlyOwner{
}
// ---------- Setting info --------------///
// ---------- GEN0 --------------///
function stakeGen0(uint16 [] calldata data) external{
}
function calculateGen0Reward(address _address) public view returns (uint){
}
function storeGen0Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen0(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen0Staked(address _address) public view returns (bool){
}
function getGen0StakeTime(address _address) public view returns(uint64){
}
function claimGen0Reward() external {
}
function calculateRewardforUnstakingGen0(uint16 [] calldata data , address _address) public view returns (uint) {
}
function getRewardforUnstakingGen0(uint16 tokens) internal {
}
function unstakeGen0(uint16 [] calldata data) external {
}
function removeGen0Token(uint16 token) internal {
}
// ---------- GEN0 --------------///
// ---------- GEN2 --------------///
function stakeGen2(uint16 [] calldata data) external{
}
function calculateGen2Reward(address _address) public view returns (uint){
}
function storeGen2Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen2(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen2Staked(address _address) public view returns (bool){
}
function getGen2StakeTime(address _address) public view returns(uint64){
}
function claimGen2Reward() external returns (uint){
}
function getRewardforUnstakingGen2(uint16 tokens) internal returns (uint){
}
function unstakeGen2(uint16 [] calldata data) external returns (uint){
}
function removeGen2Token(uint16 token) internal {
}
// ---------- GEN2 --------------///
// ---------- PlatinumFrenzBoost --------------///
function stakeRFPremium(uint16 [] calldata data) external{
}
function calculateRFPremiumReward(address _address) public view returns (uint){
}
function storeRFPremiumTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFPremium(address _address) external view returns(uint16 [] memory)
{
}
function getRFPremiumStakeTime(address _address) public view returns(uint64){
}
function claimRFPremiumReward() external returns (uint){
}
function getRewardforUnstakingRFPremium(uint16 tokens) internal returns (uint) {
}
function unstakeRFPremium(uint16 [] calldata data) external returns (uint){
}
function removeRFPremiumToken(uint16 token) internal {
}
// ---------- PlatinumFrenzBoost --------------///
// ---------- GoldFrenzBoost --------------///
function stakeRFUnleaded(uint16 [] calldata data) external{
}
function calculateRFUnleadedReward(address _address) public view returns (uint){
}
function storeRFUnleadedTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFUnleaded(address _address) external view returns(uint16 [] memory)
{
}
function getRFUnleadedStakeTime(address _address) public view returns(uint64){
}
function claimRFUnleadedReward() external returns (uint){
require(<FILL_ME>)
uint reward = calculateRFUnleadedReward(msg.sender);
stakeOwners[ msg.sender].rfunleaded.rewardStartTime = uint64(block.timestamp);
stakeOwners[ msg.sender].rfunleaded.rewards=0;
return reward;
}
function getRewardforUnstakingRFUnleaded(uint16 tokens) internal returns (uint){
}
function unstakeRFUnleaded(uint16 [] calldata data) external returns (uint){
}
function removeRFUnleadedToken(uint16 token) internal {
}
// ---------- RFUnleaded --------------///
// ---------- Spaceship --------------///
function stakeSpaceship(uint16 [] calldata data) external{
}
function calculateSpaceshipReward(address _address) public view returns (uint){
}
function storeSpaceshipTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfspaceship(address _address) external view returns(uint16 [] memory)
{
}
function getSpaceshipStakeTime(address _address) public view returns(uint64){
}
function claimSpaceshipReward() external returns(uint){
}
function getRewardforUnstakingSpaceship(uint16 tokens) internal returns (uint){
}
function unstakeSpaceship(uint16 [] calldata data) external returns(uint){
}
function removeSpaceshipToken(uint16 token) internal {
}
// ---------- Spaceship --------------///
}
| stakeOwners[msg.sender].rfunleaded.tokens.length>0,"You have not staked any NFTs" | 201,762 | stakeOwners[msg.sender].rfunleaded.tokens.length>0 |
"Not the owner" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.0;
interface IGenesis0 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IGenesis2 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostPlatinum {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostGold {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface ISpaceship {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
contract NubbiesStaking is Ownable{
uint16 public totalNFTStaked ;
uint16 public totalgen0NFTStaked ;
uint16 public totalgen2NFTStaked ;
uint16 public totalrfPremiumNFTStaked ;
uint16 public totalrfUnleadedNFTStaked ;
uint16 public totalspaceshipNFTStaked ;
struct stakeOwner{
Gen0staker gen0;
Gen2staker gen2;
FBPlatinumStaker rfpremium;
FBGoldStaker rfunleaded;
Spaceshipstaker spaceship;
}
struct Gen0staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Gen2staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBPlatinumStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBGoldStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Spaceshipstaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
//stakedNft []staked;
mapping(address => stakeOwner) public stakeOwners ;
// uint startTime = block.timestamp;
uint public dailyGen0Reward = 4 ether ;
uint public dailyGen2Reward = 2 ether;
uint public dailyspaceshipReward = 1 ether;
uint public dailyPlatinumFrenzBoost = 4 ether;
uint public dailyGoldFrenzBoost = 2 ether;
address public gen0 = 0x091d8E039d532Fd02d7AcC593043acFf05839927;
address public gen2;
address public spaceshipaddress;
address public PlatinumFrenzBoost;
address public GoldFrenzBoost;
IGenesis0 genesis0= IGenesis0(gen0) ;
IGenesis2 genesis2 ;
IFrenzBoostPlatinum RFPremium ;
IFrenzBoostGold RFUnleaded ;
ISpaceship spaceship;
constructor() {
}
/// ---------- Setting info --------------///
function setGen0Address(address contractAddr) external onlyOwner {
}
function setGen2Address(address contractAddr) external onlyOwner {
}
function setSpaceShipAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostPlatinumAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostGoldAddress(address contractAddr) external onlyOwner {
}
function setdailyGen0Reward (uint _reward) external onlyOwner{
}
function setdailyGen2Reward (uint _reward) external onlyOwner{
}
function setdailyspaceshipReward (uint _reward) external onlyOwner{
}
function setdailyRFPremiumReward (uint _reward) external onlyOwner{
}
function setdailyRFUnleadedReward (uint _reward) external onlyOwner{
}
// ---------- Setting info --------------///
// ---------- GEN0 --------------///
function stakeGen0(uint16 [] calldata data) external{
}
function calculateGen0Reward(address _address) public view returns (uint){
}
function storeGen0Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen0(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen0Staked(address _address) public view returns (bool){
}
function getGen0StakeTime(address _address) public view returns(uint64){
}
function claimGen0Reward() external {
}
function calculateRewardforUnstakingGen0(uint16 [] calldata data , address _address) public view returns (uint) {
}
function getRewardforUnstakingGen0(uint16 tokens) internal {
}
function unstakeGen0(uint16 [] calldata data) external {
}
function removeGen0Token(uint16 token) internal {
}
// ---------- GEN0 --------------///
// ---------- GEN2 --------------///
function stakeGen2(uint16 [] calldata data) external{
}
function calculateGen2Reward(address _address) public view returns (uint){
}
function storeGen2Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen2(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen2Staked(address _address) public view returns (bool){
}
function getGen2StakeTime(address _address) public view returns(uint64){
}
function claimGen2Reward() external returns (uint){
}
function getRewardforUnstakingGen2(uint16 tokens) internal returns (uint){
}
function unstakeGen2(uint16 [] calldata data) external returns (uint){
}
function removeGen2Token(uint16 token) internal {
}
// ---------- GEN2 --------------///
// ---------- PlatinumFrenzBoost --------------///
function stakeRFPremium(uint16 [] calldata data) external{
}
function calculateRFPremiumReward(address _address) public view returns (uint){
}
function storeRFPremiumTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFPremium(address _address) external view returns(uint16 [] memory)
{
}
function getRFPremiumStakeTime(address _address) public view returns(uint64){
}
function claimRFPremiumReward() external returns (uint){
}
function getRewardforUnstakingRFPremium(uint16 tokens) internal returns (uint) {
}
function unstakeRFPremium(uint16 [] calldata data) external returns (uint){
}
function removeRFPremiumToken(uint16 token) internal {
}
// ---------- PlatinumFrenzBoost --------------///
// ---------- GoldFrenzBoost --------------///
function stakeRFUnleaded(uint16 [] calldata data) external{
}
function calculateRFUnleadedReward(address _address) public view returns (uint){
}
function storeRFUnleadedTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFUnleaded(address _address) external view returns(uint16 [] memory)
{
}
function getRFUnleadedStakeTime(address _address) public view returns(uint64){
}
function claimRFUnleadedReward() external returns (uint){
}
function getRewardforUnstakingRFUnleaded(uint16 tokens) internal returns (uint){
}
function unstakeRFUnleaded(uint16 [] calldata data) external returns (uint){
}
function removeRFUnleadedToken(uint16 token) internal {
}
// ---------- RFUnleaded --------------///
// ---------- Spaceship --------------///
function stakeSpaceship(uint16 [] calldata data) external{
uint16 _number= uint16(data.length );
require(_number > 0 , "Invalid Number");
require(checkIfGen2Staked(msg.sender) == true , " No Gen0 NFTs staked");
uint16 tokens=uint16(stakeOwners[msg.sender].spaceship.tokens.length);
if(tokens > 0){
stakeOwners[ msg.sender].spaceship.rewards = calculateSpaceshipReward(msg.sender);
}
stakeOwners[ msg.sender].spaceship.rewardStartTime = uint64(block.timestamp);
totalNFTStaked += _number;
totalspaceshipNFTStaked += _number;
storeSpaceshipTokens(_number , data);
for(uint16 i ; i< _number ; i++)
{
require(<FILL_ME>)
spaceship.transferFrom( msg.sender, address(this),data[i]);
}
delete tokens;
}
function calculateSpaceshipReward(address _address) public view returns (uint){
}
function storeSpaceshipTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfspaceship(address _address) external view returns(uint16 [] memory)
{
}
function getSpaceshipStakeTime(address _address) public view returns(uint64){
}
function claimSpaceshipReward() external returns(uint){
}
function getRewardforUnstakingSpaceship(uint16 tokens) internal returns (uint){
}
function unstakeSpaceship(uint16 [] calldata data) external returns(uint){
}
function removeSpaceshipToken(uint16 token) internal {
}
// ---------- Spaceship --------------///
}
| spaceship.ownerOf(data[i])==msg.sender,"Not the owner" | 201,762 | spaceship.ownerOf(data[i])==msg.sender |
"You have not staked any NFTs" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.0;
interface IGenesis0 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IGenesis2 {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostPlatinum {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface IFrenzBoostGold {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
interface ISpaceship {
function transferFrom( address from, address to, uint256 tokenId) external;
function ownerOf( uint _tokenid) external view returns (address);
}
contract NubbiesStaking is Ownable{
uint16 public totalNFTStaked ;
uint16 public totalgen0NFTStaked ;
uint16 public totalgen2NFTStaked ;
uint16 public totalrfPremiumNFTStaked ;
uint16 public totalrfUnleadedNFTStaked ;
uint16 public totalspaceshipNFTStaked ;
struct stakeOwner{
Gen0staker gen0;
Gen2staker gen2;
FBPlatinumStaker rfpremium;
FBGoldStaker rfunleaded;
Spaceshipstaker spaceship;
}
struct Gen0staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Gen2staker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBPlatinumStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct FBGoldStaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
struct Spaceshipstaker{
uint16[] tokens ;
uint64 rewardStartTime ;
uint rewards;
}
//stakedNft []staked;
mapping(address => stakeOwner) public stakeOwners ;
// uint startTime = block.timestamp;
uint public dailyGen0Reward = 4 ether ;
uint public dailyGen2Reward = 2 ether;
uint public dailyspaceshipReward = 1 ether;
uint public dailyPlatinumFrenzBoost = 4 ether;
uint public dailyGoldFrenzBoost = 2 ether;
address public gen0 = 0x091d8E039d532Fd02d7AcC593043acFf05839927;
address public gen2;
address public spaceshipaddress;
address public PlatinumFrenzBoost;
address public GoldFrenzBoost;
IGenesis0 genesis0= IGenesis0(gen0) ;
IGenesis2 genesis2 ;
IFrenzBoostPlatinum RFPremium ;
IFrenzBoostGold RFUnleaded ;
ISpaceship spaceship;
constructor() {
}
/// ---------- Setting info --------------///
function setGen0Address(address contractAddr) external onlyOwner {
}
function setGen2Address(address contractAddr) external onlyOwner {
}
function setSpaceShipAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostPlatinumAddress(address contractAddr) external onlyOwner {
}
function setFrenzBoostGoldAddress(address contractAddr) external onlyOwner {
}
function setdailyGen0Reward (uint _reward) external onlyOwner{
}
function setdailyGen2Reward (uint _reward) external onlyOwner{
}
function setdailyspaceshipReward (uint _reward) external onlyOwner{
}
function setdailyRFPremiumReward (uint _reward) external onlyOwner{
}
function setdailyRFUnleadedReward (uint _reward) external onlyOwner{
}
// ---------- Setting info --------------///
// ---------- GEN0 --------------///
function stakeGen0(uint16 [] calldata data) external{
}
function calculateGen0Reward(address _address) public view returns (uint){
}
function storeGen0Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen0(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen0Staked(address _address) public view returns (bool){
}
function getGen0StakeTime(address _address) public view returns(uint64){
}
function claimGen0Reward() external {
}
function calculateRewardforUnstakingGen0(uint16 [] calldata data , address _address) public view returns (uint) {
}
function getRewardforUnstakingGen0(uint16 tokens) internal {
}
function unstakeGen0(uint16 [] calldata data) external {
}
function removeGen0Token(uint16 token) internal {
}
// ---------- GEN0 --------------///
// ---------- GEN2 --------------///
function stakeGen2(uint16 [] calldata data) external{
}
function calculateGen2Reward(address _address) public view returns (uint){
}
function storeGen2Tokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfGen2(address _address) external view returns(uint16 [] memory)
{
}
function checkIfGen2Staked(address _address) public view returns (bool){
}
function getGen2StakeTime(address _address) public view returns(uint64){
}
function claimGen2Reward() external returns (uint){
}
function getRewardforUnstakingGen2(uint16 tokens) internal returns (uint){
}
function unstakeGen2(uint16 [] calldata data) external returns (uint){
}
function removeGen2Token(uint16 token) internal {
}
// ---------- GEN2 --------------///
// ---------- PlatinumFrenzBoost --------------///
function stakeRFPremium(uint16 [] calldata data) external{
}
function calculateRFPremiumReward(address _address) public view returns (uint){
}
function storeRFPremiumTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFPremium(address _address) external view returns(uint16 [] memory)
{
}
function getRFPremiumStakeTime(address _address) public view returns(uint64){
}
function claimRFPremiumReward() external returns (uint){
}
function getRewardforUnstakingRFPremium(uint16 tokens) internal returns (uint) {
}
function unstakeRFPremium(uint16 [] calldata data) external returns (uint){
}
function removeRFPremiumToken(uint16 token) internal {
}
// ---------- PlatinumFrenzBoost --------------///
// ---------- GoldFrenzBoost --------------///
function stakeRFUnleaded(uint16 [] calldata data) external{
}
function calculateRFUnleadedReward(address _address) public view returns (uint){
}
function storeRFUnleadedTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfRFUnleaded(address _address) external view returns(uint16 [] memory)
{
}
function getRFUnleadedStakeTime(address _address) public view returns(uint64){
}
function claimRFUnleadedReward() external returns (uint){
}
function getRewardforUnstakingRFUnleaded(uint16 tokens) internal returns (uint){
}
function unstakeRFUnleaded(uint16 [] calldata data) external returns (uint){
}
function removeRFUnleadedToken(uint16 token) internal {
}
// ---------- RFUnleaded --------------///
// ---------- Spaceship --------------///
function stakeSpaceship(uint16 [] calldata data) external{
}
function calculateSpaceshipReward(address _address) public view returns (uint){
}
function storeSpaceshipTokens(uint16 _number , uint16 [] calldata data) internal {
}
function getFulltokenOfspaceship(address _address) external view returns(uint16 [] memory)
{
}
function getSpaceshipStakeTime(address _address) public view returns(uint64){
}
function claimSpaceshipReward() external returns(uint){
require(<FILL_ME>)
uint reward = calculateSpaceshipReward(msg.sender);
stakeOwners[ msg.sender].spaceship.rewardStartTime = uint64(block.timestamp);
stakeOwners[ msg.sender].spaceship.rewards=0;
return reward;
}
function getRewardforUnstakingSpaceship(uint16 tokens) internal returns (uint){
}
function unstakeSpaceship(uint16 [] calldata data) external returns(uint){
}
function removeSpaceshipToken(uint16 token) internal {
}
// ---------- Spaceship --------------///
}
| stakeOwners[msg.sender].spaceship.tokens.length>0,"You have not staked any NFTs" | 201,762 | stakeOwners[msg.sender].spaceship.tokens.length>0 |
null | /**
LANDLORD GAME
Twitter: https://twitter.com/LANDLORDgameERC
Telegram: https://t.me/+TiY0nEyim38xZjgx
Realestate owner wants to put his realestate up for rent, so he hires a LANDLORD to take care of the tennants.
LANDLORD pays the owner a cut of the rent he collects.
Every 10 min interval, LANDLORD is switched to the highest bidding LANDLORD (he purchased the most tokens).
During that timeframe, thete is an ongoing bidding war for next interval.
After the interval is over a new LANDLORD is chosen by the criteria of the most token purchased.
If you choose to sell your tokens at any point, your eligibility to collect rent is permanently revoked.
If the highest bidding LANDLORD sells their tokens bidding war restarts.
If there are no LANDLORDs interested, owner collects all the rent on his own.
Rent is paid in token transfer taxes.
Initial taxes are set to 3.5%.
The LANDLORD has all rights to change taxes and rent collection address however he wants (10% max)
Until the new LANDLORD sets everything up taxes are set to default and tax is sent to owner address.
When LANDLORD sets taxes, he has to write the transacrion on etherscan. Taxes are set with one decimal (eg. for 3.5% tax LANDLORD would need to set it to 35 in the contract call)
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;
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(
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 LANDLORDGAME is Context, IERC20, Ownable {
string private constant _name = unicode"LANDLORDGAME";
string private constant _symbol = unicode"LLG";
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isDisqualified;
mapping(address => bool) private bots;
uint256 public _buyTax = 35;
uint256 public _sellTax = 35;
uint256 private _ownerLANDLORDSplit = 280;
uint256 private _openTradingBlock;
uint256 private _startBlock;
uint256 public _LANDLORDForBlocks = 50;
uint256 public _toBeatAmount = 0;
address payable public _LANDLORD;
address payable public _LANDLORDToBe;
address payable public _rentCollector;
address payable public _propertyOwner;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000 * 10**_decimals;
uint256 public _taxSwapThreshold = 1000 * 10**_decimals;
uint256 public _maxTaxSwap = 20000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
modifier lockTheSwap() {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function getLANDLORD() public view returns (address) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
}
function startLANDLORDGAME() external onlyOwner {
}
function sendETHToFee(uint256 amount) private {
}
function addBots(address[] memory bots_) public onlyOwner {
}
function deleteBots(address[] memory notbot) public onlyOwner {
}
function changeFees(
uint256 _newBuyFee,
uint256 _newSellFee,
address payable rentCollector
) public {
require(<FILL_ME>)
require(
_newBuyFee >= 0 &&
_newBuyFee <= 100 &&
_newSellFee >= 0 &&
_newSellFee <= 100
);
_buyTax = _newBuyFee;
_sellTax = _newSellFee;
_rentCollector = rentCollector;
}
function evictLANDLORD() public {
}
function changeLANDLORDDuretion(uint256 _forBlocks) public {
}
function manualSwap() external {
}
receive() external payable {}
}
| _msgSender()==_LANDLORD | 201,942 | _msgSender()==_LANDLORD |
null | /**
LANDLORD GAME
Twitter: https://twitter.com/LANDLORDgameERC
Telegram: https://t.me/+TiY0nEyim38xZjgx
Realestate owner wants to put his realestate up for rent, so he hires a LANDLORD to take care of the tennants.
LANDLORD pays the owner a cut of the rent he collects.
Every 10 min interval, LANDLORD is switched to the highest bidding LANDLORD (he purchased the most tokens).
During that timeframe, thete is an ongoing bidding war for next interval.
After the interval is over a new LANDLORD is chosen by the criteria of the most token purchased.
If you choose to sell your tokens at any point, your eligibility to collect rent is permanently revoked.
If the highest bidding LANDLORD sells their tokens bidding war restarts.
If there are no LANDLORDs interested, owner collects all the rent on his own.
Rent is paid in token transfer taxes.
Initial taxes are set to 3.5%.
The LANDLORD has all rights to change taxes and rent collection address however he wants (10% max)
Until the new LANDLORD sets everything up taxes are set to default and tax is sent to owner address.
When LANDLORD sets taxes, he has to write the transacrion on etherscan. Taxes are set with one decimal (eg. for 3.5% tax LANDLORD would need to set it to 35 in the contract call)
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;
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(
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 LANDLORDGAME is Context, IERC20, Ownable {
string private constant _name = unicode"LANDLORDGAME";
string private constant _symbol = unicode"LLG";
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isDisqualified;
mapping(address => bool) private bots;
uint256 public _buyTax = 35;
uint256 public _sellTax = 35;
uint256 private _ownerLANDLORDSplit = 280;
uint256 private _openTradingBlock;
uint256 private _startBlock;
uint256 public _LANDLORDForBlocks = 50;
uint256 public _toBeatAmount = 0;
address payable public _LANDLORD;
address payable public _LANDLORDToBe;
address payable public _rentCollector;
address payable public _propertyOwner;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000 * 10**_decimals;
uint256 public _taxSwapThreshold = 1000 * 10**_decimals;
uint256 public _maxTaxSwap = 20000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
modifier lockTheSwap() {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function getLANDLORD() public view returns (address) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
}
function startLANDLORDGAME() external onlyOwner {
}
function sendETHToFee(uint256 amount) private {
}
function addBots(address[] memory bots_) public onlyOwner {
}
function deleteBots(address[] memory notbot) public onlyOwner {
}
function changeFees(
uint256 _newBuyFee,
uint256 _newSellFee,
address payable rentCollector
) public {
}
function evictLANDLORD() public {
require(<FILL_ME>)
_LANDLORD = _propertyOwner;
}
function changeLANDLORDDuretion(uint256 _forBlocks) public {
}
function manualSwap() external {
}
receive() external payable {}
}
| _msgSender()==_propertyOwner | 201,942 | _msgSender()==_propertyOwner |
"ToonCity :: Minting this many would put you over 13!" | pragma solidity ^0.8.17;
contract ToonCityNFT is ERC721A, IERC2981, Ownable, DefaultOperatorFilterer{
using Strings for uint256;
error TokenDoesNotExist(uint256 id);
uint256 public MAX_SUPPLY = 9999;
uint256 public MAX_WL_SUPPLY = 1200;
uint256 public MAX_MINT = 13;
uint256 public PRICE = .005 ether;
address public Royalty;
mapping(address => uint256) public hasMintedCount;
string private baseTokenUri;
string public placeholderTokenUri;
mapping(address => bool) public hasClaimed;
bool public isRevealed;
bool public publicSale;
bool public whiteListSale;
bool public pause;
bytes32 private merkleRoot;
mapping(address => uint256) public totalPublicMint;
mapping(address => uint256) public totalWhitelistMint;
constructor() ERC721A("ToonCity", "ToonCity"){}
modifier callerIsUser() {
}
function mint(uint256 _quantity) external payable callerIsUser {
require(publicSale, "ToonCity :: Not Yet Active.");
require((totalSupply() + _quantity) <= MAX_SUPPLY, "ToonCity :: PUBLIC SOLDOUT");
require(<FILL_ME>)
uint256 cost = PRICE * _quantity;
if (hasMintedCount[msg.sender] < 1) {
cost = PRICE * (_quantity - 1);
}
require(msg.value >= cost, "ToonCity :: pay more fool");
totalPublicMint[msg.sender] += _quantity;
hasMintedCount[msg.sender]++;
_mint(msg.sender, _quantity);
}
function whitelistMint(bytes32[] memory _merkleProof, uint256 _quantity) external payable callerIsUser {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function teamMint(uint256 quantity) external onlyOwner{
}
function setTokenUri(string calldata _baseTokenUri) external onlyOwner{
}
function setMaxSupply(uint256 _MAX_SUPPLY) external onlyOwner{
}
function setPlaceHolderUri(string calldata _placeholderTokenUri) external onlyOwner{
}
function setMintPrice(uint256 newMintPrice)external onlyOwner{
}
function setMintPrice(address _Royalty)external onlyOwner{
}
function toggleWhiteListSale() external onlyOwner{
}
function togglePublicSale() external onlyOwner{
}
function toggleReveal() external onlyOwner{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner{
}
function getMerkleRoot() external view returns (bytes32){
}
function withdraw() external onlyOwner{
}
/* ERC 2891 */
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721A, IERC165) returns (bool) {
}
function _supportsInterface(bytes4 interfaceId) private view returns (bool) {
}
//opensea registry
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override payable onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override payable onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override payable onlyAllowedOperator(from) {
}
function safeTransferFrom (address from, address to, uint256 tokenId, bytes memory data)
public payable
override
onlyAllowedOperator(from)
{
}
}
| (totalPublicMint[msg.sender]+_quantity)<=MAX_MINT,"ToonCity :: Minting this many would put you over 13!" | 202,029 | (totalPublicMint[msg.sender]+_quantity)<=MAX_MINT |
"ToonCity :: WHITELIST SOLDOUT" | pragma solidity ^0.8.17;
contract ToonCityNFT is ERC721A, IERC2981, Ownable, DefaultOperatorFilterer{
using Strings for uint256;
error TokenDoesNotExist(uint256 id);
uint256 public MAX_SUPPLY = 9999;
uint256 public MAX_WL_SUPPLY = 1200;
uint256 public MAX_MINT = 13;
uint256 public PRICE = .005 ether;
address public Royalty;
mapping(address => uint256) public hasMintedCount;
string private baseTokenUri;
string public placeholderTokenUri;
mapping(address => bool) public hasClaimed;
bool public isRevealed;
bool public publicSale;
bool public whiteListSale;
bool public pause;
bytes32 private merkleRoot;
mapping(address => uint256) public totalPublicMint;
mapping(address => uint256) public totalWhitelistMint;
constructor() ERC721A("ToonCity", "ToonCity"){}
modifier callerIsUser() {
}
function mint(uint256 _quantity) external payable callerIsUser {
}
function whitelistMint(bytes32[] memory _merkleProof, uint256 _quantity) external payable callerIsUser {
require(whiteListSale, "ToonCity :: Minting is on Pause");
require(<FILL_ME>)
require((totalWhitelistMint[msg.sender] + _quantity) <= MAX_MINT, "ToonCity :: Minting this many would put you over 13!");
uint256 cost = PRICE * _quantity;
if (hasMintedCount[msg.sender] < 2) {
cost = PRICE * (_quantity - 2 + hasMintedCount[msg.sender]);
}
require(msg.value >= cost, "ToonCity :: pay more fool");
//create leaf node
bytes32 sender = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, merkleRoot, sender), "ToonCity :: You are not whitelisted");
totalWhitelistMint[msg.sender] += _quantity;
hasMintedCount[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function teamMint(uint256 quantity) external onlyOwner{
}
function setTokenUri(string calldata _baseTokenUri) external onlyOwner{
}
function setMaxSupply(uint256 _MAX_SUPPLY) external onlyOwner{
}
function setPlaceHolderUri(string calldata _placeholderTokenUri) external onlyOwner{
}
function setMintPrice(uint256 newMintPrice)external onlyOwner{
}
function setMintPrice(address _Royalty)external onlyOwner{
}
function toggleWhiteListSale() external onlyOwner{
}
function togglePublicSale() external onlyOwner{
}
function toggleReveal() external onlyOwner{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner{
}
function getMerkleRoot() external view returns (bytes32){
}
function withdraw() external onlyOwner{
}
/* ERC 2891 */
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721A, IERC165) returns (bool) {
}
function _supportsInterface(bytes4 interfaceId) private view returns (bool) {
}
//opensea registry
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override payable onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override payable onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override payable onlyAllowedOperator(from) {
}
function safeTransferFrom (address from, address to, uint256 tokenId, bytes memory data)
public payable
override
onlyAllowedOperator(from)
{
}
}
| (totalSupply()+_quantity)<MAX_WL_SUPPLY,"ToonCity :: WHITELIST SOLDOUT" | 202,029 | (totalSupply()+_quantity)<MAX_WL_SUPPLY |
"ToonCity :: Minting this many would put you over 13!" | pragma solidity ^0.8.17;
contract ToonCityNFT is ERC721A, IERC2981, Ownable, DefaultOperatorFilterer{
using Strings for uint256;
error TokenDoesNotExist(uint256 id);
uint256 public MAX_SUPPLY = 9999;
uint256 public MAX_WL_SUPPLY = 1200;
uint256 public MAX_MINT = 13;
uint256 public PRICE = .005 ether;
address public Royalty;
mapping(address => uint256) public hasMintedCount;
string private baseTokenUri;
string public placeholderTokenUri;
mapping(address => bool) public hasClaimed;
bool public isRevealed;
bool public publicSale;
bool public whiteListSale;
bool public pause;
bytes32 private merkleRoot;
mapping(address => uint256) public totalPublicMint;
mapping(address => uint256) public totalWhitelistMint;
constructor() ERC721A("ToonCity", "ToonCity"){}
modifier callerIsUser() {
}
function mint(uint256 _quantity) external payable callerIsUser {
}
function whitelistMint(bytes32[] memory _merkleProof, uint256 _quantity) external payable callerIsUser {
require(whiteListSale, "ToonCity :: Minting is on Pause");
require((totalSupply() + _quantity) < MAX_WL_SUPPLY, "ToonCity :: WHITELIST SOLDOUT");
require(<FILL_ME>)
uint256 cost = PRICE * _quantity;
if (hasMintedCount[msg.sender] < 2) {
cost = PRICE * (_quantity - 2 + hasMintedCount[msg.sender]);
}
require(msg.value >= cost, "ToonCity :: pay more fool");
//create leaf node
bytes32 sender = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, merkleRoot, sender), "ToonCity :: You are not whitelisted");
totalWhitelistMint[msg.sender] += _quantity;
hasMintedCount[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function teamMint(uint256 quantity) external onlyOwner{
}
function setTokenUri(string calldata _baseTokenUri) external onlyOwner{
}
function setMaxSupply(uint256 _MAX_SUPPLY) external onlyOwner{
}
function setPlaceHolderUri(string calldata _placeholderTokenUri) external onlyOwner{
}
function setMintPrice(uint256 newMintPrice)external onlyOwner{
}
function setMintPrice(address _Royalty)external onlyOwner{
}
function toggleWhiteListSale() external onlyOwner{
}
function togglePublicSale() external onlyOwner{
}
function toggleReveal() external onlyOwner{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner{
}
function getMerkleRoot() external view returns (bytes32){
}
function withdraw() external onlyOwner{
}
/* ERC 2891 */
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721A, IERC165) returns (bool) {
}
function _supportsInterface(bytes4 interfaceId) private view returns (bool) {
}
//opensea registry
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override payable onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override payable onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override payable onlyAllowedOperator(from) {
}
function safeTransferFrom (address from, address to, uint256 tokenId, bytes memory data)
public payable
override
onlyAllowedOperator(from)
{
}
}
| (totalWhitelistMint[msg.sender]+_quantity)<=MAX_MINT,"ToonCity :: Minting this many would put you over 13!" | 202,029 | (totalWhitelistMint[msg.sender]+_quantity)<=MAX_MINT |
"ToonCity :: PUBLIC SOLDOUT" | pragma solidity ^0.8.17;
contract ToonCityNFT is ERC721A, IERC2981, Ownable, DefaultOperatorFilterer{
using Strings for uint256;
error TokenDoesNotExist(uint256 id);
uint256 public MAX_SUPPLY = 9999;
uint256 public MAX_WL_SUPPLY = 1200;
uint256 public MAX_MINT = 13;
uint256 public PRICE = .005 ether;
address public Royalty;
mapping(address => uint256) public hasMintedCount;
string private baseTokenUri;
string public placeholderTokenUri;
mapping(address => bool) public hasClaimed;
bool public isRevealed;
bool public publicSale;
bool public whiteListSale;
bool public pause;
bytes32 private merkleRoot;
mapping(address => uint256) public totalPublicMint;
mapping(address => uint256) public totalWhitelistMint;
constructor() ERC721A("ToonCity", "ToonCity"){}
modifier callerIsUser() {
}
function mint(uint256 _quantity) external payable callerIsUser {
}
function whitelistMint(bytes32[] memory _merkleProof, uint256 _quantity) external payable callerIsUser {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function teamMint(uint256 quantity) external onlyOwner{
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
function setTokenUri(string calldata _baseTokenUri) external onlyOwner{
}
function setMaxSupply(uint256 _MAX_SUPPLY) external onlyOwner{
}
function setPlaceHolderUri(string calldata _placeholderTokenUri) external onlyOwner{
}
function setMintPrice(uint256 newMintPrice)external onlyOwner{
}
function setMintPrice(address _Royalty)external onlyOwner{
}
function toggleWhiteListSale() external onlyOwner{
}
function togglePublicSale() external onlyOwner{
}
function toggleReveal() external onlyOwner{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner{
}
function getMerkleRoot() external view returns (bytes32){
}
function withdraw() external onlyOwner{
}
/* ERC 2891 */
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721A, IERC165) returns (bool) {
}
function _supportsInterface(bytes4 interfaceId) private view returns (bool) {
}
//opensea registry
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override payable onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override payable onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override payable onlyAllowedOperator(from) {
}
function safeTransferFrom (address from, address to, uint256 tokenId, bytes memory data)
public payable
override
onlyAllowedOperator(from)
{
}
}
| (totalSupply()+quantity)<=MAX_SUPPLY,"ToonCity :: PUBLIC SOLDOUT" | 202,029 | (totalSupply()+quantity)<=MAX_SUPPLY |
null | // SPDX-License-Identifier: MIT
/**
LINKPAY is a streamlined and secure payment solution that enables effortless one-click transactions.
With a focus on simplicity, it offers a convenient way for users to make payments with confidence, eliminating the hassle of repetitive data entry.
By ensuring a seamless and secure experience, LINKPAY redefines how transactions are conducted, making online payments smoother than ever.
BETA TESTING IS NOW LIVE!
Website: https://link.com/
Twitter: https://twitter.com/LINKPAY_coin
TG: https://t.me/linkpay_erc20
**/
pragma solidity 0.8.15;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract LinkPay is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address taxAddress;
bool public limitsInEffect = true;
bool public tradingActive = false;
// Anti-sandwithc-bot mappings and variables
mapping(address => uint256) private _holderLastBuyBlock; // to hold last Buy temporarily
bool public transferDelayEnabled = true;
uint256 public buyFee;
uint256 public sellFee;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedBuyFee(uint256 buyFee);
event UpdatedSellFee(uint256 sellFee);
event MaxTransactionExclusion(address _address, bool excluded);
event BuyBackTriggered(uint256 amount);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() ERC20("LinkPay","LINK") {
}
receive() external payable {}
// only enable if no plan to airdrop
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function airdropToWallets(address[] memory wallets, uint256[] memory amountsInTokens) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _buyFee) external onlyOwner {
}
function updateSellFees(uint256 _sellFee) external onlyOwner {
}
function returnToNormalTax() external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function sendETHToFee(uint256 amount) private {
}
function manualSwap() external {
require(<FILL_ME>)
uint256 tokenBalance=balanceOf(address(this));
if(tokenBalance>0){
swapTokensForEth(tokenBalance);
}
uint256 ethBalance=address(this).balance;
if(ethBalance>0){
sendETHToFee(ethBalance);
}
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
// useful for buybacks or to reclaim any ETH on the contract in a way that helps holders.
function buyBackTokens(uint256 amountInWei) external onlyOwner {
}
}
| _msgSender()==taxAddress | 202,082 | _msgSender()==taxAddress |
"Cannot mint more tokens than allowed per wallet" | // SPDX-License-Identifier: MIT
/*
___ _ ____ _ __ _
/ | (_) / __ ) (_) _____ ____/ / (_) ___ ____
/ /| | / / / __ | / / / ___/ / __ / / / / _ \/_ /
/ ___ | / / / /_/ / / / / / / /_/ / / / / __/ / /_
/_/ |_|/_/ /_____/ /_/ /_/ \__,_/ /_/ \___/ /___/
Looks slightly different because we're broke mfs that can't pay gas fees for reserves up front.
Contract made with help from ChatGPT.
*/
pragma solidity ^0.8.18;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "hardhat/console.sol";
contract AiBirdiez is ERC721, ERC721Enumerable, Ownable {
bool public saleIsActive = false;
string private _baseURIVar;
string public baseExtension = ".json";
uint256 public constant MAX_TOKENS_PER_WALLET = 4;
address payable public teamAddress;
constructor(string memory _initBaseURI) ERC721("AiBirdiez", "AIBRD") {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool) {
}
function setBaseURI(string memory baseURI_) public onlyOwner() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setTeamAddress(address payable teamAddress_) external onlyOwner(){
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function reserveP1() public onlyOwner {
}
function reserveP2() public onlyOwner {
}
function reserveP3() public onlyOwner {
}
function reserveP4() public onlyOwner {
}
function setSaleState(bool newState) public onlyOwner {
}
function mint(uint numberOfTokens) public payable {
require(saleIsActive, "Sale must be active to mint Tokens");
require(numberOfTokens <= 4, "Exceeded max token purchase");
require(<FILL_ME>)
require(totalSupply() + numberOfTokens <= 8550, "Purchase would exceed max supply of tokens");
for(uint i = 0; i < numberOfTokens; i++) {
uint mintIndex = totalSupply();
if (totalSupply() < 9000) {
_safeMint(msg.sender, mintIndex);
}
}
}
function withdraw() public onlyOwner {
}
}
| balanceOf(msg.sender)+numberOfTokens<=MAX_TOKENS_PER_WALLET,"Cannot mint more tokens than allowed per wallet" | 202,103 | balanceOf(msg.sender)+numberOfTokens<=MAX_TOKENS_PER_WALLET |
"Purchase would exceed max supply of tokens" | // SPDX-License-Identifier: MIT
/*
___ _ ____ _ __ _
/ | (_) / __ ) (_) _____ ____/ / (_) ___ ____
/ /| | / / / __ | / / / ___/ / __ / / / / _ \/_ /
/ ___ | / / / /_/ / / / / / / /_/ / / / / __/ / /_
/_/ |_|/_/ /_____/ /_/ /_/ \__,_/ /_/ \___/ /___/
Looks slightly different because we're broke mfs that can't pay gas fees for reserves up front.
Contract made with help from ChatGPT.
*/
pragma solidity ^0.8.18;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "hardhat/console.sol";
contract AiBirdiez is ERC721, ERC721Enumerable, Ownable {
bool public saleIsActive = false;
string private _baseURIVar;
string public baseExtension = ".json";
uint256 public constant MAX_TOKENS_PER_WALLET = 4;
address payable public teamAddress;
constructor(string memory _initBaseURI) ERC721("AiBirdiez", "AIBRD") {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool) {
}
function setBaseURI(string memory baseURI_) public onlyOwner() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setTeamAddress(address payable teamAddress_) external onlyOwner(){
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function reserveP1() public onlyOwner {
}
function reserveP2() public onlyOwner {
}
function reserveP3() public onlyOwner {
}
function reserveP4() public onlyOwner {
}
function setSaleState(bool newState) public onlyOwner {
}
function mint(uint numberOfTokens) public payable {
require(saleIsActive, "Sale must be active to mint Tokens");
require(numberOfTokens <= 4, "Exceeded max token purchase");
require(balanceOf(msg.sender) + numberOfTokens <= MAX_TOKENS_PER_WALLET, "Cannot mint more tokens than allowed per wallet");
require(<FILL_ME>)
for(uint i = 0; i < numberOfTokens; i++) {
uint mintIndex = totalSupply();
if (totalSupply() < 9000) {
_safeMint(msg.sender, mintIndex);
}
}
}
function withdraw() public onlyOwner {
}
}
| totalSupply()+numberOfTokens<=8550,"Purchase would exceed max supply of tokens" | 202,103 | totalSupply()+numberOfTokens<=8550 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.