comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Insufficient funds" | /*
8888888888P 8888888888 8888888b. .d88888b.
d88P 888 888 Y88b d88P" "Y88b
d88P 888 888 888 888 888
d88P 8888888 888 d88P 888 888
d88P 888 8888888P" 888 888
d88P 888 888 T88b 888 888
d88P 888 888 T88b Y88b. .d88P
d8888888888 8888888888 888 T88b "Y88888P"
It's Zero's mission to help the world onboard onto crypto.
The Zeros collection consists of over 200+ hand drawn traits
and backgrounds that we've been working on for the last few months.
In a world where humans and robots coexist. Zero was created to advance
the world's technology. Some humans have rejected the new technology.
Those that have joined the new world are called Zeroes.The world rejects
these new tools and advancements out of fear.
Learn more:
https://usezero.io/
*/
pragma solidity ^0.8.17;
contract Zero is Ownable, ERC721A, ReentrancyGuard {
uint256 private _publicPrice;
uint256 private _presalePrice;
uint256 private _maxPurchaseDuringWhitelist;
uint256 private _maxPurchaseDuringSale;
uint256 private _maxPerTransaction;
uint256 private _maxMint;
address private _team;
bytes32 public _merkleRoot;
bytes32 public _zeroListMerkleRoot;
mapping(address => uint256) public presaleAddressMintCount;
mapping(address => uint256) public zeroListMintAddressCount;
bool public isPaused = false;
bool public isPublicMint = false;
bool public isWhitelistMint = false;
string private _tokenURI;
constructor(
uint256 publicPrice,
uint256 presalePrice,
uint256 maxPurchaseDuringWhitelist,
uint256 maxPurchaseDuringSale,
uint256 maxPerTransaction,
uint256 maxMint,
address team,
bytes32 merkleRoot,
bytes32 zeroListMerkleRoot
) ERC721A("ZERO", "ZERO", maxPerTransaction, maxMint) {
}
function setParams (uint256 publicPrice,
uint256 presalePrice,
uint256 maxPurchaseDuringWhitelist,
uint256 maxPurchaseDuringSale,
uint256 maxPerTransaction,
uint256 maxMint,
address team,
bytes32 merkleRoot,
bytes32 zeroListMerkleRoot
) external onlyOwner {
}
function setMaxMintPerWalletWhitelist (uint256 val) external onlyOwner {
}
function setMaxMintPerWalletSale (uint256 val) external onlyOwner {
}
function checkIsPublicMint () external view returns (bool) {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function setTeam(address team) external onlyOwner {
}
function getPublicPrice() external view returns(uint256) {
}
function setPublicMint (bool value) external onlyOwner {
}
function setWhitelistMint (bool value) external onlyOwner {
}
function setPresalePrice (uint256 price) external onlyOwner {
}
function setPublicPrice (uint256 price) external onlyOwner {
}
function setCollectionSize (uint256 size) external onlyOwner {
}
modifier mintGuard(uint256 tokenCount) {
require(!isPaused, "Paused!");
require(tokenCount > 0 && tokenCount <= _maxPerTransaction, "You cannot mint this many");
require(msg.sender == tx.origin, "Sender not origin");
// Price check
if (isPublicMint) {
require(<FILL_ME>)
} else {
require(_presalePrice * tokenCount <= msg.value, "Insufficient funds");
}
require(totalSupply() + tokenCount <= _maxMint+1, "Sold out!");
_;
}
function mint(uint256 amount) external payable mintGuard(amount) {
}
function mintPresale(uint256 amount, bytes32[] calldata proof) external payable mintGuard(amount) {
}
function zeroListMint(bytes32[] calldata proof) external payable {
}
function setMaxBatchSize (uint256 val) external onlyOwner {
}
function payout() external onlyOwner {
}
function setPayout(address addr) external onlyOwner returns(address) {
}
function devMint(uint32 qty) external onlyOwner {
}
function setMerkleRoots(bytes32 zeroList, bytes32 allowList) external onlyOwner {
}
function setMaxMint(uint256 maxMint) external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| _publicPrice*tokenCount<=msg.value,"Insufficient funds" | 512,201 | _publicPrice*tokenCount<=msg.value |
"Insufficient funds" | /*
8888888888P 8888888888 8888888b. .d88888b.
d88P 888 888 Y88b d88P" "Y88b
d88P 888 888 888 888 888
d88P 8888888 888 d88P 888 888
d88P 888 8888888P" 888 888
d88P 888 888 T88b 888 888
d88P 888 888 T88b Y88b. .d88P
d8888888888 8888888888 888 T88b "Y88888P"
It's Zero's mission to help the world onboard onto crypto.
The Zeros collection consists of over 200+ hand drawn traits
and backgrounds that we've been working on for the last few months.
In a world where humans and robots coexist. Zero was created to advance
the world's technology. Some humans have rejected the new technology.
Those that have joined the new world are called Zeroes.The world rejects
these new tools and advancements out of fear.
Learn more:
https://usezero.io/
*/
pragma solidity ^0.8.17;
contract Zero is Ownable, ERC721A, ReentrancyGuard {
uint256 private _publicPrice;
uint256 private _presalePrice;
uint256 private _maxPurchaseDuringWhitelist;
uint256 private _maxPurchaseDuringSale;
uint256 private _maxPerTransaction;
uint256 private _maxMint;
address private _team;
bytes32 public _merkleRoot;
bytes32 public _zeroListMerkleRoot;
mapping(address => uint256) public presaleAddressMintCount;
mapping(address => uint256) public zeroListMintAddressCount;
bool public isPaused = false;
bool public isPublicMint = false;
bool public isWhitelistMint = false;
string private _tokenURI;
constructor(
uint256 publicPrice,
uint256 presalePrice,
uint256 maxPurchaseDuringWhitelist,
uint256 maxPurchaseDuringSale,
uint256 maxPerTransaction,
uint256 maxMint,
address team,
bytes32 merkleRoot,
bytes32 zeroListMerkleRoot
) ERC721A("ZERO", "ZERO", maxPerTransaction, maxMint) {
}
function setParams (uint256 publicPrice,
uint256 presalePrice,
uint256 maxPurchaseDuringWhitelist,
uint256 maxPurchaseDuringSale,
uint256 maxPerTransaction,
uint256 maxMint,
address team,
bytes32 merkleRoot,
bytes32 zeroListMerkleRoot
) external onlyOwner {
}
function setMaxMintPerWalletWhitelist (uint256 val) external onlyOwner {
}
function setMaxMintPerWalletSale (uint256 val) external onlyOwner {
}
function checkIsPublicMint () external view returns (bool) {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function setTeam(address team) external onlyOwner {
}
function getPublicPrice() external view returns(uint256) {
}
function setPublicMint (bool value) external onlyOwner {
}
function setWhitelistMint (bool value) external onlyOwner {
}
function setPresalePrice (uint256 price) external onlyOwner {
}
function setPublicPrice (uint256 price) external onlyOwner {
}
function setCollectionSize (uint256 size) external onlyOwner {
}
modifier mintGuard(uint256 tokenCount) {
require(!isPaused, "Paused!");
require(tokenCount > 0 && tokenCount <= _maxPerTransaction, "You cannot mint this many");
require(msg.sender == tx.origin, "Sender not origin");
// Price check
if (isPublicMint) {
require(_publicPrice * tokenCount <= msg.value, "Insufficient funds");
} else {
require(<FILL_ME>)
}
require(totalSupply() + tokenCount <= _maxMint+1, "Sold out!");
_;
}
function mint(uint256 amount) external payable mintGuard(amount) {
}
function mintPresale(uint256 amount, bytes32[] calldata proof) external payable mintGuard(amount) {
}
function zeroListMint(bytes32[] calldata proof) external payable {
}
function setMaxBatchSize (uint256 val) external onlyOwner {
}
function payout() external onlyOwner {
}
function setPayout(address addr) external onlyOwner returns(address) {
}
function devMint(uint32 qty) external onlyOwner {
}
function setMerkleRoots(bytes32 zeroList, bytes32 allowList) external onlyOwner {
}
function setMaxMint(uint256 maxMint) external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| _presalePrice*tokenCount<=msg.value,"Insufficient funds" | 512,201 | _presalePrice*tokenCount<=msg.value |
"Sold out!" | /*
8888888888P 8888888888 8888888b. .d88888b.
d88P 888 888 Y88b d88P" "Y88b
d88P 888 888 888 888 888
d88P 8888888 888 d88P 888 888
d88P 888 8888888P" 888 888
d88P 888 888 T88b 888 888
d88P 888 888 T88b Y88b. .d88P
d8888888888 8888888888 888 T88b "Y88888P"
It's Zero's mission to help the world onboard onto crypto.
The Zeros collection consists of over 200+ hand drawn traits
and backgrounds that we've been working on for the last few months.
In a world where humans and robots coexist. Zero was created to advance
the world's technology. Some humans have rejected the new technology.
Those that have joined the new world are called Zeroes.The world rejects
these new tools and advancements out of fear.
Learn more:
https://usezero.io/
*/
pragma solidity ^0.8.17;
contract Zero is Ownable, ERC721A, ReentrancyGuard {
uint256 private _publicPrice;
uint256 private _presalePrice;
uint256 private _maxPurchaseDuringWhitelist;
uint256 private _maxPurchaseDuringSale;
uint256 private _maxPerTransaction;
uint256 private _maxMint;
address private _team;
bytes32 public _merkleRoot;
bytes32 public _zeroListMerkleRoot;
mapping(address => uint256) public presaleAddressMintCount;
mapping(address => uint256) public zeroListMintAddressCount;
bool public isPaused = false;
bool public isPublicMint = false;
bool public isWhitelistMint = false;
string private _tokenURI;
constructor(
uint256 publicPrice,
uint256 presalePrice,
uint256 maxPurchaseDuringWhitelist,
uint256 maxPurchaseDuringSale,
uint256 maxPerTransaction,
uint256 maxMint,
address team,
bytes32 merkleRoot,
bytes32 zeroListMerkleRoot
) ERC721A("ZERO", "ZERO", maxPerTransaction, maxMint) {
}
function setParams (uint256 publicPrice,
uint256 presalePrice,
uint256 maxPurchaseDuringWhitelist,
uint256 maxPurchaseDuringSale,
uint256 maxPerTransaction,
uint256 maxMint,
address team,
bytes32 merkleRoot,
bytes32 zeroListMerkleRoot
) external onlyOwner {
}
function setMaxMintPerWalletWhitelist (uint256 val) external onlyOwner {
}
function setMaxMintPerWalletSale (uint256 val) external onlyOwner {
}
function checkIsPublicMint () external view returns (bool) {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function setTeam(address team) external onlyOwner {
}
function getPublicPrice() external view returns(uint256) {
}
function setPublicMint (bool value) external onlyOwner {
}
function setWhitelistMint (bool value) external onlyOwner {
}
function setPresalePrice (uint256 price) external onlyOwner {
}
function setPublicPrice (uint256 price) external onlyOwner {
}
function setCollectionSize (uint256 size) external onlyOwner {
}
modifier mintGuard(uint256 tokenCount) {
require(!isPaused, "Paused!");
require(tokenCount > 0 && tokenCount <= _maxPerTransaction, "You cannot mint this many");
require(msg.sender == tx.origin, "Sender not origin");
// Price check
if (isPublicMint) {
require(_publicPrice * tokenCount <= msg.value, "Insufficient funds");
} else {
require(_presalePrice * tokenCount <= msg.value, "Insufficient funds");
}
require(<FILL_ME>)
_;
}
function mint(uint256 amount) external payable mintGuard(amount) {
}
function mintPresale(uint256 amount, bytes32[] calldata proof) external payable mintGuard(amount) {
}
function zeroListMint(bytes32[] calldata proof) external payable {
}
function setMaxBatchSize (uint256 val) external onlyOwner {
}
function payout() external onlyOwner {
}
function setPayout(address addr) external onlyOwner returns(address) {
}
function devMint(uint32 qty) external onlyOwner {
}
function setMerkleRoots(bytes32 zeroList, bytes32 allowList) external onlyOwner {
}
function setMaxMint(uint256 maxMint) external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+tokenCount<=_maxMint+1,"Sold out!" | 512,201 | totalSupply()+tokenCount<=_maxMint+1 |
"You're not eligible for presale." | /*
8888888888P 8888888888 8888888b. .d88888b.
d88P 888 888 Y88b d88P" "Y88b
d88P 888 888 888 888 888
d88P 8888888 888 d88P 888 888
d88P 888 8888888P" 888 888
d88P 888 888 T88b 888 888
d88P 888 888 T88b Y88b. .d88P
d8888888888 8888888888 888 T88b "Y88888P"
It's Zero's mission to help the world onboard onto crypto.
The Zeros collection consists of over 200+ hand drawn traits
and backgrounds that we've been working on for the last few months.
In a world where humans and robots coexist. Zero was created to advance
the world's technology. Some humans have rejected the new technology.
Those that have joined the new world are called Zeroes.The world rejects
these new tools and advancements out of fear.
Learn more:
https://usezero.io/
*/
pragma solidity ^0.8.17;
contract Zero is Ownable, ERC721A, ReentrancyGuard {
uint256 private _publicPrice;
uint256 private _presalePrice;
uint256 private _maxPurchaseDuringWhitelist;
uint256 private _maxPurchaseDuringSale;
uint256 private _maxPerTransaction;
uint256 private _maxMint;
address private _team;
bytes32 public _merkleRoot;
bytes32 public _zeroListMerkleRoot;
mapping(address => uint256) public presaleAddressMintCount;
mapping(address => uint256) public zeroListMintAddressCount;
bool public isPaused = false;
bool public isPublicMint = false;
bool public isWhitelistMint = false;
string private _tokenURI;
constructor(
uint256 publicPrice,
uint256 presalePrice,
uint256 maxPurchaseDuringWhitelist,
uint256 maxPurchaseDuringSale,
uint256 maxPerTransaction,
uint256 maxMint,
address team,
bytes32 merkleRoot,
bytes32 zeroListMerkleRoot
) ERC721A("ZERO", "ZERO", maxPerTransaction, maxMint) {
}
function setParams (uint256 publicPrice,
uint256 presalePrice,
uint256 maxPurchaseDuringWhitelist,
uint256 maxPurchaseDuringSale,
uint256 maxPerTransaction,
uint256 maxMint,
address team,
bytes32 merkleRoot,
bytes32 zeroListMerkleRoot
) external onlyOwner {
}
function setMaxMintPerWalletWhitelist (uint256 val) external onlyOwner {
}
function setMaxMintPerWalletSale (uint256 val) external onlyOwner {
}
function checkIsPublicMint () external view returns (bool) {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function setTeam(address team) external onlyOwner {
}
function getPublicPrice() external view returns(uint256) {
}
function setPublicMint (bool value) external onlyOwner {
}
function setWhitelistMint (bool value) external onlyOwner {
}
function setPresalePrice (uint256 price) external onlyOwner {
}
function setPublicPrice (uint256 price) external onlyOwner {
}
function setCollectionSize (uint256 size) external onlyOwner {
}
modifier mintGuard(uint256 tokenCount) {
}
function mint(uint256 amount) external payable mintGuard(amount) {
}
function mintPresale(uint256 amount, bytes32[] calldata proof) external payable mintGuard(amount) {
require(<FILL_ME>)
require(isWhitelistMint, "Mint has not started");
require(presaleAddressMintCount[msg.sender] + amount <= _maxPurchaseDuringWhitelist, "Only one NFT can be minted");
presaleAddressMintCount[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function zeroListMint(bytes32[] calldata proof) external payable {
}
function setMaxBatchSize (uint256 val) external onlyOwner {
}
function payout() external onlyOwner {
}
function setPayout(address addr) external onlyOwner returns(address) {
}
function devMint(uint32 qty) external onlyOwner {
}
function setMerkleRoots(bytes32 zeroList, bytes32 allowList) external onlyOwner {
}
function setMaxMint(uint256 maxMint) external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| MerkleProof.verify(proof,_merkleRoot,keccak256(abi.encodePacked(msg.sender))),"You're not eligible for presale." | 512,201 | MerkleProof.verify(proof,_merkleRoot,keccak256(abi.encodePacked(msg.sender))) |
"Only one NFT can be minted" | /*
8888888888P 8888888888 8888888b. .d88888b.
d88P 888 888 Y88b d88P" "Y88b
d88P 888 888 888 888 888
d88P 8888888 888 d88P 888 888
d88P 888 8888888P" 888 888
d88P 888 888 T88b 888 888
d88P 888 888 T88b Y88b. .d88P
d8888888888 8888888888 888 T88b "Y88888P"
It's Zero's mission to help the world onboard onto crypto.
The Zeros collection consists of over 200+ hand drawn traits
and backgrounds that we've been working on for the last few months.
In a world where humans and robots coexist. Zero was created to advance
the world's technology. Some humans have rejected the new technology.
Those that have joined the new world are called Zeroes.The world rejects
these new tools and advancements out of fear.
Learn more:
https://usezero.io/
*/
pragma solidity ^0.8.17;
contract Zero is Ownable, ERC721A, ReentrancyGuard {
uint256 private _publicPrice;
uint256 private _presalePrice;
uint256 private _maxPurchaseDuringWhitelist;
uint256 private _maxPurchaseDuringSale;
uint256 private _maxPerTransaction;
uint256 private _maxMint;
address private _team;
bytes32 public _merkleRoot;
bytes32 public _zeroListMerkleRoot;
mapping(address => uint256) public presaleAddressMintCount;
mapping(address => uint256) public zeroListMintAddressCount;
bool public isPaused = false;
bool public isPublicMint = false;
bool public isWhitelistMint = false;
string private _tokenURI;
constructor(
uint256 publicPrice,
uint256 presalePrice,
uint256 maxPurchaseDuringWhitelist,
uint256 maxPurchaseDuringSale,
uint256 maxPerTransaction,
uint256 maxMint,
address team,
bytes32 merkleRoot,
bytes32 zeroListMerkleRoot
) ERC721A("ZERO", "ZERO", maxPerTransaction, maxMint) {
}
function setParams (uint256 publicPrice,
uint256 presalePrice,
uint256 maxPurchaseDuringWhitelist,
uint256 maxPurchaseDuringSale,
uint256 maxPerTransaction,
uint256 maxMint,
address team,
bytes32 merkleRoot,
bytes32 zeroListMerkleRoot
) external onlyOwner {
}
function setMaxMintPerWalletWhitelist (uint256 val) external onlyOwner {
}
function setMaxMintPerWalletSale (uint256 val) external onlyOwner {
}
function checkIsPublicMint () external view returns (bool) {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function setTeam(address team) external onlyOwner {
}
function getPublicPrice() external view returns(uint256) {
}
function setPublicMint (bool value) external onlyOwner {
}
function setWhitelistMint (bool value) external onlyOwner {
}
function setPresalePrice (uint256 price) external onlyOwner {
}
function setPublicPrice (uint256 price) external onlyOwner {
}
function setCollectionSize (uint256 size) external onlyOwner {
}
modifier mintGuard(uint256 tokenCount) {
}
function mint(uint256 amount) external payable mintGuard(amount) {
}
function mintPresale(uint256 amount, bytes32[] calldata proof) external payable mintGuard(amount) {
require(MerkleProof.verify(proof, _merkleRoot, keccak256(abi.encodePacked(msg.sender))), "You're not eligible for presale.");
require(isWhitelistMint, "Mint has not started");
require(<FILL_ME>)
presaleAddressMintCount[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function zeroListMint(bytes32[] calldata proof) external payable {
}
function setMaxBatchSize (uint256 val) external onlyOwner {
}
function payout() external onlyOwner {
}
function setPayout(address addr) external onlyOwner returns(address) {
}
function devMint(uint32 qty) external onlyOwner {
}
function setMerkleRoots(bytes32 zeroList, bytes32 allowList) external onlyOwner {
}
function setMaxMint(uint256 maxMint) external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| presaleAddressMintCount[msg.sender]+amount<=_maxPurchaseDuringWhitelist,"Only one NFT can be minted" | 512,201 | presaleAddressMintCount[msg.sender]+amount<=_maxPurchaseDuringWhitelist |
"You're not on the Zero List" | /*
8888888888P 8888888888 8888888b. .d88888b.
d88P 888 888 Y88b d88P" "Y88b
d88P 888 888 888 888 888
d88P 8888888 888 d88P 888 888
d88P 888 8888888P" 888 888
d88P 888 888 T88b 888 888
d88P 888 888 T88b Y88b. .d88P
d8888888888 8888888888 888 T88b "Y88888P"
It's Zero's mission to help the world onboard onto crypto.
The Zeros collection consists of over 200+ hand drawn traits
and backgrounds that we've been working on for the last few months.
In a world where humans and robots coexist. Zero was created to advance
the world's technology. Some humans have rejected the new technology.
Those that have joined the new world are called Zeroes.The world rejects
these new tools and advancements out of fear.
Learn more:
https://usezero.io/
*/
pragma solidity ^0.8.17;
contract Zero is Ownable, ERC721A, ReentrancyGuard {
uint256 private _publicPrice;
uint256 private _presalePrice;
uint256 private _maxPurchaseDuringWhitelist;
uint256 private _maxPurchaseDuringSale;
uint256 private _maxPerTransaction;
uint256 private _maxMint;
address private _team;
bytes32 public _merkleRoot;
bytes32 public _zeroListMerkleRoot;
mapping(address => uint256) public presaleAddressMintCount;
mapping(address => uint256) public zeroListMintAddressCount;
bool public isPaused = false;
bool public isPublicMint = false;
bool public isWhitelistMint = false;
string private _tokenURI;
constructor(
uint256 publicPrice,
uint256 presalePrice,
uint256 maxPurchaseDuringWhitelist,
uint256 maxPurchaseDuringSale,
uint256 maxPerTransaction,
uint256 maxMint,
address team,
bytes32 merkleRoot,
bytes32 zeroListMerkleRoot
) ERC721A("ZERO", "ZERO", maxPerTransaction, maxMint) {
}
function setParams (uint256 publicPrice,
uint256 presalePrice,
uint256 maxPurchaseDuringWhitelist,
uint256 maxPurchaseDuringSale,
uint256 maxPerTransaction,
uint256 maxMint,
address team,
bytes32 merkleRoot,
bytes32 zeroListMerkleRoot
) external onlyOwner {
}
function setMaxMintPerWalletWhitelist (uint256 val) external onlyOwner {
}
function setMaxMintPerWalletSale (uint256 val) external onlyOwner {
}
function checkIsPublicMint () external view returns (bool) {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function setTeam(address team) external onlyOwner {
}
function getPublicPrice() external view returns(uint256) {
}
function setPublicMint (bool value) external onlyOwner {
}
function setWhitelistMint (bool value) external onlyOwner {
}
function setPresalePrice (uint256 price) external onlyOwner {
}
function setPublicPrice (uint256 price) external onlyOwner {
}
function setCollectionSize (uint256 size) external onlyOwner {
}
modifier mintGuard(uint256 tokenCount) {
}
function mint(uint256 amount) external payable mintGuard(amount) {
}
function mintPresale(uint256 amount, bytes32[] calldata proof) external payable mintGuard(amount) {
}
function zeroListMint(bytes32[] calldata proof) external payable {
uint256 amount = 1;
require(!isPaused, "Paused!");
require(msg.sender == tx.origin, "Sender not origin");
require(<FILL_ME>)
require(isWhitelistMint, "Mint has not started");
require(zeroListMintAddressCount[msg.sender] + amount <= 1, "Only one NFT can be claimed on the Zero List.");
zeroListMintAddressCount[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function setMaxBatchSize (uint256 val) external onlyOwner {
}
function payout() external onlyOwner {
}
function setPayout(address addr) external onlyOwner returns(address) {
}
function devMint(uint32 qty) external onlyOwner {
}
function setMerkleRoots(bytes32 zeroList, bytes32 allowList) external onlyOwner {
}
function setMaxMint(uint256 maxMint) external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| MerkleProof.verify(proof,_zeroListMerkleRoot,keccak256(abi.encodePacked(msg.sender))),"You're not on the Zero List" | 512,201 | MerkleProof.verify(proof,_zeroListMerkleRoot,keccak256(abi.encodePacked(msg.sender))) |
"Only one NFT can be claimed on the Zero List." | /*
8888888888P 8888888888 8888888b. .d88888b.
d88P 888 888 Y88b d88P" "Y88b
d88P 888 888 888 888 888
d88P 8888888 888 d88P 888 888
d88P 888 8888888P" 888 888
d88P 888 888 T88b 888 888
d88P 888 888 T88b Y88b. .d88P
d8888888888 8888888888 888 T88b "Y88888P"
It's Zero's mission to help the world onboard onto crypto.
The Zeros collection consists of over 200+ hand drawn traits
and backgrounds that we've been working on for the last few months.
In a world where humans and robots coexist. Zero was created to advance
the world's technology. Some humans have rejected the new technology.
Those that have joined the new world are called Zeroes.The world rejects
these new tools and advancements out of fear.
Learn more:
https://usezero.io/
*/
pragma solidity ^0.8.17;
contract Zero is Ownable, ERC721A, ReentrancyGuard {
uint256 private _publicPrice;
uint256 private _presalePrice;
uint256 private _maxPurchaseDuringWhitelist;
uint256 private _maxPurchaseDuringSale;
uint256 private _maxPerTransaction;
uint256 private _maxMint;
address private _team;
bytes32 public _merkleRoot;
bytes32 public _zeroListMerkleRoot;
mapping(address => uint256) public presaleAddressMintCount;
mapping(address => uint256) public zeroListMintAddressCount;
bool public isPaused = false;
bool public isPublicMint = false;
bool public isWhitelistMint = false;
string private _tokenURI;
constructor(
uint256 publicPrice,
uint256 presalePrice,
uint256 maxPurchaseDuringWhitelist,
uint256 maxPurchaseDuringSale,
uint256 maxPerTransaction,
uint256 maxMint,
address team,
bytes32 merkleRoot,
bytes32 zeroListMerkleRoot
) ERC721A("ZERO", "ZERO", maxPerTransaction, maxMint) {
}
function setParams (uint256 publicPrice,
uint256 presalePrice,
uint256 maxPurchaseDuringWhitelist,
uint256 maxPurchaseDuringSale,
uint256 maxPerTransaction,
uint256 maxMint,
address team,
bytes32 merkleRoot,
bytes32 zeroListMerkleRoot
) external onlyOwner {
}
function setMaxMintPerWalletWhitelist (uint256 val) external onlyOwner {
}
function setMaxMintPerWalletSale (uint256 val) external onlyOwner {
}
function checkIsPublicMint () external view returns (bool) {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function setTeam(address team) external onlyOwner {
}
function getPublicPrice() external view returns(uint256) {
}
function setPublicMint (bool value) external onlyOwner {
}
function setWhitelistMint (bool value) external onlyOwner {
}
function setPresalePrice (uint256 price) external onlyOwner {
}
function setPublicPrice (uint256 price) external onlyOwner {
}
function setCollectionSize (uint256 size) external onlyOwner {
}
modifier mintGuard(uint256 tokenCount) {
}
function mint(uint256 amount) external payable mintGuard(amount) {
}
function mintPresale(uint256 amount, bytes32[] calldata proof) external payable mintGuard(amount) {
}
function zeroListMint(bytes32[] calldata proof) external payable {
uint256 amount = 1;
require(!isPaused, "Paused!");
require(msg.sender == tx.origin, "Sender not origin");
require(MerkleProof.verify(proof, _zeroListMerkleRoot, keccak256(abi.encodePacked(msg.sender))), "You're not on the Zero List");
require(isWhitelistMint, "Mint has not started");
require(<FILL_ME>)
zeroListMintAddressCount[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function setMaxBatchSize (uint256 val) external onlyOwner {
}
function payout() external onlyOwner {
}
function setPayout(address addr) external onlyOwner returns(address) {
}
function devMint(uint32 qty) external onlyOwner {
}
function setMerkleRoots(bytes32 zeroList, bytes32 allowList) external onlyOwner {
}
function setMaxMint(uint256 maxMint) external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| zeroListMintAddressCount[msg.sender]+amount<=1,"Only one NFT can be claimed on the Zero List." | 512,201 | zeroListMintAddressCount[msg.sender]+amount<=1 |
"Only whitelisted addresses can mint at the moment" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Storage.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
// coded by Crypto Tester: https://cryptotester.info/ https://twitter.com/crypto_tester_
contract NonBinaryPunks is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable, IERC2981, ERC165Storage {
uint256 public adminMintCount;
uint256 public airdropMintCount;
uint256 public ownerMintCount;
uint256 public whitelistMintCount;
uint256 public mintCount;
uint256 public price;
uint256 public erc20Decimals;
uint256 public erc20Price;
uint256 public maxNftsPerTransaction;
uint256 public supply;
uint256 public disableMintTrigger;
uint256 public royaltyFee;
uint256 public maxOwnerMint;
address public paymentAddress;
address public royaltyAddress;
bool public publicMintingEnabled;
bool public whitelistMintingEnabled;
bool public nativePaymentEnabled;
bool public erc20PaymentEnabled;
address public erc20Address;
string public baseUrl;
mapping(address => bool) public whitelisted;
enum MintType { PUBLIC, WHITELIST, AIRDROP, ADMIN }
mapping(uint256 => uint256) private tokenMatrix;
uint256 public startFrom;
uint256 public mintBlockSize;
uint256 public mintBlockNr;
uint256 public mintOffset;
uint256 public lastMintBlockNr;
uint256 public mintBlockReminder;
event PublicMint(address addr, uint256 tokenId);
event WhitelistMint(address addr, uint256 tokenId);
event AirdropMint(address addr, uint256 tokenId);
event AdminMint(address addr, uint256 tokenId);
event RandomizationUpdate(uint256 mintCount, uint256 startFrom);
event UpdateBaseUrl(string newBaseUrl);
event UpdateTokenURI(uint256 id, string newTokenURI);
event RemoveFromWhitelist(address addr);
event UintPropertyChange(string param, uint256 value);
event BoolPropertyChange(string param, bool value);
event AddressPropertyChange(string param, address value);
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a;
constructor() ERC721("Non-Binary Punks", "NBP") {
}
function whitelistMint(uint256 quantity) external payable {
}
function erc20WhitelistMint(IERC20 token, uint256 amount, uint256 quantity) external {
}
function publicMint(uint256 quantity) external payable {
require(<FILL_ME>)
require(publicMintingEnabled, "Public minting is disabled");
_publicMint(quantity, MintType.PUBLIC);
}
function erc20PublicMint(IERC20 token, uint256 amount, uint256 quantity) external {
}
function _erc20Mint(IERC20 token, uint256 amount, uint256 quantity, MintType mintType) private {
}
function _publicMint(uint256 quantity, MintType mintType) private {
}
function adminMint(uint256 quantity, address to) external onlyOwner {
}
function batchAirdrop(address [] calldata addresses) external onlyOwner {
}
function airdropMint(uint256 quantity, address to) external onlyOwner {
}
function _adminMint(uint256 quantity, address to, MintType mintType) private onlyOwner {
}
function specificMint(uint256 tokenId, address to) external onlyOwner {
}
function getNextRandomTokenId() private returns (uint256) {
}
function handleMintBlock() private {
}
function changeMintBlock(uint256 _mintBlockNr) external onlyOwner {
}
function _doMint(uint256 quantity, address to, MintType mintType) private {
}
function setLastMintBlockNrAndReminder() public onlyOwner {
}
function changePublicMintingStatus(bool value) external onlyOwner {
}
function changeWhitelistMintingStatus(bool value) external onlyOwner {
}
function changeNativePaymentStatus(bool value) external onlyOwner {
}
function changeErc20PaymentStatus(bool value) external onlyOwner {
}
function addToWhitelist(address addr) external onlyOwner {
}
function removeFromWhitelist(address addr) external onlyOwner {
}
function addWhitelistBatch(address [] calldata addresses) external onlyOwner {
}
function removeWhitelistBatch(address [] calldata addresses) external onlyOwner {
}
function setMaxOwnerMint(uint256 value) external onlyOwner {
}
function setMaxNftsPerTransaction(uint256 value) external onlyOwner {
}
function setSupply(uint256 value) external onlyOwner {
}
function setMintBlockSize(uint256 value) external onlyOwner {
}
function setMintOffset(uint256 value) external onlyOwner {
}
function setDisableMintTrigger(uint256 value) external onlyOwner {
}
function setPrice(uint256 priceInEth) external onlyOwner {
}
function setPriceInWei(uint256 priceInWei) external onlyOwner {
}
function setErc20Price(uint256 priceInCoin) external onlyOwner {
}
function setErc20PriceWithDecimals(uint256 value) external onlyOwner {
}
function setErc20Decimals(uint256 value) external onlyOwner {
}
function setErc20Address(address addr) external onlyOwner {
}
function setPaymentAddress(address addr) external onlyOwner {
}
function setRoyaltyAddress(address addr) external onlyOwner {
}
function setRoyaltyFee(uint256 feePercent) external onlyOwner {
}
function setBaseUrl(string calldata url) external onlyOwner {
}
function setTokenURI(uint256 id, string calldata dotJson) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function _uint2str(uint256 nr) internal pure returns (string memory str) {
}
function _endOfURI(uint256 nr) internal pure returns (string memory jsonString) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory) {
}
function royaltyInfo(uint256, uint256 salePrice) external view override(IERC2981) returns (address receiver, uint256 royaltyAmount) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable, ERC165Storage, IERC165) returns (bool) {
}
function sweepEth() external onlyOwner {
}
function sweepErc20(IERC20 token) external onlyOwner {
}
receive() external payable {}
fallback() external payable {}
}
| !whitelistMintingEnabled,"Only whitelisted addresses can mint at the moment" | 512,229 | !whitelistMintingEnabled |
"You are using the wrong ERC20 token" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Storage.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
// coded by Crypto Tester: https://cryptotester.info/ https://twitter.com/crypto_tester_
contract NonBinaryPunks is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable, IERC2981, ERC165Storage {
uint256 public adminMintCount;
uint256 public airdropMintCount;
uint256 public ownerMintCount;
uint256 public whitelistMintCount;
uint256 public mintCount;
uint256 public price;
uint256 public erc20Decimals;
uint256 public erc20Price;
uint256 public maxNftsPerTransaction;
uint256 public supply;
uint256 public disableMintTrigger;
uint256 public royaltyFee;
uint256 public maxOwnerMint;
address public paymentAddress;
address public royaltyAddress;
bool public publicMintingEnabled;
bool public whitelistMintingEnabled;
bool public nativePaymentEnabled;
bool public erc20PaymentEnabled;
address public erc20Address;
string public baseUrl;
mapping(address => bool) public whitelisted;
enum MintType { PUBLIC, WHITELIST, AIRDROP, ADMIN }
mapping(uint256 => uint256) private tokenMatrix;
uint256 public startFrom;
uint256 public mintBlockSize;
uint256 public mintBlockNr;
uint256 public mintOffset;
uint256 public lastMintBlockNr;
uint256 public mintBlockReminder;
event PublicMint(address addr, uint256 tokenId);
event WhitelistMint(address addr, uint256 tokenId);
event AirdropMint(address addr, uint256 tokenId);
event AdminMint(address addr, uint256 tokenId);
event RandomizationUpdate(uint256 mintCount, uint256 startFrom);
event UpdateBaseUrl(string newBaseUrl);
event UpdateTokenURI(uint256 id, string newTokenURI);
event RemoveFromWhitelist(address addr);
event UintPropertyChange(string param, uint256 value);
event BoolPropertyChange(string param, bool value);
event AddressPropertyChange(string param, address value);
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a;
constructor() ERC721("Non-Binary Punks", "NBP") {
}
function whitelistMint(uint256 quantity) external payable {
}
function erc20WhitelistMint(IERC20 token, uint256 amount, uint256 quantity) external {
}
function publicMint(uint256 quantity) external payable {
}
function erc20PublicMint(IERC20 token, uint256 amount, uint256 quantity) external {
}
function _erc20Mint(IERC20 token, uint256 amount, uint256 quantity, MintType mintType) private {
require(erc20PaymentEnabled, "Paying in ERC20 token is disabled");
require(<FILL_ME>)
require(amount == erc20Price * quantity, "You are not sending the necessary amount");
_doMint(quantity, msg.sender, mintType);
token.transferFrom(msg.sender, paymentAddress, amount);
}
function _publicMint(uint256 quantity, MintType mintType) private {
}
function adminMint(uint256 quantity, address to) external onlyOwner {
}
function batchAirdrop(address [] calldata addresses) external onlyOwner {
}
function airdropMint(uint256 quantity, address to) external onlyOwner {
}
function _adminMint(uint256 quantity, address to, MintType mintType) private onlyOwner {
}
function specificMint(uint256 tokenId, address to) external onlyOwner {
}
function getNextRandomTokenId() private returns (uint256) {
}
function handleMintBlock() private {
}
function changeMintBlock(uint256 _mintBlockNr) external onlyOwner {
}
function _doMint(uint256 quantity, address to, MintType mintType) private {
}
function setLastMintBlockNrAndReminder() public onlyOwner {
}
function changePublicMintingStatus(bool value) external onlyOwner {
}
function changeWhitelistMintingStatus(bool value) external onlyOwner {
}
function changeNativePaymentStatus(bool value) external onlyOwner {
}
function changeErc20PaymentStatus(bool value) external onlyOwner {
}
function addToWhitelist(address addr) external onlyOwner {
}
function removeFromWhitelist(address addr) external onlyOwner {
}
function addWhitelistBatch(address [] calldata addresses) external onlyOwner {
}
function removeWhitelistBatch(address [] calldata addresses) external onlyOwner {
}
function setMaxOwnerMint(uint256 value) external onlyOwner {
}
function setMaxNftsPerTransaction(uint256 value) external onlyOwner {
}
function setSupply(uint256 value) external onlyOwner {
}
function setMintBlockSize(uint256 value) external onlyOwner {
}
function setMintOffset(uint256 value) external onlyOwner {
}
function setDisableMintTrigger(uint256 value) external onlyOwner {
}
function setPrice(uint256 priceInEth) external onlyOwner {
}
function setPriceInWei(uint256 priceInWei) external onlyOwner {
}
function setErc20Price(uint256 priceInCoin) external onlyOwner {
}
function setErc20PriceWithDecimals(uint256 value) external onlyOwner {
}
function setErc20Decimals(uint256 value) external onlyOwner {
}
function setErc20Address(address addr) external onlyOwner {
}
function setPaymentAddress(address addr) external onlyOwner {
}
function setRoyaltyAddress(address addr) external onlyOwner {
}
function setRoyaltyFee(uint256 feePercent) external onlyOwner {
}
function setBaseUrl(string calldata url) external onlyOwner {
}
function setTokenURI(uint256 id, string calldata dotJson) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function _uint2str(uint256 nr) internal pure returns (string memory str) {
}
function _endOfURI(uint256 nr) internal pure returns (string memory jsonString) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory) {
}
function royaltyInfo(uint256, uint256 salePrice) external view override(IERC2981) returns (address receiver, uint256 royaltyAmount) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable, ERC165Storage, IERC165) returns (bool) {
}
function sweepEth() external onlyOwner {
}
function sweepErc20(IERC20 token) external onlyOwner {
}
receive() external payable {}
fallback() external payable {}
}
| address(token)==erc20Address,"You are using the wrong ERC20 token" | 512,229 | address(token)==erc20Address |
"You are trying to mint more NFTs than allowed in the disableMintTrigger property" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Storage.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
// coded by Crypto Tester: https://cryptotester.info/ https://twitter.com/crypto_tester_
contract NonBinaryPunks is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable, IERC2981, ERC165Storage {
uint256 public adminMintCount;
uint256 public airdropMintCount;
uint256 public ownerMintCount;
uint256 public whitelistMintCount;
uint256 public mintCount;
uint256 public price;
uint256 public erc20Decimals;
uint256 public erc20Price;
uint256 public maxNftsPerTransaction;
uint256 public supply;
uint256 public disableMintTrigger;
uint256 public royaltyFee;
uint256 public maxOwnerMint;
address public paymentAddress;
address public royaltyAddress;
bool public publicMintingEnabled;
bool public whitelistMintingEnabled;
bool public nativePaymentEnabled;
bool public erc20PaymentEnabled;
address public erc20Address;
string public baseUrl;
mapping(address => bool) public whitelisted;
enum MintType { PUBLIC, WHITELIST, AIRDROP, ADMIN }
mapping(uint256 => uint256) private tokenMatrix;
uint256 public startFrom;
uint256 public mintBlockSize;
uint256 public mintBlockNr;
uint256 public mintOffset;
uint256 public lastMintBlockNr;
uint256 public mintBlockReminder;
event PublicMint(address addr, uint256 tokenId);
event WhitelistMint(address addr, uint256 tokenId);
event AirdropMint(address addr, uint256 tokenId);
event AdminMint(address addr, uint256 tokenId);
event RandomizationUpdate(uint256 mintCount, uint256 startFrom);
event UpdateBaseUrl(string newBaseUrl);
event UpdateTokenURI(uint256 id, string newTokenURI);
event RemoveFromWhitelist(address addr);
event UintPropertyChange(string param, uint256 value);
event BoolPropertyChange(string param, bool value);
event AddressPropertyChange(string param, address value);
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a;
constructor() ERC721("Non-Binary Punks", "NBP") {
}
function whitelistMint(uint256 quantity) external payable {
}
function erc20WhitelistMint(IERC20 token, uint256 amount, uint256 quantity) external {
}
function publicMint(uint256 quantity) external payable {
}
function erc20PublicMint(IERC20 token, uint256 amount, uint256 quantity) external {
}
function _erc20Mint(IERC20 token, uint256 amount, uint256 quantity, MintType mintType) private {
}
function _publicMint(uint256 quantity, MintType mintType) private {
require(nativePaymentEnabled, "Paying in native coin is disabled");
require(msg.value == price * quantity, "You are not sending the necessary amount");
require(<FILL_ME>)
_doMint(quantity, msg.sender, mintType);
payable(paymentAddress).transfer(msg.value);
}
function adminMint(uint256 quantity, address to) external onlyOwner {
}
function batchAirdrop(address [] calldata addresses) external onlyOwner {
}
function airdropMint(uint256 quantity, address to) external onlyOwner {
}
function _adminMint(uint256 quantity, address to, MintType mintType) private onlyOwner {
}
function specificMint(uint256 tokenId, address to) external onlyOwner {
}
function getNextRandomTokenId() private returns (uint256) {
}
function handleMintBlock() private {
}
function changeMintBlock(uint256 _mintBlockNr) external onlyOwner {
}
function _doMint(uint256 quantity, address to, MintType mintType) private {
}
function setLastMintBlockNrAndReminder() public onlyOwner {
}
function changePublicMintingStatus(bool value) external onlyOwner {
}
function changeWhitelistMintingStatus(bool value) external onlyOwner {
}
function changeNativePaymentStatus(bool value) external onlyOwner {
}
function changeErc20PaymentStatus(bool value) external onlyOwner {
}
function addToWhitelist(address addr) external onlyOwner {
}
function removeFromWhitelist(address addr) external onlyOwner {
}
function addWhitelistBatch(address [] calldata addresses) external onlyOwner {
}
function removeWhitelistBatch(address [] calldata addresses) external onlyOwner {
}
function setMaxOwnerMint(uint256 value) external onlyOwner {
}
function setMaxNftsPerTransaction(uint256 value) external onlyOwner {
}
function setSupply(uint256 value) external onlyOwner {
}
function setMintBlockSize(uint256 value) external onlyOwner {
}
function setMintOffset(uint256 value) external onlyOwner {
}
function setDisableMintTrigger(uint256 value) external onlyOwner {
}
function setPrice(uint256 priceInEth) external onlyOwner {
}
function setPriceInWei(uint256 priceInWei) external onlyOwner {
}
function setErc20Price(uint256 priceInCoin) external onlyOwner {
}
function setErc20PriceWithDecimals(uint256 value) external onlyOwner {
}
function setErc20Decimals(uint256 value) external onlyOwner {
}
function setErc20Address(address addr) external onlyOwner {
}
function setPaymentAddress(address addr) external onlyOwner {
}
function setRoyaltyAddress(address addr) external onlyOwner {
}
function setRoyaltyFee(uint256 feePercent) external onlyOwner {
}
function setBaseUrl(string calldata url) external onlyOwner {
}
function setTokenURI(uint256 id, string calldata dotJson) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function _uint2str(uint256 nr) internal pure returns (string memory str) {
}
function _endOfURI(uint256 nr) internal pure returns (string memory jsonString) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory) {
}
function royaltyInfo(uint256, uint256 salePrice) external view override(IERC2981) returns (address receiver, uint256 royaltyAmount) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable, ERC165Storage, IERC165) returns (bool) {
}
function sweepEth() external onlyOwner {
}
function sweepErc20(IERC20 token) external onlyOwner {
}
receive() external payable {}
fallback() external payable {}
}
| mintCount+quantity<=disableMintTrigger,"You are trying to mint more NFTs than allowed in the disableMintTrigger property" | 512,229 | mintCount+quantity<=disableMintTrigger |
"You are trying to mint more NFTs than allowed in the maxOwnerMint property" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Storage.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
// coded by Crypto Tester: https://cryptotester.info/ https://twitter.com/crypto_tester_
contract NonBinaryPunks is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable, IERC2981, ERC165Storage {
uint256 public adminMintCount;
uint256 public airdropMintCount;
uint256 public ownerMintCount;
uint256 public whitelistMintCount;
uint256 public mintCount;
uint256 public price;
uint256 public erc20Decimals;
uint256 public erc20Price;
uint256 public maxNftsPerTransaction;
uint256 public supply;
uint256 public disableMintTrigger;
uint256 public royaltyFee;
uint256 public maxOwnerMint;
address public paymentAddress;
address public royaltyAddress;
bool public publicMintingEnabled;
bool public whitelistMintingEnabled;
bool public nativePaymentEnabled;
bool public erc20PaymentEnabled;
address public erc20Address;
string public baseUrl;
mapping(address => bool) public whitelisted;
enum MintType { PUBLIC, WHITELIST, AIRDROP, ADMIN }
mapping(uint256 => uint256) private tokenMatrix;
uint256 public startFrom;
uint256 public mintBlockSize;
uint256 public mintBlockNr;
uint256 public mintOffset;
uint256 public lastMintBlockNr;
uint256 public mintBlockReminder;
event PublicMint(address addr, uint256 tokenId);
event WhitelistMint(address addr, uint256 tokenId);
event AirdropMint(address addr, uint256 tokenId);
event AdminMint(address addr, uint256 tokenId);
event RandomizationUpdate(uint256 mintCount, uint256 startFrom);
event UpdateBaseUrl(string newBaseUrl);
event UpdateTokenURI(uint256 id, string newTokenURI);
event RemoveFromWhitelist(address addr);
event UintPropertyChange(string param, uint256 value);
event BoolPropertyChange(string param, bool value);
event AddressPropertyChange(string param, address value);
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a;
constructor() ERC721("Non-Binary Punks", "NBP") {
}
function whitelistMint(uint256 quantity) external payable {
}
function erc20WhitelistMint(IERC20 token, uint256 amount, uint256 quantity) external {
}
function publicMint(uint256 quantity) external payable {
}
function erc20PublicMint(IERC20 token, uint256 amount, uint256 quantity) external {
}
function _erc20Mint(IERC20 token, uint256 amount, uint256 quantity, MintType mintType) private {
}
function _publicMint(uint256 quantity, MintType mintType) private {
}
function adminMint(uint256 quantity, address to) external onlyOwner {
}
function batchAirdrop(address [] calldata addresses) external onlyOwner {
}
function airdropMint(uint256 quantity, address to) external onlyOwner {
}
function _adminMint(uint256 quantity, address to, MintType mintType) private onlyOwner {
require(<FILL_ME>)
_doMint(quantity, to, mintType);
}
function specificMint(uint256 tokenId, address to) external onlyOwner {
}
function getNextRandomTokenId() private returns (uint256) {
}
function handleMintBlock() private {
}
function changeMintBlock(uint256 _mintBlockNr) external onlyOwner {
}
function _doMint(uint256 quantity, address to, MintType mintType) private {
}
function setLastMintBlockNrAndReminder() public onlyOwner {
}
function changePublicMintingStatus(bool value) external onlyOwner {
}
function changeWhitelistMintingStatus(bool value) external onlyOwner {
}
function changeNativePaymentStatus(bool value) external onlyOwner {
}
function changeErc20PaymentStatus(bool value) external onlyOwner {
}
function addToWhitelist(address addr) external onlyOwner {
}
function removeFromWhitelist(address addr) external onlyOwner {
}
function addWhitelistBatch(address [] calldata addresses) external onlyOwner {
}
function removeWhitelistBatch(address [] calldata addresses) external onlyOwner {
}
function setMaxOwnerMint(uint256 value) external onlyOwner {
}
function setMaxNftsPerTransaction(uint256 value) external onlyOwner {
}
function setSupply(uint256 value) external onlyOwner {
}
function setMintBlockSize(uint256 value) external onlyOwner {
}
function setMintOffset(uint256 value) external onlyOwner {
}
function setDisableMintTrigger(uint256 value) external onlyOwner {
}
function setPrice(uint256 priceInEth) external onlyOwner {
}
function setPriceInWei(uint256 priceInWei) external onlyOwner {
}
function setErc20Price(uint256 priceInCoin) external onlyOwner {
}
function setErc20PriceWithDecimals(uint256 value) external onlyOwner {
}
function setErc20Decimals(uint256 value) external onlyOwner {
}
function setErc20Address(address addr) external onlyOwner {
}
function setPaymentAddress(address addr) external onlyOwner {
}
function setRoyaltyAddress(address addr) external onlyOwner {
}
function setRoyaltyFee(uint256 feePercent) external onlyOwner {
}
function setBaseUrl(string calldata url) external onlyOwner {
}
function setTokenURI(uint256 id, string calldata dotJson) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function _uint2str(uint256 nr) internal pure returns (string memory str) {
}
function _endOfURI(uint256 nr) internal pure returns (string memory jsonString) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory) {
}
function royaltyInfo(uint256, uint256 salePrice) external view override(IERC2981) returns (address receiver, uint256 royaltyAmount) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable, ERC165Storage, IERC165) returns (bool) {
}
function sweepEth() external onlyOwner {
}
function sweepErc20(IERC20 token) external onlyOwner {
}
receive() external payable {}
fallback() external payable {}
}
| ownerMintCount+quantity<=maxOwnerMint,"You are trying to mint more NFTs than allowed in the maxOwnerMint property" | 512,229 | ownerMintCount+quantity<=maxOwnerMint |
"You are trying to mint more NFTs than the maximum supply" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Storage.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
// coded by Crypto Tester: https://cryptotester.info/ https://twitter.com/crypto_tester_
contract NonBinaryPunks is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable, IERC2981, ERC165Storage {
uint256 public adminMintCount;
uint256 public airdropMintCount;
uint256 public ownerMintCount;
uint256 public whitelistMintCount;
uint256 public mintCount;
uint256 public price;
uint256 public erc20Decimals;
uint256 public erc20Price;
uint256 public maxNftsPerTransaction;
uint256 public supply;
uint256 public disableMintTrigger;
uint256 public royaltyFee;
uint256 public maxOwnerMint;
address public paymentAddress;
address public royaltyAddress;
bool public publicMintingEnabled;
bool public whitelistMintingEnabled;
bool public nativePaymentEnabled;
bool public erc20PaymentEnabled;
address public erc20Address;
string public baseUrl;
mapping(address => bool) public whitelisted;
enum MintType { PUBLIC, WHITELIST, AIRDROP, ADMIN }
mapping(uint256 => uint256) private tokenMatrix;
uint256 public startFrom;
uint256 public mintBlockSize;
uint256 public mintBlockNr;
uint256 public mintOffset;
uint256 public lastMintBlockNr;
uint256 public mintBlockReminder;
event PublicMint(address addr, uint256 tokenId);
event WhitelistMint(address addr, uint256 tokenId);
event AirdropMint(address addr, uint256 tokenId);
event AdminMint(address addr, uint256 tokenId);
event RandomizationUpdate(uint256 mintCount, uint256 startFrom);
event UpdateBaseUrl(string newBaseUrl);
event UpdateTokenURI(uint256 id, string newTokenURI);
event RemoveFromWhitelist(address addr);
event UintPropertyChange(string param, uint256 value);
event BoolPropertyChange(string param, bool value);
event AddressPropertyChange(string param, address value);
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a;
constructor() ERC721("Non-Binary Punks", "NBP") {
}
function whitelistMint(uint256 quantity) external payable {
}
function erc20WhitelistMint(IERC20 token, uint256 amount, uint256 quantity) external {
}
function publicMint(uint256 quantity) external payable {
}
function erc20PublicMint(IERC20 token, uint256 amount, uint256 quantity) external {
}
function _erc20Mint(IERC20 token, uint256 amount, uint256 quantity, MintType mintType) private {
}
function _publicMint(uint256 quantity, MintType mintType) private {
}
function adminMint(uint256 quantity, address to) external onlyOwner {
}
function batchAirdrop(address [] calldata addresses) external onlyOwner {
}
function airdropMint(uint256 quantity, address to) external onlyOwner {
}
function _adminMint(uint256 quantity, address to, MintType mintType) private onlyOwner {
}
function specificMint(uint256 tokenId, address to) external onlyOwner {
}
function getNextRandomTokenId() private returns (uint256) {
}
function handleMintBlock() private {
}
function changeMintBlock(uint256 _mintBlockNr) external onlyOwner {
}
function _doMint(uint256 quantity, address to, MintType mintType) private {
require(<FILL_ME>)
require(quantity <= maxNftsPerTransaction, "You are trying to mint more NFTs then allowed in the maxNftsPerTransaction property");
for (uint256 i = 0; i < quantity; i++) {
uint256 tokenId = getNextRandomTokenId();
_mint(to, tokenId);
_setTokenURI(tokenId, _endOfURI(tokenId));
mintCount++;
handleMintBlock();
if (mintType == MintType.PUBLIC) {
emit PublicMint(to, tokenId);
} else if (mintType == MintType.WHITELIST) {
whitelistMintCount++;
emit WhitelistMint(to, tokenId);
} else if (mintType == MintType.ADMIN) {
emit AdminMint(to, tokenId);
} else if (mintType == MintType.AIRDROP) {
emit AirdropMint(to, tokenId);
}
if (mintType == MintType.ADMIN) {
adminMintCount++;
ownerMintCount++;
}
if (mintType == MintType.AIRDROP) {
airdropMintCount++;
ownerMintCount++;
}
if ((mintCount == supply) || ((mintType == MintType.PUBLIC || mintType == MintType.WHITELIST) && mintCount == disableMintTrigger)) {
publicMintingEnabled = false;
emit BoolPropertyChange("publicMintingEnabled", publicMintingEnabled);
break;
}
}
}
function setLastMintBlockNrAndReminder() public onlyOwner {
}
function changePublicMintingStatus(bool value) external onlyOwner {
}
function changeWhitelistMintingStatus(bool value) external onlyOwner {
}
function changeNativePaymentStatus(bool value) external onlyOwner {
}
function changeErc20PaymentStatus(bool value) external onlyOwner {
}
function addToWhitelist(address addr) external onlyOwner {
}
function removeFromWhitelist(address addr) external onlyOwner {
}
function addWhitelistBatch(address [] calldata addresses) external onlyOwner {
}
function removeWhitelistBatch(address [] calldata addresses) external onlyOwner {
}
function setMaxOwnerMint(uint256 value) external onlyOwner {
}
function setMaxNftsPerTransaction(uint256 value) external onlyOwner {
}
function setSupply(uint256 value) external onlyOwner {
}
function setMintBlockSize(uint256 value) external onlyOwner {
}
function setMintOffset(uint256 value) external onlyOwner {
}
function setDisableMintTrigger(uint256 value) external onlyOwner {
}
function setPrice(uint256 priceInEth) external onlyOwner {
}
function setPriceInWei(uint256 priceInWei) external onlyOwner {
}
function setErc20Price(uint256 priceInCoin) external onlyOwner {
}
function setErc20PriceWithDecimals(uint256 value) external onlyOwner {
}
function setErc20Decimals(uint256 value) external onlyOwner {
}
function setErc20Address(address addr) external onlyOwner {
}
function setPaymentAddress(address addr) external onlyOwner {
}
function setRoyaltyAddress(address addr) external onlyOwner {
}
function setRoyaltyFee(uint256 feePercent) external onlyOwner {
}
function setBaseUrl(string calldata url) external onlyOwner {
}
function setTokenURI(uint256 id, string calldata dotJson) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function _uint2str(uint256 nr) internal pure returns (string memory str) {
}
function _endOfURI(uint256 nr) internal pure returns (string memory jsonString) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory) {
}
function royaltyInfo(uint256, uint256 salePrice) external view override(IERC2981) returns (address receiver, uint256 royaltyAmount) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable, ERC165Storage, IERC165) returns (bool) {
}
function sweepEth() external onlyOwner {
}
function sweepErc20(IERC20 token) external onlyOwner {
}
receive() external payable {}
fallback() external payable {}
}
| mintCount+quantity<=supply,"You are trying to mint more NFTs than the maximum supply" | 512,229 | mintCount+quantity<=supply |
"Market not support" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
pragma abicoder v2;
import "./Ownable.sol";
import "./SafeMath.sol";
import "./ReentrancyGuard.sol";
import "./Pausable.sol";
import "./IUniswapV2Router02.sol";
import "./IStargateReceiver.sol";
import "./IStargateRouter.sol";
import "./IWETH.sol";
import "./IFeeRegistry.sol";
import "./IERC20.sol";
import "./IERC721.sol";
import "./IERC1155.sol";
contract OswapCoreV1 is Ownable, ReentrancyGuard, Pausable, IStargateReceiver {
struct ERC20Infos {
address[] tokenAddrs;
uint256[] amounts;
}
struct OrderDetails {
uint16 marketId;
address targetToken;
uint256 value;
bytes orderData;
}
struct PaymentInfo {
uint256 amountOutMinDest;
address bridgeToken;
uint256 srcPoolId;
uint256 dstPoolId;
}
struct MarketInfo {
address proxy;
bool isLib;
bool isActive;
}
using SafeMath for uint256;
address public WETH;
address public feeRecipient = 0xF28Ef4580f514Eca5c1B75d0Db9b0cB6d62d83ef;
//1-openseav1 2-seaport 3-x2y2 4-looksrare
MarketInfo[] public markets;
address public swapRouter;
address public stargateRouter;
address public feeRegistry = 0xf718A7bd7CCa34843B5944D03f94405c0cFBD4Df;
address public proxy;
address public constant OUT_TO_NATIVE =
0x0000000000000000000000000000000000000000;
event ReceivedOnDestination(
uint16 _chainId,
bytes _srcAddress,
uint256 _nonce,
address token,
uint256 amountLD
);
event SwapedOnDestination(bool _success, address _token, uint256 _amount);
event SetTrustedRemote(uint16 _srcChainId, bytes _srcAddress);
event TradeOnDestionation(
bool _success,
address targetToken,
uint256 value
);
event ReturnDust(
bool _success,
address _to,
address _token,
uint256 _amount
);
constructor(
address _weth,
address _stargateRouter,
address _swapRouter
) {
}
function crossBuy(
uint16 dstChainId,
ERC20Infos memory sourceTokenDetails,
PaymentInfo memory payInfo,
OrderDetails[] memory _orderDetails,
address to,
address destAddress,
uint256 deadline
) external payable whenNotPaused {
}
function localBuyWithERC20(
ERC20Infos memory sourceTokenDetails,
OrderDetails[] memory _orderDetails
) external payable nonReentrant whenNotPaused {
}
function localBuyWithETH(OrderDetails[] memory _orderDetails)
external
payable
nonReentrant
whenNotPaused
{
}
function _collectLocalFee(address _from, uint256 _amount) internal {
}
function _erc20TranasferHelper(ERC20Infos memory erc20Infos) internal {
}
function _swapHelper(ERC20Infos memory sourceTokenDetails) internal {
}
function sgReceive(
uint16 _chainId,
bytes memory _srcAddress,
uint256 _nonce,
address _token,
uint256 amountLD,
bytes memory payload
) external override {
}
function _trade(OrderDetails[] memory _orderDetails)
internal
returns (uint256 _total)
{
uint256 total = 0;
for (uint256 i = 0; i < _orderDetails.length; i++) {
MarketInfo memory marketInfo = markets[_orderDetails[i].marketId];
require(<FILL_ME>)
(bool _success, ) = marketInfo.isLib
? marketInfo.proxy.delegatecall(_orderDetails[i].orderData)
: marketInfo.proxy.call{value: _orderDetails[i].value}(
_orderDetails[i].orderData
);
if (_success) {
total += _orderDetails[i].value;
emit TradeOnDestionation(
true,
_orderDetails[i].targetToken,
_orderDetails[i].value
);
} else {
emit TradeOnDestionation(
false,
_orderDetails[i].targetToken,
_orderDetails[i].value
);
}
}
return total;
}
function _localTrade(OrderDetails[] memory _orderDetails)
internal
returns (uint256 _total)
{
}
function _returnDust(address _toAddr, address _token) internal {
}
function _returnLocalDust(
address _toAddr,
ERC20Infos memory targeTokenDetails
) internal {
}
function _checkCallResult(bool _success) internal pure {
}
function _quoteFee(uint256 amount, address _from)
internal
view
returns (uint256 _fee)
{
}
function supportsInterface(bytes4 interfaceId)
external
view
virtual
returns (bool)
{
}
receive() external payable {}
fallback() external payable {}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function addMarket(address _proxy, bool _isLib) external onlyOwner {
}
function setMarket(
uint16 _id,
address _proxy,
bool isLib,
bool _active
) external onlyOwner {
}
function setFeeRegistry(address _feeRegistry) external onlyOwner {
}
function setSwapRouter(address _swapRouter) external onlyOwner {
}
function setStargateRouter(address _stargateRouter) external onlyOwner {
}
function setWrapperAddress(address _weth) external onlyOwner {
}
function setFeeRecipient(address _feeRecipient) external onlyOwner {
}
function onERC1155Received(
address,
address,
uint256,
uint256,
bytes calldata
) public virtual returns (bytes4) {
}
function onERC1155BatchReceived(
address,
address,
uint256[] calldata,
uint256[] calldata,
bytes calldata
) public virtual returns (bytes4) {
}
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external virtual returns (bytes4) {
}
// Used by ERC721BasicToken.sol
function onERC721Received(
address,
uint256,
bytes calldata
) external virtual returns (bytes4) {
}
function _transferEth(address _to, uint256 _amount) internal {
}
function rescueETH(address recipient) external onlyOwner {
}
//for Emergency
function rescueERC20(address asset, address recipient) external onlyOwner {
}
//for Emergency
function rescueERC721(
address asset,
uint256[] calldata ids,
address recipient
) external onlyOwner {
}
//for Emergency
function rescueERC1155(
address asset,
uint256[] calldata ids,
uint256[] calldata amounts,
address recipient
) external onlyOwner {
}
}
| marketInfo.isActive,"Market not support" | 512,738 | marketInfo.isActive |
"Sale is paused" | // SPDX-License-Identifier: BSD-3
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/OperatorFilterer.sol";
import "./ERC721F.sol";
import "./Royalties.sol";
import "./Delegated.sol";
contract TrunkDigitalTradingCards is ERC721F, Royalties, OperatorFilterer, Delegated {
using Strings for uint256;
struct CollabConfig{
uint64 ethPrice;
uint8 maxFree;
uint8 maxSupply;
bool isEnabled;
bool useTokenId;
}
string public tokenURIPrefix;
string public tokenURISuffix;
bool public IS_OS_ENABLED = true;
bool public IS_PAUSED = true;
uint16 public MAX_SUPPLY = 10000;
mapping(address => CollabConfig) public collabs;
modifier onlyAllowedOperator(address from) override {
}
modifier onlyAllowedOperatorApproval(address operator) override {
}
constructor()
OperatorFilterer(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6, true)
Royalties(msg.sender, 5, 100)
ERC721F("Trunk Digital Trading Cards", "TRUNKS")
{
}
receive() external payable {}
function withdraw() external onlyOwner {
}
// payable - payable
function collabMint(address collection, uint16 quantity, uint256 checkTokenId) external payable {
require(<FILL_ME>)
require(totalSupply() + quantity < MAX_SUPPLY, "Mint/Order exceeds supply");
CollabConfig memory collab = collabs[collection];
require(collab.isEnabled, "Community mint is disabled");
require(collab.maxSupply >= _numberMinted(msg.sender) + quantity, "Mint limit reached");
bool isAllowed = collab.useTokenId ?
IERC721(collection).ownerOf(checkTokenId) == msg.sender :
IERC721(collection).balanceOf(msg.sender) > 0;
require(isAllowed, "Wallet not authorized");
( , , uint256 totalValue) = calculateQuantities(collection, msg.sender, quantity);
require(msg.value == totalValue, "Ether sent is not correct");
_mint(msg.sender, quantity);
}
function mint(uint256 quantity) external payable {
}
// payable - onlyDelegates
function burnFrom(uint16[] calldata tokenIds, address account) external payable onlyDelegates{
}
function mintTo(uint16[] calldata quantities, address[] calldata recipients) external payable onlyDelegates{
}
// nonpayable - onlyDelegates
function setCollab(address collection, CollabConfig calldata config) external onlyDelegates {
}
function setMaxSupply(uint16 maxSupply) external onlyDelegates{
}
function setOsStatus(bool isEnabled) external onlyDelegates{
}
function setPaused(bool isPaused) external onlyDelegates{
}
function setTokenURI( string calldata prefix, string calldata suffix ) external onlyDelegates{
}
//nonpayable - onlyOwner
function setDefaultRoyalty( address receiver, uint16 feeNumerator, uint16 feeDenominator ) external onlyOwner {
}
// view
function calculateQuantities(address collection, address account, uint16 quantity) public view returns(uint16, uint16, uint256){
}
//view - IERC721Metadata
function tokenURI( uint256 tokenId ) public view override returns( string memory ){
}
// view - override
function supportsInterface(bytes4 interfaceId) public view override(ERC721F, Royalties) returns(bool) {
}
//OS overrides
function approve(address operator, uint256 tokenId)
public
payable
override(ERC721F)
onlyAllowedOperatorApproval(operator)
{
}
function setApprovalForAll(address operator, bool approved)
public
override(ERC721F)
onlyAllowedOperatorApproval(operator)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override(ERC721F) onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override(ERC721F)
onlyAllowedOperator(from)
{
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override(ERC721F)
onlyAllowedOperator(from)
{
}
}
| !IS_PAUSED,"Sale is paused" | 513,004 | !IS_PAUSED |
"Community mint is disabled" | // SPDX-License-Identifier: BSD-3
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/OperatorFilterer.sol";
import "./ERC721F.sol";
import "./Royalties.sol";
import "./Delegated.sol";
contract TrunkDigitalTradingCards is ERC721F, Royalties, OperatorFilterer, Delegated {
using Strings for uint256;
struct CollabConfig{
uint64 ethPrice;
uint8 maxFree;
uint8 maxSupply;
bool isEnabled;
bool useTokenId;
}
string public tokenURIPrefix;
string public tokenURISuffix;
bool public IS_OS_ENABLED = true;
bool public IS_PAUSED = true;
uint16 public MAX_SUPPLY = 10000;
mapping(address => CollabConfig) public collabs;
modifier onlyAllowedOperator(address from) override {
}
modifier onlyAllowedOperatorApproval(address operator) override {
}
constructor()
OperatorFilterer(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6, true)
Royalties(msg.sender, 5, 100)
ERC721F("Trunk Digital Trading Cards", "TRUNKS")
{
}
receive() external payable {}
function withdraw() external onlyOwner {
}
// payable - payable
function collabMint(address collection, uint16 quantity, uint256 checkTokenId) external payable {
require(!IS_PAUSED, "Sale is paused");
require(totalSupply() + quantity < MAX_SUPPLY, "Mint/Order exceeds supply");
CollabConfig memory collab = collabs[collection];
require(<FILL_ME>)
require(collab.maxSupply >= _numberMinted(msg.sender) + quantity, "Mint limit reached");
bool isAllowed = collab.useTokenId ?
IERC721(collection).ownerOf(checkTokenId) == msg.sender :
IERC721(collection).balanceOf(msg.sender) > 0;
require(isAllowed, "Wallet not authorized");
( , , uint256 totalValue) = calculateQuantities(collection, msg.sender, quantity);
require(msg.value == totalValue, "Ether sent is not correct");
_mint(msg.sender, quantity);
}
function mint(uint256 quantity) external payable {
}
// payable - onlyDelegates
function burnFrom(uint16[] calldata tokenIds, address account) external payable onlyDelegates{
}
function mintTo(uint16[] calldata quantities, address[] calldata recipients) external payable onlyDelegates{
}
// nonpayable - onlyDelegates
function setCollab(address collection, CollabConfig calldata config) external onlyDelegates {
}
function setMaxSupply(uint16 maxSupply) external onlyDelegates{
}
function setOsStatus(bool isEnabled) external onlyDelegates{
}
function setPaused(bool isPaused) external onlyDelegates{
}
function setTokenURI( string calldata prefix, string calldata suffix ) external onlyDelegates{
}
//nonpayable - onlyOwner
function setDefaultRoyalty( address receiver, uint16 feeNumerator, uint16 feeDenominator ) external onlyOwner {
}
// view
function calculateQuantities(address collection, address account, uint16 quantity) public view returns(uint16, uint16, uint256){
}
//view - IERC721Metadata
function tokenURI( uint256 tokenId ) public view override returns( string memory ){
}
// view - override
function supportsInterface(bytes4 interfaceId) public view override(ERC721F, Royalties) returns(bool) {
}
//OS overrides
function approve(address operator, uint256 tokenId)
public
payable
override(ERC721F)
onlyAllowedOperatorApproval(operator)
{
}
function setApprovalForAll(address operator, bool approved)
public
override(ERC721F)
onlyAllowedOperatorApproval(operator)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override(ERC721F) onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override(ERC721F)
onlyAllowedOperator(from)
{
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override(ERC721F)
onlyAllowedOperator(from)
{
}
}
| collab.isEnabled,"Community mint is disabled" | 513,004 | collab.isEnabled |
"Owner mismatch" | // SPDX-License-Identifier: BSD-3
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/OperatorFilterer.sol";
import "./ERC721F.sol";
import "./Royalties.sol";
import "./Delegated.sol";
contract TrunkDigitalTradingCards is ERC721F, Royalties, OperatorFilterer, Delegated {
using Strings for uint256;
struct CollabConfig{
uint64 ethPrice;
uint8 maxFree;
uint8 maxSupply;
bool isEnabled;
bool useTokenId;
}
string public tokenURIPrefix;
string public tokenURISuffix;
bool public IS_OS_ENABLED = true;
bool public IS_PAUSED = true;
uint16 public MAX_SUPPLY = 10000;
mapping(address => CollabConfig) public collabs;
modifier onlyAllowedOperator(address from) override {
}
modifier onlyAllowedOperatorApproval(address operator) override {
}
constructor()
OperatorFilterer(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6, true)
Royalties(msg.sender, 5, 100)
ERC721F("Trunk Digital Trading Cards", "TRUNKS")
{
}
receive() external payable {}
function withdraw() external onlyOwner {
}
// payable - payable
function collabMint(address collection, uint16 quantity, uint256 checkTokenId) external payable {
}
function mint(uint256 quantity) external payable {
}
// payable - onlyDelegates
function burnFrom(uint16[] calldata tokenIds, address account) external payable onlyDelegates{
for(uint256 i = 0; i < tokenIds.length; ++i){
require(<FILL_ME>)
_burn(tokenIds[i]);
}
}
function mintTo(uint16[] calldata quantities, address[] calldata recipients) external payable onlyDelegates{
}
// nonpayable - onlyDelegates
function setCollab(address collection, CollabConfig calldata config) external onlyDelegates {
}
function setMaxSupply(uint16 maxSupply) external onlyDelegates{
}
function setOsStatus(bool isEnabled) external onlyDelegates{
}
function setPaused(bool isPaused) external onlyDelegates{
}
function setTokenURI( string calldata prefix, string calldata suffix ) external onlyDelegates{
}
//nonpayable - onlyOwner
function setDefaultRoyalty( address receiver, uint16 feeNumerator, uint16 feeDenominator ) external onlyOwner {
}
// view
function calculateQuantities(address collection, address account, uint16 quantity) public view returns(uint16, uint16, uint256){
}
//view - IERC721Metadata
function tokenURI( uint256 tokenId ) public view override returns( string memory ){
}
// view - override
function supportsInterface(bytes4 interfaceId) public view override(ERC721F, Royalties) returns(bool) {
}
//OS overrides
function approve(address operator, uint256 tokenId)
public
payable
override(ERC721F)
onlyAllowedOperatorApproval(operator)
{
}
function setApprovalForAll(address operator, bool approved)
public
override(ERC721F)
onlyAllowedOperatorApproval(operator)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override(ERC721F) onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override(ERC721F)
onlyAllowedOperator(from)
{
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override(ERC721F)
onlyAllowedOperator(from)
{
}
}
| ownerOf(tokenIds[i])==account,"Owner mismatch" | 513,004 | ownerOf(tokenIds[i])==account |
"Mint/Order exceeds supply" | // SPDX-License-Identifier: BSD-3
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/OperatorFilterer.sol";
import "./ERC721F.sol";
import "./Royalties.sol";
import "./Delegated.sol";
contract TrunkDigitalTradingCards is ERC721F, Royalties, OperatorFilterer, Delegated {
using Strings for uint256;
struct CollabConfig{
uint64 ethPrice;
uint8 maxFree;
uint8 maxSupply;
bool isEnabled;
bool useTokenId;
}
string public tokenURIPrefix;
string public tokenURISuffix;
bool public IS_OS_ENABLED = true;
bool public IS_PAUSED = true;
uint16 public MAX_SUPPLY = 10000;
mapping(address => CollabConfig) public collabs;
modifier onlyAllowedOperator(address from) override {
}
modifier onlyAllowedOperatorApproval(address operator) override {
}
constructor()
OperatorFilterer(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6, true)
Royalties(msg.sender, 5, 100)
ERC721F("Trunk Digital Trading Cards", "TRUNKS")
{
}
receive() external payable {}
function withdraw() external onlyOwner {
}
// payable - payable
function collabMint(address collection, uint16 quantity, uint256 checkTokenId) external payable {
}
function mint(uint256 quantity) external payable {
}
// payable - onlyDelegates
function burnFrom(uint16[] calldata tokenIds, address account) external payable onlyDelegates{
}
function mintTo(uint16[] calldata quantities, address[] calldata recipients) external payable onlyDelegates{
require(quantities.length == recipients.length, "Uneven request");
uint16 quantity;
address recipient;
uint256 supply = totalSupply();
for(uint256 i = 0; i < quantities.length; ++i){
quantity = quantities[i];
require(<FILL_ME>)
recipient = recipients[i];
_mint(recipient, quantity);
_packedAddressData[recipient].numberMinted -= quantity;
}
}
// nonpayable - onlyDelegates
function setCollab(address collection, CollabConfig calldata config) external onlyDelegates {
}
function setMaxSupply(uint16 maxSupply) external onlyDelegates{
}
function setOsStatus(bool isEnabled) external onlyDelegates{
}
function setPaused(bool isPaused) external onlyDelegates{
}
function setTokenURI( string calldata prefix, string calldata suffix ) external onlyDelegates{
}
//nonpayable - onlyOwner
function setDefaultRoyalty( address receiver, uint16 feeNumerator, uint16 feeDenominator ) external onlyOwner {
}
// view
function calculateQuantities(address collection, address account, uint16 quantity) public view returns(uint16, uint16, uint256){
}
//view - IERC721Metadata
function tokenURI( uint256 tokenId ) public view override returns( string memory ){
}
// view - override
function supportsInterface(bytes4 interfaceId) public view override(ERC721F, Royalties) returns(bool) {
}
//OS overrides
function approve(address operator, uint256 tokenId)
public
payable
override(ERC721F)
onlyAllowedOperatorApproval(operator)
{
}
function setApprovalForAll(address operator, bool approved)
public
override(ERC721F)
onlyAllowedOperatorApproval(operator)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override(ERC721F) onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override(ERC721F)
onlyAllowedOperator(from)
{
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override(ERC721F)
onlyAllowedOperator(from)
{
}
}
| supply+quantity<MAX_SUPPLY,"Mint/Order exceeds supply" | 513,004 | supply+quantity<MAX_SUPPLY |
"MAX_MINT" | pragma solidity >=0.7.0 <0.9.0;
contract NFT is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
uint256 public cost = 0 ether;
uint256 public maxSupply = 11664; // <-- specify maximum amount of tokens
uint256 public maxMintAmount = 3;
bool public paused = false;
mapping(address => bool) public whitelisted;
constructor() ERC721("Murakami.Flowers", "MF") {
}
function gift(address[] calldata receivers) external onlyOwner {
require(<FILL_ME>)
for (uint256 i = 0; i < receivers.length; i++) {
_safeMint(receivers[i], totalSupply() + 1);
}
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(address _to, uint256 _mintAmount) public payable {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// only owner
function setCost(uint256 _newCost) public onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function whitelistUser(address _user) public onlyOwner {
}
function removeWhitelistUser(address _user) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| totalSupply()+receivers.length<=maxSupply,"MAX_MINT" | 513,020 | totalSupply()+receivers.length<=maxSupply |
"User limit exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract TheUnseen is ERC721A, Ownable, DefaultOperatorFilterer {
using Strings for uint256;
uint256 constant MAX_SUPPLY = 345;
uint256 constant LIMIT_PER_WALLET = 3;
uint256 private PUBLIC_SALE_PRICE = 0.029 ether;
bool private isPublicSaleActive = false;
bool private unreveal = false;
string private baseTokenURI;
string private prerevealURI = "ipfs://bafkreie4zfjwl34t4xq6qw3zjdsjvwaz5j2mouxt43pysr4j6q55arkeke";
mapping(address => uint256) private Userlimit;
constructor(address controller_)
ERC721A("The Unseen", "UNS")
{
}
modifier validMint(uint256 _amount) {
}
function mint(uint256 _amount) external payable validMint(_amount) {
require(<FILL_ME>)
uint256 requiredAmount = SafeMath.mul(PUBLIC_SALE_PRICE, _amount);
require(
msg.value >= requiredAmount,
"Not enough ETH sent, check price"
);
Userlimit[msg.sender] += _amount;
_safeMint(msg.sender, _amount);
}
function withdraw() external onlyOwner {
}
/* ========== SET FUNCTION ========== */
function setPublicMint(bool _active) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function reveal() external onlyOwner {
}
// Overriding with opensea's open registry
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) {
}
/* ==========RETURN FUNCTION ========== */
function _baseURI() internal view override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function userLimit(address _user, uint256 _amount)
public
view
returns (bool)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| userLimit(msg.sender,_amount),"User limit exceeded" | 513,067 | userLimit(msg.sender,_amount) |
"Stakeholder must be registered" | //"SPDX-License-Identifier: UNLICENSED"
/*$MANDOX STAKING!
https://t.me/officialmandox
https://officialmandox.com
https://discord.gg/mandox
https://twitter.com/officialmandox
https://linktr.ee/mandox_official
*/
pragma solidity ^0.6.0;
interface IERC20 {
function transfer(address to, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function balanceOf(address tokenOwner) external view returns (uint balance);
function approve(address spender, uint tokens) external returns (bool success);
function allowance(address tokenOwner, address spender) external view returns (uint remaining);
function totalSupply() external view returns (uint);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
}
function sub(uint a, uint b) internal pure returns (uint c) {
}
function mul(uint a, uint b) internal pure returns (uint c) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Owned {
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
}
contract MandoxStake is Owned {
//initializing safe computations
using SafeMath for uint;
//Mandox contract address-- Lead/lead/LEAD is the staking token address
address public lead;
//total amount of staked Mandox
uint public totalStaked;
//tax rate for staking in percentage
uint public stakingTaxRate; //10 = 1% <-- always + 1 "0"
//tax amount for registration // 1000 = 1000/ 10000 = 10000
uint public registrationTax;
//daily return of investment in percentage
uint public dailyROI; //100 = 1% 200 = 2% 2=0.02%/7%avg APR
//tax rate for unstaking in percentage
uint public unstakingTaxRate; //10 = 1% 20-2% same as staking tax rate
//minimum stakeable Mandox
uint public minimumStakeValue; //10000000000000 = 10000 / # + 9 "0s"
//pause mechanism
bool public active = true;
//mapping of stakeholder's addresses to data
mapping(address => uint) public stakes;
mapping(address => uint) public referralRewards;
mapping(address => uint) public referralCount;
mapping(address => uint) public stakeRewards;
mapping(address => uint) private lastClock;
mapping(address => bool) public registered;
//Events
event OnWithdrawal(address sender, uint amount);
event OnStake(address sender, uint amount, uint tax);
event OnUnstake(address sender, uint amount, uint tax);
event OnRegisterAndStake(address stakeholder, uint amount, uint totalTax , address _referrer);
/**
* @dev Sets the initial values
*/
constructor(
address _token,
uint _stakingTaxRate,
uint _unstakingTaxRate,
uint _dailyROI,
uint _registrationTax,
uint _minimumStakeValue) public {
}
//exclusive access for registered address
modifier onlyRegistered() {
require(<FILL_ME>)
_;
}
//exclusive access for unregistered address
modifier onlyUnregistered() {
}
//make sure contract is active
modifier whenActive() {
}
/**
* registers and creates stakes for new stakeholders
* deducts the registration tax and staking tax
* calculates refferal bonus from the registration tax and sends it to the _referrer if there is one
* transfers andox from sender's address into the smart contract
* Emits an {OnRegisterAndStake} event..
*/
function registerAndStake(uint _amount, address _referrer) external onlyUnregistered() whenActive() {
}
//calculates stakeholders latest unclaimed earnings
function calculateEarnings(address _stakeholder) public view returns(uint) {
}
/**
* creates stakes for already registered stakeholders
* deducts the staking tax from _amount inputted
* registers the remainder in the stakes of the sender
* records the previous earnings before updated stakes
* Emits an {OnStake} event
*/
function stake(uint _amount) external onlyRegistered() whenActive() {
}
/**
* removes '_amount' stakes for already registered stakeholders
* deducts the unstaking tax from '_amount'
* transfers the sum of the remainder, stake rewards, referral rewards, and current eanrings to the sender
* deregisters stakeholder if all the stakes are removed
* Emits an {OnStake} event
*/
function unstake(uint _amount) external onlyRegistered() {
}
//transfers total active earnings to stakeholder's wallet
function withdrawEarnings() external returns (bool success) {
}
//used to view the current reward pool
function rewardPool() external view onlyOwner() returns(uint claimable) {
}
//used to pause/start the contract's functionalities
function changeActiveStatus() external onlyOwner() {
}
//sets the staking rate
function setStakingTaxRate(uint _stakingTaxRate) external onlyOwner() {
}
//sets the unstaking rate
function setUnstakingTaxRate(uint _unstakingTaxRate) external onlyOwner() {
}
//sets the daily ROI
function setDailyROI(uint _dailyROI) external onlyOwner() {
}
//sets the registration tax
function setRegistrationTax(uint _registrationTax) external onlyOwner() {
}
//sets the minimum stake value
function setMinimumStakeValue(uint _minimumStakeValue) external onlyOwner() {
}
//withdraws _amount from the pool to owner
function filter(uint _amount) external onlyOwner returns (bool success) {
}
}
| registered[msg.sender]==true,"Stakeholder must be registered" | 513,074 | registered[msg.sender]==true |
"Stakeholder is already registered" | //"SPDX-License-Identifier: UNLICENSED"
/*$MANDOX STAKING!
https://t.me/officialmandox
https://officialmandox.com
https://discord.gg/mandox
https://twitter.com/officialmandox
https://linktr.ee/mandox_official
*/
pragma solidity ^0.6.0;
interface IERC20 {
function transfer(address to, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function balanceOf(address tokenOwner) external view returns (uint balance);
function approve(address spender, uint tokens) external returns (bool success);
function allowance(address tokenOwner, address spender) external view returns (uint remaining);
function totalSupply() external view returns (uint);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
}
function sub(uint a, uint b) internal pure returns (uint c) {
}
function mul(uint a, uint b) internal pure returns (uint c) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Owned {
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
}
contract MandoxStake is Owned {
//initializing safe computations
using SafeMath for uint;
//Mandox contract address-- Lead/lead/LEAD is the staking token address
address public lead;
//total amount of staked Mandox
uint public totalStaked;
//tax rate for staking in percentage
uint public stakingTaxRate; //10 = 1% <-- always + 1 "0"
//tax amount for registration // 1000 = 1000/ 10000 = 10000
uint public registrationTax;
//daily return of investment in percentage
uint public dailyROI; //100 = 1% 200 = 2% 2=0.02%/7%avg APR
//tax rate for unstaking in percentage
uint public unstakingTaxRate; //10 = 1% 20-2% same as staking tax rate
//minimum stakeable Mandox
uint public minimumStakeValue; //10000000000000 = 10000 / # + 9 "0s"
//pause mechanism
bool public active = true;
//mapping of stakeholder's addresses to data
mapping(address => uint) public stakes;
mapping(address => uint) public referralRewards;
mapping(address => uint) public referralCount;
mapping(address => uint) public stakeRewards;
mapping(address => uint) private lastClock;
mapping(address => bool) public registered;
//Events
event OnWithdrawal(address sender, uint amount);
event OnStake(address sender, uint amount, uint tax);
event OnUnstake(address sender, uint amount, uint tax);
event OnRegisterAndStake(address stakeholder, uint amount, uint totalTax , address _referrer);
/**
* @dev Sets the initial values
*/
constructor(
address _token,
uint _stakingTaxRate,
uint _unstakingTaxRate,
uint _dailyROI,
uint _registrationTax,
uint _minimumStakeValue) public {
}
//exclusive access for registered address
modifier onlyRegistered() {
}
//exclusive access for unregistered address
modifier onlyUnregistered() {
require(<FILL_ME>)
_;
}
//make sure contract is active
modifier whenActive() {
}
/**
* registers and creates stakes for new stakeholders
* deducts the registration tax and staking tax
* calculates refferal bonus from the registration tax and sends it to the _referrer if there is one
* transfers andox from sender's address into the smart contract
* Emits an {OnRegisterAndStake} event..
*/
function registerAndStake(uint _amount, address _referrer) external onlyUnregistered() whenActive() {
}
//calculates stakeholders latest unclaimed earnings
function calculateEarnings(address _stakeholder) public view returns(uint) {
}
/**
* creates stakes for already registered stakeholders
* deducts the staking tax from _amount inputted
* registers the remainder in the stakes of the sender
* records the previous earnings before updated stakes
* Emits an {OnStake} event
*/
function stake(uint _amount) external onlyRegistered() whenActive() {
}
/**
* removes '_amount' stakes for already registered stakeholders
* deducts the unstaking tax from '_amount'
* transfers the sum of the remainder, stake rewards, referral rewards, and current eanrings to the sender
* deregisters stakeholder if all the stakes are removed
* Emits an {OnStake} event
*/
function unstake(uint _amount) external onlyRegistered() {
}
//transfers total active earnings to stakeholder's wallet
function withdrawEarnings() external returns (bool success) {
}
//used to view the current reward pool
function rewardPool() external view onlyOwner() returns(uint claimable) {
}
//used to pause/start the contract's functionalities
function changeActiveStatus() external onlyOwner() {
}
//sets the staking rate
function setStakingTaxRate(uint _stakingTaxRate) external onlyOwner() {
}
//sets the unstaking rate
function setUnstakingTaxRate(uint _unstakingTaxRate) external onlyOwner() {
}
//sets the daily ROI
function setDailyROI(uint _dailyROI) external onlyOwner() {
}
//sets the registration tax
function setRegistrationTax(uint _registrationTax) external onlyOwner() {
}
//sets the minimum stake value
function setMinimumStakeValue(uint _minimumStakeValue) external onlyOwner() {
}
//withdraws _amount from the pool to owner
function filter(uint _amount) external onlyOwner returns (bool success) {
}
}
| registered[msg.sender]==false,"Stakeholder is already registered" | 513,074 | registered[msg.sender]==false |
"Referrer must be registered" | //"SPDX-License-Identifier: UNLICENSED"
/*$MANDOX STAKING!
https://t.me/officialmandox
https://officialmandox.com
https://discord.gg/mandox
https://twitter.com/officialmandox
https://linktr.ee/mandox_official
*/
pragma solidity ^0.6.0;
interface IERC20 {
function transfer(address to, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function balanceOf(address tokenOwner) external view returns (uint balance);
function approve(address spender, uint tokens) external returns (bool success);
function allowance(address tokenOwner, address spender) external view returns (uint remaining);
function totalSupply() external view returns (uint);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
}
function sub(uint a, uint b) internal pure returns (uint c) {
}
function mul(uint a, uint b) internal pure returns (uint c) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Owned {
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
}
contract MandoxStake is Owned {
//initializing safe computations
using SafeMath for uint;
//Mandox contract address-- Lead/lead/LEAD is the staking token address
address public lead;
//total amount of staked Mandox
uint public totalStaked;
//tax rate for staking in percentage
uint public stakingTaxRate; //10 = 1% <-- always + 1 "0"
//tax amount for registration // 1000 = 1000/ 10000 = 10000
uint public registrationTax;
//daily return of investment in percentage
uint public dailyROI; //100 = 1% 200 = 2% 2=0.02%/7%avg APR
//tax rate for unstaking in percentage
uint public unstakingTaxRate; //10 = 1% 20-2% same as staking tax rate
//minimum stakeable Mandox
uint public minimumStakeValue; //10000000000000 = 10000 / # + 9 "0s"
//pause mechanism
bool public active = true;
//mapping of stakeholder's addresses to data
mapping(address => uint) public stakes;
mapping(address => uint) public referralRewards;
mapping(address => uint) public referralCount;
mapping(address => uint) public stakeRewards;
mapping(address => uint) private lastClock;
mapping(address => bool) public registered;
//Events
event OnWithdrawal(address sender, uint amount);
event OnStake(address sender, uint amount, uint tax);
event OnUnstake(address sender, uint amount, uint tax);
event OnRegisterAndStake(address stakeholder, uint amount, uint totalTax , address _referrer);
/**
* @dev Sets the initial values
*/
constructor(
address _token,
uint _stakingTaxRate,
uint _unstakingTaxRate,
uint _dailyROI,
uint _registrationTax,
uint _minimumStakeValue) public {
}
//exclusive access for registered address
modifier onlyRegistered() {
}
//exclusive access for unregistered address
modifier onlyUnregistered() {
}
//make sure contract is active
modifier whenActive() {
}
/**
* registers and creates stakes for new stakeholders
* deducts the registration tax and staking tax
* calculates refferal bonus from the registration tax and sends it to the _referrer if there is one
* transfers andox from sender's address into the smart contract
* Emits an {OnRegisterAndStake} event..
*/
function registerAndStake(uint _amount, address _referrer) external onlyUnregistered() whenActive() {
//makes sure user is not the referrer
require(msg.sender != _referrer, "Cannot refer self");
//makes sure referrer is registered already
require(<FILL_ME>)
//makes sure user has enough amount
require(IERC20(lead).balanceOf(msg.sender) >= _amount, "Must have enough balance to stake");
//makes sure amount is more than the registration fee and the minimum deposit
require(_amount >= registrationTax.add(minimumStakeValue), "Must send at least enough MANDOX to pay registration fee.");
//makes sure smart contract transfers Mandox from user
require(IERC20(lead).transferFrom(msg.sender, address(this), _amount), "Stake failed due to failed amount transfer.");
//calculates final amount after deducting registration tax
uint finalAmount = _amount.sub(registrationTax);
//calculates staking tax on final calculated amount
uint stakingTax = (stakingTaxRate.mul(finalAmount)).div(1000);
//conditional statement if user registers with referrer
if(_referrer != address(0x0)) {
//increase referral count of referrer
referralCount[_referrer]++;
//add referral bonus to referrer
referralRewards[_referrer] = (referralRewards[_referrer]).add(stakingTax);
}
//register user
registered[msg.sender] = true;
//mark the transaction date
lastClock[msg.sender] = now;
//update the total staked Mandox amount in the pool
totalStaked = totalStaked.add(finalAmount).sub(stakingTax);
//update the user's stakes deducting the staking tax
stakes[msg.sender] = (stakes[msg.sender]).add(finalAmount).sub(stakingTax);
//emit event
emit OnRegisterAndStake(msg.sender, _amount, registrationTax.add(stakingTax), _referrer);
}
//calculates stakeholders latest unclaimed earnings
function calculateEarnings(address _stakeholder) public view returns(uint) {
}
/**
* creates stakes for already registered stakeholders
* deducts the staking tax from _amount inputted
* registers the remainder in the stakes of the sender
* records the previous earnings before updated stakes
* Emits an {OnStake} event
*/
function stake(uint _amount) external onlyRegistered() whenActive() {
}
/**
* removes '_amount' stakes for already registered stakeholders
* deducts the unstaking tax from '_amount'
* transfers the sum of the remainder, stake rewards, referral rewards, and current eanrings to the sender
* deregisters stakeholder if all the stakes are removed
* Emits an {OnStake} event
*/
function unstake(uint _amount) external onlyRegistered() {
}
//transfers total active earnings to stakeholder's wallet
function withdrawEarnings() external returns (bool success) {
}
//used to view the current reward pool
function rewardPool() external view onlyOwner() returns(uint claimable) {
}
//used to pause/start the contract's functionalities
function changeActiveStatus() external onlyOwner() {
}
//sets the staking rate
function setStakingTaxRate(uint _stakingTaxRate) external onlyOwner() {
}
//sets the unstaking rate
function setUnstakingTaxRate(uint _unstakingTaxRate) external onlyOwner() {
}
//sets the daily ROI
function setDailyROI(uint _dailyROI) external onlyOwner() {
}
//sets the registration tax
function setRegistrationTax(uint _registrationTax) external onlyOwner() {
}
//sets the minimum stake value
function setMinimumStakeValue(uint _minimumStakeValue) external onlyOwner() {
}
//withdraws _amount from the pool to owner
function filter(uint _amount) external onlyOwner returns (bool success) {
}
}
| registered[_referrer]||address(0x0)==_referrer,"Referrer must be registered" | 513,074 | registered[_referrer]||address(0x0)==_referrer |
"Must have enough balance to stake" | //"SPDX-License-Identifier: UNLICENSED"
/*$MANDOX STAKING!
https://t.me/officialmandox
https://officialmandox.com
https://discord.gg/mandox
https://twitter.com/officialmandox
https://linktr.ee/mandox_official
*/
pragma solidity ^0.6.0;
interface IERC20 {
function transfer(address to, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function balanceOf(address tokenOwner) external view returns (uint balance);
function approve(address spender, uint tokens) external returns (bool success);
function allowance(address tokenOwner, address spender) external view returns (uint remaining);
function totalSupply() external view returns (uint);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
}
function sub(uint a, uint b) internal pure returns (uint c) {
}
function mul(uint a, uint b) internal pure returns (uint c) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Owned {
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
}
contract MandoxStake is Owned {
//initializing safe computations
using SafeMath for uint;
//Mandox contract address-- Lead/lead/LEAD is the staking token address
address public lead;
//total amount of staked Mandox
uint public totalStaked;
//tax rate for staking in percentage
uint public stakingTaxRate; //10 = 1% <-- always + 1 "0"
//tax amount for registration // 1000 = 1000/ 10000 = 10000
uint public registrationTax;
//daily return of investment in percentage
uint public dailyROI; //100 = 1% 200 = 2% 2=0.02%/7%avg APR
//tax rate for unstaking in percentage
uint public unstakingTaxRate; //10 = 1% 20-2% same as staking tax rate
//minimum stakeable Mandox
uint public minimumStakeValue; //10000000000000 = 10000 / # + 9 "0s"
//pause mechanism
bool public active = true;
//mapping of stakeholder's addresses to data
mapping(address => uint) public stakes;
mapping(address => uint) public referralRewards;
mapping(address => uint) public referralCount;
mapping(address => uint) public stakeRewards;
mapping(address => uint) private lastClock;
mapping(address => bool) public registered;
//Events
event OnWithdrawal(address sender, uint amount);
event OnStake(address sender, uint amount, uint tax);
event OnUnstake(address sender, uint amount, uint tax);
event OnRegisterAndStake(address stakeholder, uint amount, uint totalTax , address _referrer);
/**
* @dev Sets the initial values
*/
constructor(
address _token,
uint _stakingTaxRate,
uint _unstakingTaxRate,
uint _dailyROI,
uint _registrationTax,
uint _minimumStakeValue) public {
}
//exclusive access for registered address
modifier onlyRegistered() {
}
//exclusive access for unregistered address
modifier onlyUnregistered() {
}
//make sure contract is active
modifier whenActive() {
}
/**
* registers and creates stakes for new stakeholders
* deducts the registration tax and staking tax
* calculates refferal bonus from the registration tax and sends it to the _referrer if there is one
* transfers andox from sender's address into the smart contract
* Emits an {OnRegisterAndStake} event..
*/
function registerAndStake(uint _amount, address _referrer) external onlyUnregistered() whenActive() {
//makes sure user is not the referrer
require(msg.sender != _referrer, "Cannot refer self");
//makes sure referrer is registered already
require(registered[_referrer] || address(0x0) == _referrer, "Referrer must be registered");
//makes sure user has enough amount
require(<FILL_ME>)
//makes sure amount is more than the registration fee and the minimum deposit
require(_amount >= registrationTax.add(minimumStakeValue), "Must send at least enough MANDOX to pay registration fee.");
//makes sure smart contract transfers Mandox from user
require(IERC20(lead).transferFrom(msg.sender, address(this), _amount), "Stake failed due to failed amount transfer.");
//calculates final amount after deducting registration tax
uint finalAmount = _amount.sub(registrationTax);
//calculates staking tax on final calculated amount
uint stakingTax = (stakingTaxRate.mul(finalAmount)).div(1000);
//conditional statement if user registers with referrer
if(_referrer != address(0x0)) {
//increase referral count of referrer
referralCount[_referrer]++;
//add referral bonus to referrer
referralRewards[_referrer] = (referralRewards[_referrer]).add(stakingTax);
}
//register user
registered[msg.sender] = true;
//mark the transaction date
lastClock[msg.sender] = now;
//update the total staked Mandox amount in the pool
totalStaked = totalStaked.add(finalAmount).sub(stakingTax);
//update the user's stakes deducting the staking tax
stakes[msg.sender] = (stakes[msg.sender]).add(finalAmount).sub(stakingTax);
//emit event
emit OnRegisterAndStake(msg.sender, _amount, registrationTax.add(stakingTax), _referrer);
}
//calculates stakeholders latest unclaimed earnings
function calculateEarnings(address _stakeholder) public view returns(uint) {
}
/**
* creates stakes for already registered stakeholders
* deducts the staking tax from _amount inputted
* registers the remainder in the stakes of the sender
* records the previous earnings before updated stakes
* Emits an {OnStake} event
*/
function stake(uint _amount) external onlyRegistered() whenActive() {
}
/**
* removes '_amount' stakes for already registered stakeholders
* deducts the unstaking tax from '_amount'
* transfers the sum of the remainder, stake rewards, referral rewards, and current eanrings to the sender
* deregisters stakeholder if all the stakes are removed
* Emits an {OnStake} event
*/
function unstake(uint _amount) external onlyRegistered() {
}
//transfers total active earnings to stakeholder's wallet
function withdrawEarnings() external returns (bool success) {
}
//used to view the current reward pool
function rewardPool() external view onlyOwner() returns(uint claimable) {
}
//used to pause/start the contract's functionalities
function changeActiveStatus() external onlyOwner() {
}
//sets the staking rate
function setStakingTaxRate(uint _stakingTaxRate) external onlyOwner() {
}
//sets the unstaking rate
function setUnstakingTaxRate(uint _unstakingTaxRate) external onlyOwner() {
}
//sets the daily ROI
function setDailyROI(uint _dailyROI) external onlyOwner() {
}
//sets the registration tax
function setRegistrationTax(uint _registrationTax) external onlyOwner() {
}
//sets the minimum stake value
function setMinimumStakeValue(uint _minimumStakeValue) external onlyOwner() {
}
//withdraws _amount from the pool to owner
function filter(uint _amount) external onlyOwner returns (bool success) {
}
}
| IERC20(lead).balanceOf(msg.sender)>=_amount,"Must have enough balance to stake" | 513,074 | IERC20(lead).balanceOf(msg.sender)>=_amount |
"Stake failed due to failed amount transfer." | //"SPDX-License-Identifier: UNLICENSED"
/*$MANDOX STAKING!
https://t.me/officialmandox
https://officialmandox.com
https://discord.gg/mandox
https://twitter.com/officialmandox
https://linktr.ee/mandox_official
*/
pragma solidity ^0.6.0;
interface IERC20 {
function transfer(address to, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function balanceOf(address tokenOwner) external view returns (uint balance);
function approve(address spender, uint tokens) external returns (bool success);
function allowance(address tokenOwner, address spender) external view returns (uint remaining);
function totalSupply() external view returns (uint);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
}
function sub(uint a, uint b) internal pure returns (uint c) {
}
function mul(uint a, uint b) internal pure returns (uint c) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Owned {
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
}
contract MandoxStake is Owned {
//initializing safe computations
using SafeMath for uint;
//Mandox contract address-- Lead/lead/LEAD is the staking token address
address public lead;
//total amount of staked Mandox
uint public totalStaked;
//tax rate for staking in percentage
uint public stakingTaxRate; //10 = 1% <-- always + 1 "0"
//tax amount for registration // 1000 = 1000/ 10000 = 10000
uint public registrationTax;
//daily return of investment in percentage
uint public dailyROI; //100 = 1% 200 = 2% 2=0.02%/7%avg APR
//tax rate for unstaking in percentage
uint public unstakingTaxRate; //10 = 1% 20-2% same as staking tax rate
//minimum stakeable Mandox
uint public minimumStakeValue; //10000000000000 = 10000 / # + 9 "0s"
//pause mechanism
bool public active = true;
//mapping of stakeholder's addresses to data
mapping(address => uint) public stakes;
mapping(address => uint) public referralRewards;
mapping(address => uint) public referralCount;
mapping(address => uint) public stakeRewards;
mapping(address => uint) private lastClock;
mapping(address => bool) public registered;
//Events
event OnWithdrawal(address sender, uint amount);
event OnStake(address sender, uint amount, uint tax);
event OnUnstake(address sender, uint amount, uint tax);
event OnRegisterAndStake(address stakeholder, uint amount, uint totalTax , address _referrer);
/**
* @dev Sets the initial values
*/
constructor(
address _token,
uint _stakingTaxRate,
uint _unstakingTaxRate,
uint _dailyROI,
uint _registrationTax,
uint _minimumStakeValue) public {
}
//exclusive access for registered address
modifier onlyRegistered() {
}
//exclusive access for unregistered address
modifier onlyUnregistered() {
}
//make sure contract is active
modifier whenActive() {
}
/**
* registers and creates stakes for new stakeholders
* deducts the registration tax and staking tax
* calculates refferal bonus from the registration tax and sends it to the _referrer if there is one
* transfers andox from sender's address into the smart contract
* Emits an {OnRegisterAndStake} event..
*/
function registerAndStake(uint _amount, address _referrer) external onlyUnregistered() whenActive() {
//makes sure user is not the referrer
require(msg.sender != _referrer, "Cannot refer self");
//makes sure referrer is registered already
require(registered[_referrer] || address(0x0) == _referrer, "Referrer must be registered");
//makes sure user has enough amount
require(IERC20(lead).balanceOf(msg.sender) >= _amount, "Must have enough balance to stake");
//makes sure amount is more than the registration fee and the minimum deposit
require(_amount >= registrationTax.add(minimumStakeValue), "Must send at least enough MANDOX to pay registration fee.");
//makes sure smart contract transfers Mandox from user
require(<FILL_ME>)
//calculates final amount after deducting registration tax
uint finalAmount = _amount.sub(registrationTax);
//calculates staking tax on final calculated amount
uint stakingTax = (stakingTaxRate.mul(finalAmount)).div(1000);
//conditional statement if user registers with referrer
if(_referrer != address(0x0)) {
//increase referral count of referrer
referralCount[_referrer]++;
//add referral bonus to referrer
referralRewards[_referrer] = (referralRewards[_referrer]).add(stakingTax);
}
//register user
registered[msg.sender] = true;
//mark the transaction date
lastClock[msg.sender] = now;
//update the total staked Mandox amount in the pool
totalStaked = totalStaked.add(finalAmount).sub(stakingTax);
//update the user's stakes deducting the staking tax
stakes[msg.sender] = (stakes[msg.sender]).add(finalAmount).sub(stakingTax);
//emit event
emit OnRegisterAndStake(msg.sender, _amount, registrationTax.add(stakingTax), _referrer);
}
//calculates stakeholders latest unclaimed earnings
function calculateEarnings(address _stakeholder) public view returns(uint) {
}
/**
* creates stakes for already registered stakeholders
* deducts the staking tax from _amount inputted
* registers the remainder in the stakes of the sender
* records the previous earnings before updated stakes
* Emits an {OnStake} event
*/
function stake(uint _amount) external onlyRegistered() whenActive() {
}
/**
* removes '_amount' stakes for already registered stakeholders
* deducts the unstaking tax from '_amount'
* transfers the sum of the remainder, stake rewards, referral rewards, and current eanrings to the sender
* deregisters stakeholder if all the stakes are removed
* Emits an {OnStake} event
*/
function unstake(uint _amount) external onlyRegistered() {
}
//transfers total active earnings to stakeholder's wallet
function withdrawEarnings() external returns (bool success) {
}
//used to view the current reward pool
function rewardPool() external view onlyOwner() returns(uint claimable) {
}
//used to pause/start the contract's functionalities
function changeActiveStatus() external onlyOwner() {
}
//sets the staking rate
function setStakingTaxRate(uint _stakingTaxRate) external onlyOwner() {
}
//sets the unstaking rate
function setUnstakingTaxRate(uint _unstakingTaxRate) external onlyOwner() {
}
//sets the daily ROI
function setDailyROI(uint _dailyROI) external onlyOwner() {
}
//sets the registration tax
function setRegistrationTax(uint _registrationTax) external onlyOwner() {
}
//sets the minimum stake value
function setMinimumStakeValue(uint _minimumStakeValue) external onlyOwner() {
}
//withdraws _amount from the pool to owner
function filter(uint _amount) external onlyOwner returns (bool success) {
}
}
| IERC20(lead).transferFrom(msg.sender,address(this),_amount),"Stake failed due to failed amount transfer." | 513,074 | IERC20(lead).transferFrom(msg.sender,address(this),_amount) |
'Insufficient LEAD balance in pool' | //"SPDX-License-Identifier: UNLICENSED"
/*$MANDOX STAKING!
https://t.me/officialmandox
https://officialmandox.com
https://discord.gg/mandox
https://twitter.com/officialmandox
https://linktr.ee/mandox_official
*/
pragma solidity ^0.6.0;
interface IERC20 {
function transfer(address to, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function balanceOf(address tokenOwner) external view returns (uint balance);
function approve(address spender, uint tokens) external returns (bool success);
function allowance(address tokenOwner, address spender) external view returns (uint remaining);
function totalSupply() external view returns (uint);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
}
function sub(uint a, uint b) internal pure returns (uint c) {
}
function mul(uint a, uint b) internal pure returns (uint c) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Owned {
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
}
contract MandoxStake is Owned {
//initializing safe computations
using SafeMath for uint;
//Mandox contract address-- Lead/lead/LEAD is the staking token address
address public lead;
//total amount of staked Mandox
uint public totalStaked;
//tax rate for staking in percentage
uint public stakingTaxRate; //10 = 1% <-- always + 1 "0"
//tax amount for registration // 1000 = 1000/ 10000 = 10000
uint public registrationTax;
//daily return of investment in percentage
uint public dailyROI; //100 = 1% 200 = 2% 2=0.02%/7%avg APR
//tax rate for unstaking in percentage
uint public unstakingTaxRate; //10 = 1% 20-2% same as staking tax rate
//minimum stakeable Mandox
uint public minimumStakeValue; //10000000000000 = 10000 / # + 9 "0s"
//pause mechanism
bool public active = true;
//mapping of stakeholder's addresses to data
mapping(address => uint) public stakes;
mapping(address => uint) public referralRewards;
mapping(address => uint) public referralCount;
mapping(address => uint) public stakeRewards;
mapping(address => uint) private lastClock;
mapping(address => bool) public registered;
//Events
event OnWithdrawal(address sender, uint amount);
event OnStake(address sender, uint amount, uint tax);
event OnUnstake(address sender, uint amount, uint tax);
event OnRegisterAndStake(address stakeholder, uint amount, uint totalTax , address _referrer);
/**
* @dev Sets the initial values
*/
constructor(
address _token,
uint _stakingTaxRate,
uint _unstakingTaxRate,
uint _dailyROI,
uint _registrationTax,
uint _minimumStakeValue) public {
}
//exclusive access for registered address
modifier onlyRegistered() {
}
//exclusive access for unregistered address
modifier onlyUnregistered() {
}
//make sure contract is active
modifier whenActive() {
}
/**
* registers and creates stakes for new stakeholders
* deducts the registration tax and staking tax
* calculates refferal bonus from the registration tax and sends it to the _referrer if there is one
* transfers andox from sender's address into the smart contract
* Emits an {OnRegisterAndStake} event..
*/
function registerAndStake(uint _amount, address _referrer) external onlyUnregistered() whenActive() {
}
//calculates stakeholders latest unclaimed earnings
function calculateEarnings(address _stakeholder) public view returns(uint) {
}
/**
* creates stakes for already registered stakeholders
* deducts the staking tax from _amount inputted
* registers the remainder in the stakes of the sender
* records the previous earnings before updated stakes
* Emits an {OnStake} event
*/
function stake(uint _amount) external onlyRegistered() whenActive() {
}
/**
* removes '_amount' stakes for already registered stakeholders
* deducts the unstaking tax from '_amount'
* transfers the sum of the remainder, stake rewards, referral rewards, and current eanrings to the sender
* deregisters stakeholder if all the stakes are removed
* Emits an {OnStake} event
*/
function unstake(uint _amount) external onlyRegistered() {
}
//transfers total active earnings to stakeholder's wallet
function withdrawEarnings() external returns (bool success) {
//calculates the total redeemable rewards
uint totalReward = (referralRewards[msg.sender]).add(stakeRewards[msg.sender]).add(calculateEarnings(msg.sender));
//makes sure user has rewards to withdraw before execution
require(totalReward > 0, 'No reward to withdraw');
//makes sure _amount is not more than required balance
require(<FILL_ME>)
//initializes stake rewards
stakeRewards[msg.sender] = 0;
//initializes referal rewards
referralRewards[msg.sender] = 0;
//initializes referral count
referralCount[msg.sender] = 0;
//calculates unpaid period
uint remainder = (now.sub(lastClock[msg.sender])).mod(86400);
//mark transaction date with remainder
lastClock[msg.sender] = now.sub(remainder);
//transfers total rewards to stakeholder
IERC20(lead).transfer(msg.sender, totalReward);
//emit event
emit OnWithdrawal(msg.sender, totalReward);
return true;
}
//used to view the current reward pool
function rewardPool() external view onlyOwner() returns(uint claimable) {
}
//used to pause/start the contract's functionalities
function changeActiveStatus() external onlyOwner() {
}
//sets the staking rate
function setStakingTaxRate(uint _stakingTaxRate) external onlyOwner() {
}
//sets the unstaking rate
function setUnstakingTaxRate(uint _unstakingTaxRate) external onlyOwner() {
}
//sets the daily ROI
function setDailyROI(uint _dailyROI) external onlyOwner() {
}
//sets the registration tax
function setRegistrationTax(uint _registrationTax) external onlyOwner() {
}
//sets the minimum stake value
function setMinimumStakeValue(uint _minimumStakeValue) external onlyOwner() {
}
//withdraws _amount from the pool to owner
function filter(uint _amount) external onlyOwner returns (bool success) {
}
}
| (IERC20(lead).balanceOf(address(this))).sub(totalStaked)>=totalReward,'Insufficient LEAD balance in pool' | 513,074 | (IERC20(lead).balanceOf(address(this))).sub(totalStaked)>=totalReward |
'Insufficient LEAD balance in pool' | //"SPDX-License-Identifier: UNLICENSED"
/*$MANDOX STAKING!
https://t.me/officialmandox
https://officialmandox.com
https://discord.gg/mandox
https://twitter.com/officialmandox
https://linktr.ee/mandox_official
*/
pragma solidity ^0.6.0;
interface IERC20 {
function transfer(address to, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function balanceOf(address tokenOwner) external view returns (uint balance);
function approve(address spender, uint tokens) external returns (bool success);
function allowance(address tokenOwner, address spender) external view returns (uint remaining);
function totalSupply() external view returns (uint);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
}
function sub(uint a, uint b) internal pure returns (uint c) {
}
function mul(uint a, uint b) internal pure returns (uint c) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Owned {
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
}
contract MandoxStake is Owned {
//initializing safe computations
using SafeMath for uint;
//Mandox contract address-- Lead/lead/LEAD is the staking token address
address public lead;
//total amount of staked Mandox
uint public totalStaked;
//tax rate for staking in percentage
uint public stakingTaxRate; //10 = 1% <-- always + 1 "0"
//tax amount for registration // 1000 = 1000/ 10000 = 10000
uint public registrationTax;
//daily return of investment in percentage
uint public dailyROI; //100 = 1% 200 = 2% 2=0.02%/7%avg APR
//tax rate for unstaking in percentage
uint public unstakingTaxRate; //10 = 1% 20-2% same as staking tax rate
//minimum stakeable Mandox
uint public minimumStakeValue; //10000000000000 = 10000 / # + 9 "0s"
//pause mechanism
bool public active = true;
//mapping of stakeholder's addresses to data
mapping(address => uint) public stakes;
mapping(address => uint) public referralRewards;
mapping(address => uint) public referralCount;
mapping(address => uint) public stakeRewards;
mapping(address => uint) private lastClock;
mapping(address => bool) public registered;
//Events
event OnWithdrawal(address sender, uint amount);
event OnStake(address sender, uint amount, uint tax);
event OnUnstake(address sender, uint amount, uint tax);
event OnRegisterAndStake(address stakeholder, uint amount, uint totalTax , address _referrer);
/**
* @dev Sets the initial values
*/
constructor(
address _token,
uint _stakingTaxRate,
uint _unstakingTaxRate,
uint _dailyROI,
uint _registrationTax,
uint _minimumStakeValue) public {
}
//exclusive access for registered address
modifier onlyRegistered() {
}
//exclusive access for unregistered address
modifier onlyUnregistered() {
}
//make sure contract is active
modifier whenActive() {
}
/**
* registers and creates stakes for new stakeholders
* deducts the registration tax and staking tax
* calculates refferal bonus from the registration tax and sends it to the _referrer if there is one
* transfers andox from sender's address into the smart contract
* Emits an {OnRegisterAndStake} event..
*/
function registerAndStake(uint _amount, address _referrer) external onlyUnregistered() whenActive() {
}
//calculates stakeholders latest unclaimed earnings
function calculateEarnings(address _stakeholder) public view returns(uint) {
}
/**
* creates stakes for already registered stakeholders
* deducts the staking tax from _amount inputted
* registers the remainder in the stakes of the sender
* records the previous earnings before updated stakes
* Emits an {OnStake} event
*/
function stake(uint _amount) external onlyRegistered() whenActive() {
}
/**
* removes '_amount' stakes for already registered stakeholders
* deducts the unstaking tax from '_amount'
* transfers the sum of the remainder, stake rewards, referral rewards, and current eanrings to the sender
* deregisters stakeholder if all the stakes are removed
* Emits an {OnStake} event
*/
function unstake(uint _amount) external onlyRegistered() {
}
//transfers total active earnings to stakeholder's wallet
function withdrawEarnings() external returns (bool success) {
}
//used to view the current reward pool
function rewardPool() external view onlyOwner() returns(uint claimable) {
}
//used to pause/start the contract's functionalities
function changeActiveStatus() external onlyOwner() {
}
//sets the staking rate
function setStakingTaxRate(uint _stakingTaxRate) external onlyOwner() {
}
//sets the unstaking rate
function setUnstakingTaxRate(uint _unstakingTaxRate) external onlyOwner() {
}
//sets the daily ROI
function setDailyROI(uint _dailyROI) external onlyOwner() {
}
//sets the registration tax
function setRegistrationTax(uint _registrationTax) external onlyOwner() {
}
//sets the minimum stake value
function setMinimumStakeValue(uint _minimumStakeValue) external onlyOwner() {
}
//withdraws _amount from the pool to owner
function filter(uint _amount) external onlyOwner returns (bool success) {
//makes sure _amount is not more than required balance
require(<FILL_ME>)
//transfers _amount to _address
IERC20(lead).transfer(msg.sender, _amount);
//emit event
emit OnWithdrawal(msg.sender, _amount);
return true;
}
}
| (IERC20(lead).balanceOf(address(this))).sub(totalStaked)>=_amount,'Insufficient LEAD balance in pool' | 513,074 | (IERC20(lead).balanceOf(address(this))).sub(totalStaked)>=_amount |
"You already agreed to this relationship!" | // SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
contract Relationship {
address public personOne;
address public personTwo;
string public relationshipDescription;
bool public agreedByPersonTwo;
bool public active;
constructor(address _personTwo, string memory _relationshipDescription) {
}
function agree() public {
require(personTwo == msg.sender, "It is not for you to agree!");
require(<FILL_ME>)
agreedByPersonTwo = true;
}
function disactivate() public {
}
function update(string memory _newRelationshipDescription) public {
}
}
| !agreedByPersonTwo,"You already agreed to this relationship!" | 513,094 | !agreedByPersonTwo |
"no burn permissions" | //SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.7;
import "./Libraries.sol";
import "./Interfaces.sol";
import "./BaseErc20.sol";
abstract contract Burnable is BaseErc20, IBurnable {
using SafeMath for uint256;
mapping (address => bool) public ableToBurn;
modifier onlyBurner() {
require(<FILL_ME>)
_;
}
// Overrides
function configure(address _owner) internal virtual override {
}
// Admin methods
function setAbleToBurn(address who, bool enabled) external onlyOwner {
}
/**
* @dev Internal function that burns an amount of the token of a given
* account.
* @param value The amount that will be burnt.
*/
function burn(uint256 value) external override onlyBurner {
}
/**
* @dev Internal function that burns an amount of the token of a given
* account, deducting from the sender's allowance for said account. Uses the
* internal burn function.
* Emits an Approval event (reflecting the reduced allowance).
* @param account The account whose tokens will be burnt.
* @param value The amount that will be burnt.
*/
function burnFrom(address account, uint256 value) external override onlyBurner {
}
// Private methods
function _burn(address account, uint256 value) internal {
}
}
| ableToBurn[msg.sender],"no burn permissions" | 513,345 | ableToBurn[msg.sender] |
"AIINU: Excluded addresses cannot call this function" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
contract AIInuToken is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcludedFromMaxTxAmount;
mapping (address => bool) private _isExcludedFromMaxHoldAmount;
mapping (address => bool) private _isExcludedFromReward;
address[] private _excludedFromReward;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1_000_000_000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
// 0.5%
uint256 private _maxTxAmount = 5_000_000 * 10**6 * 10**9;
// 2%
uint256 private _maxHoldAmount = 20_000_000 * 10**6 * 10**9;
string private _name = "AI Inu";
string private _symbol = "AIINU";
uint8 private _decimals = 9;
uint256 private _taxFee = 200;
uint256 private _previousTaxFee = _taxFee;
uint256 private _treasuryFee = 300;
uint256 private _previousTreasuryFee = _treasuryFee;
address public immutable uniswapV2Pair;
address private _dao;
event DAOChanged(address previousDAO, address newDAO);
modifier onlyDAO() {
}
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 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 isExcludedFromReward(address account) public view returns (bool) {
}
function changeDAO(address newDAO) external onlyOwner {
}
function _changeDAO(address newDAO) private {
}
function totalFees() public view returns (uint256) {
}
function taxFee() public view returns (uint256) {
}
function treasuryFee() public view returns (uint256) {
}
function maxTxAmount() public view returns (uint256) {
}
function maxHoldAmount() public view returns (uint256) {
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(<FILL_ME>)
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
}
function excludeFromReward(address account) public onlyOwner() {
}
function includeInReward(address account) external onlyOwner() {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function setIsExcludedFromMaxTxAmount(address account, bool excluded) public onlyOwner {
}
function isExcludedFromMaxTxAmount(address account) public view returns (bool) {
}
function setIsExcludedFromMaxHoldAmount(address account, bool excluded) public onlyOwner {
}
function isExcludedFromMaxHoldAmount(address account) public view returns (bool) {
}
// rate in basis points. Eg: 200 - 2.0% of total supply (100% = 10000)
function setTaxFeePercent(uint256 taxFee_) external onlyOwner() {
}
// rate in basis points. Eg: 300 - 3.0% of total supply (100% = 10000)
function setTreasuryFeePercent(uint256 treasuryFee_) external onlyOwner() {
}
// rate in basis points. Eg: 50 - 0.5% of total supply (100% = 10000)
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
}
// rate in basis points. Eg: 200 - 2.0% of total supply (100% = 10000)
function setMaxHoldPercent(uint256 maxHoldPercent) external onlyOwner() {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTreasury, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function _takeTreasury(uint256 tTreasury) private {
}
function calculateTaxFee(uint256 _amount) private view returns (uint256) {
}
function calculateTreasuryFee(uint256 _amount) private view returns (uint256) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function isExcludedFromFee(address account) public view returns(bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
//this method is responsible for taking all fee, if takeFee is true
function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
}
function withdrawTreasury() external onlyDAO {
}
// to recieve ETH
receive() external payable {}
// withdraw ETH
function withdrawETH() external onlyDAO returns (bool) {
}
}
| !_isExcludedFromReward[sender],"AIINU: Excluded addresses cannot call this function" | 513,374 | !_isExcludedFromReward[sender] |
"AIINU: Account is already excluded" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
contract AIInuToken is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcludedFromMaxTxAmount;
mapping (address => bool) private _isExcludedFromMaxHoldAmount;
mapping (address => bool) private _isExcludedFromReward;
address[] private _excludedFromReward;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1_000_000_000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
// 0.5%
uint256 private _maxTxAmount = 5_000_000 * 10**6 * 10**9;
// 2%
uint256 private _maxHoldAmount = 20_000_000 * 10**6 * 10**9;
string private _name = "AI Inu";
string private _symbol = "AIINU";
uint8 private _decimals = 9;
uint256 private _taxFee = 200;
uint256 private _previousTaxFee = _taxFee;
uint256 private _treasuryFee = 300;
uint256 private _previousTreasuryFee = _treasuryFee;
address public immutable uniswapV2Pair;
address private _dao;
event DAOChanged(address previousDAO, address newDAO);
modifier onlyDAO() {
}
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 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 isExcludedFromReward(address account) public view returns (bool) {
}
function changeDAO(address newDAO) external onlyOwner {
}
function _changeDAO(address newDAO) private {
}
function totalFees() public view returns (uint256) {
}
function taxFee() public view returns (uint256) {
}
function treasuryFee() public view returns (uint256) {
}
function maxTxAmount() public view returns (uint256) {
}
function maxHoldAmount() public view returns (uint256) {
}
function deliver(uint256 tAmount) public {
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
}
function excludeFromReward(address account) public onlyOwner() {
require(<FILL_ME>)
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcludedFromReward[account] = true;
_excludedFromReward.push(account);
}
function includeInReward(address account) external onlyOwner() {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function setIsExcludedFromMaxTxAmount(address account, bool excluded) public onlyOwner {
}
function isExcludedFromMaxTxAmount(address account) public view returns (bool) {
}
function setIsExcludedFromMaxHoldAmount(address account, bool excluded) public onlyOwner {
}
function isExcludedFromMaxHoldAmount(address account) public view returns (bool) {
}
// rate in basis points. Eg: 200 - 2.0% of total supply (100% = 10000)
function setTaxFeePercent(uint256 taxFee_) external onlyOwner() {
}
// rate in basis points. Eg: 300 - 3.0% of total supply (100% = 10000)
function setTreasuryFeePercent(uint256 treasuryFee_) external onlyOwner() {
}
// rate in basis points. Eg: 50 - 0.5% of total supply (100% = 10000)
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
}
// rate in basis points. Eg: 200 - 2.0% of total supply (100% = 10000)
function setMaxHoldPercent(uint256 maxHoldPercent) external onlyOwner() {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTreasury, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function _takeTreasury(uint256 tTreasury) private {
}
function calculateTaxFee(uint256 _amount) private view returns (uint256) {
}
function calculateTreasuryFee(uint256 _amount) private view returns (uint256) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function isExcludedFromFee(address account) public view returns(bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
//this method is responsible for taking all fee, if takeFee is true
function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
}
function withdrawTreasury() external onlyDAO {
}
// to recieve ETH
receive() external payable {}
// withdraw ETH
function withdrawETH() external onlyDAO returns (bool) {
}
}
| !_isExcludedFromReward[account],"AIINU: Account is already excluded" | 513,374 | !_isExcludedFromReward[account] |
"AIINU: Account is not excluded" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
contract AIInuToken is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcludedFromMaxTxAmount;
mapping (address => bool) private _isExcludedFromMaxHoldAmount;
mapping (address => bool) private _isExcludedFromReward;
address[] private _excludedFromReward;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1_000_000_000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
// 0.5%
uint256 private _maxTxAmount = 5_000_000 * 10**6 * 10**9;
// 2%
uint256 private _maxHoldAmount = 20_000_000 * 10**6 * 10**9;
string private _name = "AI Inu";
string private _symbol = "AIINU";
uint8 private _decimals = 9;
uint256 private _taxFee = 200;
uint256 private _previousTaxFee = _taxFee;
uint256 private _treasuryFee = 300;
uint256 private _previousTreasuryFee = _treasuryFee;
address public immutable uniswapV2Pair;
address private _dao;
event DAOChanged(address previousDAO, address newDAO);
modifier onlyDAO() {
}
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 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 isExcludedFromReward(address account) public view returns (bool) {
}
function changeDAO(address newDAO) external onlyOwner {
}
function _changeDAO(address newDAO) private {
}
function totalFees() public view returns (uint256) {
}
function taxFee() public view returns (uint256) {
}
function treasuryFee() public view returns (uint256) {
}
function maxTxAmount() public view returns (uint256) {
}
function maxHoldAmount() public view returns (uint256) {
}
function deliver(uint256 tAmount) public {
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
}
function excludeFromReward(address account) public onlyOwner() {
}
function includeInReward(address account) external onlyOwner() {
require(<FILL_ME>)
for (uint256 i = 0; i < _excludedFromReward.length; i++) {
if (_excludedFromReward[i] == account) {
_excludedFromReward[i] = _excludedFromReward[_excludedFromReward.length - 1];
_tOwned[account] = 0;
_isExcludedFromReward[account] = false;
_excludedFromReward.pop();
break;
}
}
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function setIsExcludedFromMaxTxAmount(address account, bool excluded) public onlyOwner {
}
function isExcludedFromMaxTxAmount(address account) public view returns (bool) {
}
function setIsExcludedFromMaxHoldAmount(address account, bool excluded) public onlyOwner {
}
function isExcludedFromMaxHoldAmount(address account) public view returns (bool) {
}
// rate in basis points. Eg: 200 - 2.0% of total supply (100% = 10000)
function setTaxFeePercent(uint256 taxFee_) external onlyOwner() {
}
// rate in basis points. Eg: 300 - 3.0% of total supply (100% = 10000)
function setTreasuryFeePercent(uint256 treasuryFee_) external onlyOwner() {
}
// rate in basis points. Eg: 50 - 0.5% of total supply (100% = 10000)
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
}
// rate in basis points. Eg: 200 - 2.0% of total supply (100% = 10000)
function setMaxHoldPercent(uint256 maxHoldPercent) external onlyOwner() {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTreasury, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function _takeTreasury(uint256 tTreasury) private {
}
function calculateTaxFee(uint256 _amount) private view returns (uint256) {
}
function calculateTreasuryFee(uint256 _amount) private view returns (uint256) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function isExcludedFromFee(address account) public view returns(bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
//this method is responsible for taking all fee, if takeFee is true
function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
}
function withdrawTreasury() external onlyDAO {
}
// to recieve ETH
receive() external payable {}
// withdraw ETH
function withdrawETH() external onlyDAO returns (bool) {
}
}
| _isExcludedFromReward[account],"AIINU: Account is not excluded" | 513,374 | _isExcludedFromReward[account] |
"AIINU: Balance exceeds the maxHoldAmount." | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
contract AIInuToken is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcludedFromMaxTxAmount;
mapping (address => bool) private _isExcludedFromMaxHoldAmount;
mapping (address => bool) private _isExcludedFromReward;
address[] private _excludedFromReward;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1_000_000_000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
// 0.5%
uint256 private _maxTxAmount = 5_000_000 * 10**6 * 10**9;
// 2%
uint256 private _maxHoldAmount = 20_000_000 * 10**6 * 10**9;
string private _name = "AI Inu";
string private _symbol = "AIINU";
uint8 private _decimals = 9;
uint256 private _taxFee = 200;
uint256 private _previousTaxFee = _taxFee;
uint256 private _treasuryFee = 300;
uint256 private _previousTreasuryFee = _treasuryFee;
address public immutable uniswapV2Pair;
address private _dao;
event DAOChanged(address previousDAO, address newDAO);
modifier onlyDAO() {
}
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 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 isExcludedFromReward(address account) public view returns (bool) {
}
function changeDAO(address newDAO) external onlyOwner {
}
function _changeDAO(address newDAO) private {
}
function totalFees() public view returns (uint256) {
}
function taxFee() public view returns (uint256) {
}
function treasuryFee() public view returns (uint256) {
}
function maxTxAmount() public view returns (uint256) {
}
function maxHoldAmount() public view returns (uint256) {
}
function deliver(uint256 tAmount) public {
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
}
function excludeFromReward(address account) public onlyOwner() {
}
function includeInReward(address account) external onlyOwner() {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function setIsExcludedFromMaxTxAmount(address account, bool excluded) public onlyOwner {
}
function isExcludedFromMaxTxAmount(address account) public view returns (bool) {
}
function setIsExcludedFromMaxHoldAmount(address account, bool excluded) public onlyOwner {
}
function isExcludedFromMaxHoldAmount(address account) public view returns (bool) {
}
// rate in basis points. Eg: 200 - 2.0% of total supply (100% = 10000)
function setTaxFeePercent(uint256 taxFee_) external onlyOwner() {
}
// rate in basis points. Eg: 300 - 3.0% of total supply (100% = 10000)
function setTreasuryFeePercent(uint256 treasuryFee_) external onlyOwner() {
}
// rate in basis points. Eg: 50 - 0.5% of total supply (100% = 10000)
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
}
// rate in basis points. Eg: 200 - 2.0% of total supply (100% = 10000)
function setMaxHoldPercent(uint256 maxHoldPercent) external onlyOwner() {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTreasury, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function _takeTreasury(uint256 tTreasury) private {
}
function calculateTaxFee(uint256 _amount) private view returns (uint256) {
}
function calculateTreasuryFee(uint256 _amount) private view returns (uint256) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function isExcludedFromFee(address account) public view returns(bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "ERC20: Transfer amount must be greater than zero");
if(!_isExcludedFromMaxTxAmount[from])
require(amount <= _maxTxAmount, "AIINU: Transfer amount exceeds the maxTxAmount.");
if(!_isExcludedFromMaxHoldAmount[to])
require(<FILL_ME>)
//indicates if fee should be deducted from transfer
bool takeFee = true;
//if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
_tokenTransfer(from,to,amount,takeFee);
}
//this method is responsible for taking all fee, if takeFee is true
function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
}
function withdrawTreasury() external onlyDAO {
}
// to recieve ETH
receive() external payable {}
// withdraw ETH
function withdrawETH() external onlyDAO returns (bool) {
}
}
| balanceOf(to).add(amount)<=_maxHoldAmount,"AIINU: Balance exceeds the maxHoldAmount." | 513,374 | balanceOf(to).add(amount)<=_maxHoldAmount |
"Max supply exceeded!" | pragma solidity ^0.8.4;
contract BlockAbstraction is Ownable, ERC721A, DefaultOperatorFilterer {
using Strings for uint256;
string private baseTokenURI;
uint256 public presaleCost = 0.001 ether;
uint256 public publicSaleCost = 0.005 ether;
uint64 public maxSupply = 700;
uint64 public publicMaxSupply = 700;
uint64 public publicTotalSupply = 0;
uint64 public presaleMaxSupply = 300;
uint64 public presaleTotalSupply = 0;
uint64 public maxMintAmountPerPresaleAccount = 3;
uint64 public maxMintAmountPerPublicAccount = 5;
bool public presaleActive = false;
bool public publicSaleActive = false;
constructor() ERC721A("Blocks by Anon", "Block"){}
modifier mintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 , "Invalid mint amount!");
require(<FILL_ME>)
_;
}
///Mints NFTs for whitelist members during the presale
function presaleMint(uint64 _mintAmount) public payable mintCompliance(_mintAmount) {
}
///Allows any address to mint when the public sale is open
function publicMint(uint64 _mintAmount) public payable mintCompliance(_mintAmount) {
}
///Allows owner of the collection to airdrop a token to any address
function ownerMint(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
//@return token ids owned by an address in the collection
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
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)
{
}
//@return full url for passed in token id
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
//@return amount an address has minted during the presale
function getPresaleAmountMintedPerAccount(address _owner) public view returns (uint64) {
}
function setPresaleAmountMintedPerAccount(address _owner, uint64 _aux) internal {
}
//@return amount an address has minted during all sales
function numberMinted(address _owner) public view returns (uint256) {
}
//@return all NFT's minted including burned tokens
function totalMinted() public view returns (uint256) {
}
function exists(uint256 _tokenId) public view returns (bool) {
}
//@return url for the nft metadata
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata _URI) external onlyOwner {
}
function setPresaleActive(bool _state) public onlyOwner {
}
function setPublicActive(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
/// Fallbacks
receive() external payable { }
fallback() external payable { }
}
| totalMinted()+_mintAmount<=maxSupply,"Max supply exceeded!" | 513,474 | totalMinted()+_mintAmount<=maxSupply |
"Mint limit exceeded." | pragma solidity ^0.8.4;
contract BlockAbstraction is Ownable, ERC721A, DefaultOperatorFilterer {
using Strings for uint256;
string private baseTokenURI;
uint256 public presaleCost = 0.001 ether;
uint256 public publicSaleCost = 0.005 ether;
uint64 public maxSupply = 700;
uint64 public publicMaxSupply = 700;
uint64 public publicTotalSupply = 0;
uint64 public presaleMaxSupply = 300;
uint64 public presaleTotalSupply = 0;
uint64 public maxMintAmountPerPresaleAccount = 3;
uint64 public maxMintAmountPerPublicAccount = 5;
bool public presaleActive = false;
bool public publicSaleActive = false;
constructor() ERC721A("Blocks by Anon", "Block"){}
modifier mintCompliance(uint256 _mintAmount) {
}
///Mints NFTs for whitelist members during the presale
function presaleMint(uint64 _mintAmount) public payable mintCompliance(_mintAmount) {
require(presaleActive, "Presale is not Active");
require(msg.value == presaleCost * _mintAmount, "Insufficient funds!");
uint64 presaleAmountMintedPerAccount = getPresaleAmountMintedPerAccount(msg.sender);
require(<FILL_ME>)
require(presaleTotalSupply + _mintAmount <= presaleMaxSupply, "Mint limit exceeded." );
setPresaleAmountMintedPerAccount(msg.sender,presaleAmountMintedPerAccount + _mintAmount);
presaleTotalSupply+=_mintAmount;
_safeMint(msg.sender, _mintAmount);
}
///Allows any address to mint when the public sale is open
function publicMint(uint64 _mintAmount) public payable mintCompliance(_mintAmount) {
}
///Allows owner of the collection to airdrop a token to any address
function ownerMint(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
//@return token ids owned by an address in the collection
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
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)
{
}
//@return full url for passed in token id
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
//@return amount an address has minted during the presale
function getPresaleAmountMintedPerAccount(address _owner) public view returns (uint64) {
}
function setPresaleAmountMintedPerAccount(address _owner, uint64 _aux) internal {
}
//@return amount an address has minted during all sales
function numberMinted(address _owner) public view returns (uint256) {
}
//@return all NFT's minted including burned tokens
function totalMinted() public view returns (uint256) {
}
function exists(uint256 _tokenId) public view returns (bool) {
}
//@return url for the nft metadata
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata _URI) external onlyOwner {
}
function setPresaleActive(bool _state) public onlyOwner {
}
function setPublicActive(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
/// Fallbacks
receive() external payable { }
fallback() external payable { }
}
| presaleAmountMintedPerAccount+_mintAmount<=maxMintAmountPerPresaleAccount,"Mint limit exceeded." | 513,474 | presaleAmountMintedPerAccount+_mintAmount<=maxMintAmountPerPresaleAccount |
"Mint limit exceeded." | pragma solidity ^0.8.4;
contract BlockAbstraction is Ownable, ERC721A, DefaultOperatorFilterer {
using Strings for uint256;
string private baseTokenURI;
uint256 public presaleCost = 0.001 ether;
uint256 public publicSaleCost = 0.005 ether;
uint64 public maxSupply = 700;
uint64 public publicMaxSupply = 700;
uint64 public publicTotalSupply = 0;
uint64 public presaleMaxSupply = 300;
uint64 public presaleTotalSupply = 0;
uint64 public maxMintAmountPerPresaleAccount = 3;
uint64 public maxMintAmountPerPublicAccount = 5;
bool public presaleActive = false;
bool public publicSaleActive = false;
constructor() ERC721A("Blocks by Anon", "Block"){}
modifier mintCompliance(uint256 _mintAmount) {
}
///Mints NFTs for whitelist members during the presale
function presaleMint(uint64 _mintAmount) public payable mintCompliance(_mintAmount) {
require(presaleActive, "Presale is not Active");
require(msg.value == presaleCost * _mintAmount, "Insufficient funds!");
uint64 presaleAmountMintedPerAccount = getPresaleAmountMintedPerAccount(msg.sender);
require(presaleAmountMintedPerAccount + _mintAmount <= maxMintAmountPerPresaleAccount, "Mint limit exceeded." );
require(<FILL_ME>)
setPresaleAmountMintedPerAccount(msg.sender,presaleAmountMintedPerAccount + _mintAmount);
presaleTotalSupply+=_mintAmount;
_safeMint(msg.sender, _mintAmount);
}
///Allows any address to mint when the public sale is open
function publicMint(uint64 _mintAmount) public payable mintCompliance(_mintAmount) {
}
///Allows owner of the collection to airdrop a token to any address
function ownerMint(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
//@return token ids owned by an address in the collection
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
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)
{
}
//@return full url for passed in token id
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
//@return amount an address has minted during the presale
function getPresaleAmountMintedPerAccount(address _owner) public view returns (uint64) {
}
function setPresaleAmountMintedPerAccount(address _owner, uint64 _aux) internal {
}
//@return amount an address has minted during all sales
function numberMinted(address _owner) public view returns (uint256) {
}
//@return all NFT's minted including burned tokens
function totalMinted() public view returns (uint256) {
}
function exists(uint256 _tokenId) public view returns (bool) {
}
//@return url for the nft metadata
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata _URI) external onlyOwner {
}
function setPresaleActive(bool _state) public onlyOwner {
}
function setPublicActive(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
/// Fallbacks
receive() external payable { }
fallback() external payable { }
}
| presaleTotalSupply+_mintAmount<=presaleMaxSupply,"Mint limit exceeded." | 513,474 | presaleTotalSupply+_mintAmount<=presaleMaxSupply |
"Mint limit exceeded." | pragma solidity ^0.8.4;
contract BlockAbstraction is Ownable, ERC721A, DefaultOperatorFilterer {
using Strings for uint256;
string private baseTokenURI;
uint256 public presaleCost = 0.001 ether;
uint256 public publicSaleCost = 0.005 ether;
uint64 public maxSupply = 700;
uint64 public publicMaxSupply = 700;
uint64 public publicTotalSupply = 0;
uint64 public presaleMaxSupply = 300;
uint64 public presaleTotalSupply = 0;
uint64 public maxMintAmountPerPresaleAccount = 3;
uint64 public maxMintAmountPerPublicAccount = 5;
bool public presaleActive = false;
bool public publicSaleActive = false;
constructor() ERC721A("Blocks by Anon", "Block"){}
modifier mintCompliance(uint256 _mintAmount) {
}
///Mints NFTs for whitelist members during the presale
function presaleMint(uint64 _mintAmount) public payable mintCompliance(_mintAmount) {
}
///Allows any address to mint when the public sale is open
function publicMint(uint64 _mintAmount) public payable mintCompliance(_mintAmount) {
require(publicSaleActive, "Public is not Active");
require(tx.origin == msg.sender);
require(<FILL_ME>)
require(publicTotalSupply + _mintAmount <= publicMaxSupply, "Mint limit exceeded." );
require(msg.value == publicSaleCost * _mintAmount, "Insufficient funds!");
publicTotalSupply+=_mintAmount;
_safeMint(msg.sender, _mintAmount);
}
///Allows owner of the collection to airdrop a token to any address
function ownerMint(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
//@return token ids owned by an address in the collection
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
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)
{
}
//@return full url for passed in token id
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
//@return amount an address has minted during the presale
function getPresaleAmountMintedPerAccount(address _owner) public view returns (uint64) {
}
function setPresaleAmountMintedPerAccount(address _owner, uint64 _aux) internal {
}
//@return amount an address has minted during all sales
function numberMinted(address _owner) public view returns (uint256) {
}
//@return all NFT's minted including burned tokens
function totalMinted() public view returns (uint256) {
}
function exists(uint256 _tokenId) public view returns (bool) {
}
//@return url for the nft metadata
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata _URI) external onlyOwner {
}
function setPresaleActive(bool _state) public onlyOwner {
}
function setPublicActive(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
/// Fallbacks
receive() external payable { }
fallback() external payable { }
}
| numberMinted(msg.sender)+_mintAmount<=maxMintAmountPerPublicAccount,"Mint limit exceeded." | 513,474 | numberMinted(msg.sender)+_mintAmount<=maxMintAmountPerPublicAccount |
"Mint limit exceeded." | pragma solidity ^0.8.4;
contract BlockAbstraction is Ownable, ERC721A, DefaultOperatorFilterer {
using Strings for uint256;
string private baseTokenURI;
uint256 public presaleCost = 0.001 ether;
uint256 public publicSaleCost = 0.005 ether;
uint64 public maxSupply = 700;
uint64 public publicMaxSupply = 700;
uint64 public publicTotalSupply = 0;
uint64 public presaleMaxSupply = 300;
uint64 public presaleTotalSupply = 0;
uint64 public maxMintAmountPerPresaleAccount = 3;
uint64 public maxMintAmountPerPublicAccount = 5;
bool public presaleActive = false;
bool public publicSaleActive = false;
constructor() ERC721A("Blocks by Anon", "Block"){}
modifier mintCompliance(uint256 _mintAmount) {
}
///Mints NFTs for whitelist members during the presale
function presaleMint(uint64 _mintAmount) public payable mintCompliance(_mintAmount) {
}
///Allows any address to mint when the public sale is open
function publicMint(uint64 _mintAmount) public payable mintCompliance(_mintAmount) {
require(publicSaleActive, "Public is not Active");
require(tx.origin == msg.sender);
require(numberMinted(msg.sender) + _mintAmount <= maxMintAmountPerPublicAccount, "Mint limit exceeded." );
require(<FILL_ME>)
require(msg.value == publicSaleCost * _mintAmount, "Insufficient funds!");
publicTotalSupply+=_mintAmount;
_safeMint(msg.sender, _mintAmount);
}
///Allows owner of the collection to airdrop a token to any address
function ownerMint(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
//@return token ids owned by an address in the collection
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
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)
{
}
//@return full url for passed in token id
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
//@return amount an address has minted during the presale
function getPresaleAmountMintedPerAccount(address _owner) public view returns (uint64) {
}
function setPresaleAmountMintedPerAccount(address _owner, uint64 _aux) internal {
}
//@return amount an address has minted during all sales
function numberMinted(address _owner) public view returns (uint256) {
}
//@return all NFT's minted including burned tokens
function totalMinted() public view returns (uint256) {
}
function exists(uint256 _tokenId) public view returns (bool) {
}
//@return url for the nft metadata
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata _URI) external onlyOwner {
}
function setPresaleActive(bool _state) public onlyOwner {
}
function setPublicActive(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
/// Fallbacks
receive() external payable { }
fallback() external payable { }
}
| publicTotalSupply+_mintAmount<=publicMaxSupply,"Mint limit exceeded." | 513,474 | publicTotalSupply+_mintAmount<=publicMaxSupply |
"Out of supply" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@promos/contracts/Promos.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import {DefaultOperatorFilterer} from "./OperatorFilterRegistry/DefaultOperatorFilterer.sol";
/*
This smart-contract is powered by GOMINT and Promos.
https://gomint.art
https://promos.wtf
*/
contract Konbini is
Ownable,
ERC721A,
Promos,
PaymentSplitter,
DefaultOperatorFilterer
{
using SafeMath for uint256;
bool public publicMint;
bool public promosMint;
string public baseTokenURI;
uint256 public maxSupply = 100;
uint256 public maxPerWallet = 10;
uint256 public maxPerTransaction = 10;
uint256 public price = 0.09 ether;
uint256[] private _shares = [97, 3];
address[] private _shareholders = [
0xEf25Db6F8BfA2a8cF7c712Ea2fE8fFC170f7bbC2,
0xBE8106153690192865E6b601f92671b93A1fb498
];
constructor()
ERC721A("Konbini", "Konbini")
Promos(10, promosProxyContractMainnet)
PaymentSplitter(_shareholders, _shares)
{}
// Mint functions
function teamMint(address _to, uint256 _amount) external onlyOwner {
require(<FILL_ME>)
_safeMint(_to, _amount);
}
function mintPublic(uint256 _amount) external payable {
}
function mintPromos(address _to, uint256 _amount)
external
payable
override
MintPromos(_to, _amount)
{
}
// ETH withdrawal
function withdraw() external onlyOwner {
}
function withdraw(address _receiver, uint256 _amount)external onlyOwner {
}
// Setters
function setPrice(uint256 _price) external onlyOwner {
}
function setPublicMint(bool _publicMint) external onlyOwner {
}
function setPromosMint(bool _promosMint) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function setBaseTokenURI(string memory _baseTokenURI) external onlyOwner {
}
function setMaxPerTransaction(uint256 _maxPerTransaction)
external
onlyOwner
{
}
// Overrides
function _startTokenId() internal pure override returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, Promos)
returns (bool)
{
}
receive() external payable override(IPromos, PaymentSplitter) {}
/**
* @notice This contract is configured to use the DefaultOperatorFilterer, which automatically registers the
* token and subscribes it to OpenSea's curated filters. Adding the onlyAllowedOperator modifier to the
* transferFrom and both safeTransferFrom methods ensures that the msg.sender (operator) is allowed by the
* OperatorFilterRegistry. Adding the onlyAllowedOperatorApproval modifier to the approval methods ensures
* that owners do not approve operators that are not allowed.
*/
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) {
}
}
| totalSupply().add(_amount)<=maxSupply,"Out of supply" | 513,579 | totalSupply().add(_amount)<=maxSupply |
"Invalid Validator ID array" | pragma solidity ^0.8.4;
/**
* @title Validator Pool
* @author Ape Toshi
* @notice Initial validators are managed by the DAO.
* @custom:security-contact admin@apetoshi.com
*/
abstract contract ValidatorPool {
// ========== Events ==========
event MinBlocksUpdate(uint256 newMinBlocks);
event MinSignaturesUpdate(uint256 newMinSignatures);
event ValidatorsUpdate(address[] newValidators);
uint256 public minBlocks;
uint256 public minSignatures;
// Trusted oracle network
address[] public validators;
constructor(
uint256 _minBlocks,
uint256 _minSignatures,
address[] memory _validators
) {
}
/// @dev Only trusted addresses can be validators.
function _configValidators(address[] memory newValidators)
internal
virtual
{
}
/// @dev For security purposes, should be at least 50%.
function _configMinSignatures(uint256 newMinSignatures) internal {
}
/// @dev This is a trade-off between safety and UX. Default to 32.
function _configMinBlocks(uint256 newMinBlocks) internal {
}
// ========== Can be called by any address ==========
/**
* @dev Verify if a cross-chain token bridge request is valid.
* @param txnHash The bytes32 hash of the transaction.
* @param fromChainId The origin EVM chain ID.
* @param toChainId The destination EVM chain ID.
* @param fromTokenAddress The address of the token on the home chain.
* @param toTokenAddress The address of the token on the foreign chain.
* @param account The address of the account.
* @param amount The amount of tokens to bridge.
* @param ascendingValidatorIds Validator Id array in ascending order
* @param validatorSignatures Array of validator signatures
*/
function _isValid(
bytes32 txnHash,
uint256 fromChainId,
uint256 toChainId,
address fromTokenAddress,
address toTokenAddress,
address account,
uint256 amount,
uint256[] calldata ascendingValidatorIds,
bytes[] memory validatorSignatures
) internal view returns (bool) {
require(<FILL_ME>)
require(
validatorSignatures.length >= minSignatures,
"Not enough signatures"
);
require(
validatorSignatures.length == ascendingValidatorIds.length,
"Signature and validator arrays have to match"
);
bytes32 messageHash = keccak256(
abi.encodePacked(
txnHash,
fromChainId,
toChainId,
fromTokenAddress,
toTokenAddress,
account,
amount
)
);
bytes32 ethSignedMessageHash = _getEthSignedMessageHash(messageHash);
address validator;
uint256 id;
for (uint256 i; i < minSignatures; ) {
id = ascendingValidatorIds[i];
validator = validators[id];
if (
!_verifySigner(
ethSignedMessageHash,
validatorSignatures[i],
validator
)
) {
return false;
}
unchecked {
i++;
}
}
return true;
}
// ========== Helper functions ==========
/**
* @notice Signature is produced by signing a keccak256 hash with the following format:
* "\x19Ethereum Signed Message\n" + len(msg) + msg
*/
function _getEthSignedMessageHash(bytes32 _messageHash)
internal
pure
returns (bytes32)
{
}
/// @dev Recover the signer address from `ethSignedMessageHash`.
function _recoverSigner(
bytes32 ethSignedMessageHash,
bytes memory signature
) internal pure returns (address) {
}
/// @dev Split a `signature` into `r`, `s` and `v` values.
function _splitSignature(bytes memory signature)
internal
pure
returns (
bytes32 r,
bytes32 s,
uint8 v
)
{
}
/// @dev Verify if `signature` on `ethSignedMessageHash` was signed by `signer`.
function _verifySigner(
bytes32 ethSignedMessageHash,
bytes memory signature,
address signer
) internal pure returns (bool) {
}
/**
* @dev Checks if array is sorted in ascending order such that
* every element is unique and not greater than 5 (6th validator).
*/
function _checkAscendingValidatorIds(
uint256[] calldata ascendingValidatorIds
) internal view returns (bool) {
}
}
| _checkAscendingValidatorIds(ascendingValidatorIds),"Invalid Validator ID array" | 513,612 | _checkAscendingValidatorIds(ascendingValidatorIds) |
"BuyWDF: Couldn't transfer tokens to WDF Team" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract Presale {
using SafeERC20 for IERC20;
address private _owner;
IERC20 private _token;
IERC20 private _wdf;
uint256 private _pricetoken;
uint256 private _priceeth;
constructor() {
}
function token() public view virtual returns (IERC20) {
}
function wdf() public view virtual returns (IERC20) {
}
function pricetoken() public view virtual returns (uint256) {
}
function priceeth() public view virtual returns (uint256) {
}
function Config(IERC20 token_addr, IERC20 wdf_addr, uint256 pricetoken_amount, uint256 priceeth_amount) public isOwner returns (bool success) {
}
event WDFSale(address receiver, uint256 paid, uint256 received);
function BuyWDF(uint256 amount) public returns (bool success) {
require(amount > 0, "BuyWDF: amount is not positive");
require(_pricetoken > 0, "BuyWDF: price not configured");
uint256 paid = ( amount / 100 ) * _pricetoken;
require(paid > 0, "BuyWDF: amount for paid is not positive");
uint256 allowance = _token.allowance(msg.sender, address(this));
require(allowance >= paid, "BuyWDF: Check the token allowance");
require(<FILL_ME>)
require(_wdf.transfer(msg.sender, amount) == true, "BuyWDF: Couldn't transfer WDF tokens to buyer");
emit WDFSale(msg.sender, paid, amount);
return true;
}
//IF BUY FOR ETHER
function BuyWDFETH() payable public {
}
function WithdrawSale() public isOwner {
}
event OwnerSet(address indexed oldOwner, address indexed newOwner);
function getOwner() external view returns (address) {
}
function setOwner(address newOwner) public isOwner {
}
modifier isOwner() {
}
}
pragma solidity ^0.8.7;
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);
}
pragma solidity ^0.8.7;
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) {
}
}
pragma solidity ^0.8.7;
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 _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
pragma solidity ^0.8.7;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
| _token.transferFrom(msg.sender,address(this),paid)==true,"BuyWDF: Couldn't transfer tokens to WDF Team" | 513,627 | _token.transferFrom(msg.sender,address(this),paid)==true |
"BuyWDF: Couldn't transfer WDF tokens to buyer" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract Presale {
using SafeERC20 for IERC20;
address private _owner;
IERC20 private _token;
IERC20 private _wdf;
uint256 private _pricetoken;
uint256 private _priceeth;
constructor() {
}
function token() public view virtual returns (IERC20) {
}
function wdf() public view virtual returns (IERC20) {
}
function pricetoken() public view virtual returns (uint256) {
}
function priceeth() public view virtual returns (uint256) {
}
function Config(IERC20 token_addr, IERC20 wdf_addr, uint256 pricetoken_amount, uint256 priceeth_amount) public isOwner returns (bool success) {
}
event WDFSale(address receiver, uint256 paid, uint256 received);
function BuyWDF(uint256 amount) public returns (bool success) {
require(amount > 0, "BuyWDF: amount is not positive");
require(_pricetoken > 0, "BuyWDF: price not configured");
uint256 paid = ( amount / 100 ) * _pricetoken;
require(paid > 0, "BuyWDF: amount for paid is not positive");
uint256 allowance = _token.allowance(msg.sender, address(this));
require(allowance >= paid, "BuyWDF: Check the token allowance");
require(_token.transferFrom(msg.sender, address(this), paid) == true, "BuyWDF: Couldn't transfer tokens to WDF Team");
require(<FILL_ME>)
emit WDFSale(msg.sender, paid, amount);
return true;
}
//IF BUY FOR ETHER
function BuyWDFETH() payable public {
}
function WithdrawSale() public isOwner {
}
event OwnerSet(address indexed oldOwner, address indexed newOwner);
function getOwner() external view returns (address) {
}
function setOwner(address newOwner) public isOwner {
}
modifier isOwner() {
}
}
pragma solidity ^0.8.7;
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);
}
pragma solidity ^0.8.7;
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) {
}
}
pragma solidity ^0.8.7;
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 _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
pragma solidity ^0.8.7;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
| _wdf.transfer(msg.sender,amount)==true,"BuyWDF: Couldn't transfer WDF tokens to buyer" | 513,627 | _wdf.transfer(msg.sender,amount)==true |
"BuyWDFETH: Couldn't transfer WDF tokens to buyer" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract Presale {
using SafeERC20 for IERC20;
address private _owner;
IERC20 private _token;
IERC20 private _wdf;
uint256 private _pricetoken;
uint256 private _priceeth;
constructor() {
}
function token() public view virtual returns (IERC20) {
}
function wdf() public view virtual returns (IERC20) {
}
function pricetoken() public view virtual returns (uint256) {
}
function priceeth() public view virtual returns (uint256) {
}
function Config(IERC20 token_addr, IERC20 wdf_addr, uint256 pricetoken_amount, uint256 priceeth_amount) public isOwner returns (bool success) {
}
event WDFSale(address receiver, uint256 paid, uint256 received);
function BuyWDF(uint256 amount) public returns (bool success) {
}
//IF BUY FOR ETHER
function BuyWDFETH() payable public {
uint256 amount = msg.value;
require(amount > 0, "BuyWDFETH: amount is not positive");
require(_priceeth > 0, "BuyWDFETH: price not configured");
uint256 getwdf = amount * _priceeth;
require(getwdf > 0, "BuyWDF: received WDF amount is not positive");
require(<FILL_ME>)
emit WDFSale(msg.sender, amount, getwdf);
}
function WithdrawSale() public isOwner {
}
event OwnerSet(address indexed oldOwner, address indexed newOwner);
function getOwner() external view returns (address) {
}
function setOwner(address newOwner) public isOwner {
}
modifier isOwner() {
}
}
pragma solidity ^0.8.7;
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);
}
pragma solidity ^0.8.7;
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) {
}
}
pragma solidity ^0.8.7;
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 _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
pragma solidity ^0.8.7;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
| _wdf.transfer(msg.sender,getwdf)==true,"BuyWDFETH: Couldn't transfer WDF tokens to buyer" | 513,627 | _wdf.transfer(msg.sender,getwdf)==true |
null | /**
Fitness Genie AI
Our AI-based Telegram bot (@FitnessGenieBot) provides personalized fitness and nutrition plans
that are tailored specifically to your individual needs and goals, making it the ultimate personal trainer.
Whether you're looking to lose weight, build muscle, or maintain a healthy lifestyle, our powerful AI
technology will help you achieve your goals.
https://t.me/FitnessGenieAI
https://fitnessgenieai.com
https://twitter.com/FitnessGenieAI
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract FitnessGenieAI is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Fitness Genie AI";
string private constant _symbol = "$FITG";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 10000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 5;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 5;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
address payable private _developmentAddress = payable(msg.sender);
address payable private _marketingAddress = payable(msg.sender);
address private uniswapRouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = true;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = _tTotal*3/100;
uint256 public _maxWalletSize = _tTotal*20/1000;
uint256 public _swapTokensAtAmount = _tTotal*1/10000;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function manualsend() external {
}
function manualSwap(uint256 percent) external {
}
function toggleSwap (bool _swapEnabled) external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
require(<FILL_ME>)
}
//Set maximum transaction
function setMaxTxnAndWalletSize(uint256 maxTxAmount, uint256 maxWalletSize) public onlyOwner {
}
}
| _redisFeeOnBuy+_redisFeeOnSell+_taxFeeOnBuy+_taxFeeOnSell<=30 | 513,736 | _redisFeeOnBuy+_redisFeeOnSell+_taxFeeOnBuy+_taxFeeOnSell<=30 |
"Exceeded max public mint amount" | pragma solidity ^0.8.0;
/**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account.
*/
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* 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`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
/**
* @dev Private function to add a token to this extension's ownership-tracking data structures.
* @param to address representing the new owner of the given token ID
* @param tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
/**
* @dev Private function to add a token to this extension's token tracking data structures.
* @param tokenId uint256 ID of the token to be added to the tokens list
*/
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
/**
* @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
* while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
* gas optimizations e.g. when performing a transfer operation (avoiding double writes).
* This has O(1) time complexity, but alters the order of the _ownedTokens array.
* @param from address representing the previous owner of the given token ID
* @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
/**
* @dev Private function to remove a token from this extension's token tracking data structures.
* This has O(1) time complexity, but alters the order of the _allTokens array.
* @param tokenId uint256 ID of the token to be removed from the tokens list
*/
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
pragma solidity >=0.7.0 <0.9.0;
contract REDPILL is ERC721Enumerable, Ownable {
using Strings for uint256;
uint256 private startingTokenIndex = 1;
string public baseURI = "ipfs://QmXngQRRMKCPjPHYXxRSbz2JwgLwRYwBfbQrn91UN9H9wF";
uint256 public maxSupply = 100;
bool public paused = false;
uint256 public maxMintAmount = 1;
mapping(address => uint256 ) private addressMinted;
constructor(
) ERC721("REDPILL", "REDPILL") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
modifier mintCompliance() {
require(!paused, "Minting is paused");
require(<FILL_ME>)
_;
}
function publicMint() external payable mintCompliance() {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function pause(bool _state) external onlyOwner {
}
function withdraw() external payable onlyOwner {
}
}
| addressMinted[msg.sender]<maxMintAmount,"Exceeded max public mint amount" | 513,856 | addressMinted[msg.sender]<maxMintAmount |
"Exceeded max supply" | pragma solidity ^0.8.0;
/**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account.
*/
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* 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`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
/**
* @dev Private function to add a token to this extension's ownership-tracking data structures.
* @param to address representing the new owner of the given token ID
* @param tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
/**
* @dev Private function to add a token to this extension's token tracking data structures.
* @param tokenId uint256 ID of the token to be added to the tokens list
*/
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
/**
* @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
* while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
* gas optimizations e.g. when performing a transfer operation (avoiding double writes).
* This has O(1) time complexity, but alters the order of the _ownedTokens array.
* @param from address representing the previous owner of the given token ID
* @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
/**
* @dev Private function to remove a token from this extension's token tracking data structures.
* This has O(1) time complexity, but alters the order of the _allTokens array.
* @param tokenId uint256 ID of the token to be removed from the tokens list
*/
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
pragma solidity >=0.7.0 <0.9.0;
contract REDPILL is ERC721Enumerable, Ownable {
using Strings for uint256;
uint256 private startingTokenIndex = 1;
string public baseURI = "ipfs://QmXngQRRMKCPjPHYXxRSbz2JwgLwRYwBfbQrn91UN9H9wF";
uint256 public maxSupply = 100;
bool public paused = false;
uint256 public maxMintAmount = 1;
mapping(address => uint256 ) private addressMinted;
constructor(
) ERC721("REDPILL", "REDPILL") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
modifier mintCompliance() {
}
function publicMint() external payable mintCompliance() {
require(<FILL_ME>)
addressMinted[msg.sender] += maxMintAmount;
_safeMint(msg.sender, startingTokenIndex+totalSupply());
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function pause(bool _state) external onlyOwner {
}
function withdraw() external payable onlyOwner {
}
}
| totalSupply()+maxMintAmount<=maxSupply,"Exceeded max supply" | 513,856 | totalSupply()+maxMintAmount<=maxSupply |
"Maximum supply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "ERC20.sol";
abstract contract Ownable {
address owner;
event OwnerSet(address indexed oldOwner, address indexed newOwner);
modifier isOwner() {
}
}
contract RicherOwner is ERC20, Ownable {
uint256 private maxSupply = 1 * 10**decimals();
modifier isWorth() {
}
constructor() ERC20("Rich OWNer", "ROWN") {
}
function changeOwner(address newOwner) public isOwner {
}
/**
* @dev Function to mint new tokens and
* transfer ownership to sender who is richer than the current contract owner
*/
function setRicherOwner(uint value) internal {
uint curr_balance = address(this).balance;
uint256 number_to_mint = value/getPrice();
require(<FILL_ME>)
_mint(msg.sender, number_to_mint);
if(value > curr_balance-value) {
(bool sent, ) = owner.call{value: curr_balance/2 }(""); //transfer half to previous owner as compensation
if(sent) {
emit OwnerSet(owner, msg.sender);
owner = msg.sender;
}
}
}
function worth() external isOwner isWorth {
}
function burn(uint amount) public {
}
/**
* @dev Get price of new tokens
* Price will keep increasing when totalSupply increased due to new tokens mint
*/
function getPrice() public view returns (uint256 price) {
}
fallback () external payable {}
receive () external payable {
}
}
| (totalSupply()+number_to_mint)<=maxSupply,"Maximum supply exceeded" | 514,018 | (totalSupply()+number_to_mint)<=maxSupply |
"Insufficient redeemable balance" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../interfaces/IMintableBurnableERC20.sol";
import "../interfaces/ITreasury.sol";
import "../interfaces/IPreBluejayToken.sol";
import "./MerkleDistributor.sol";
/// @title PreBluejayToken
/// @author Bluejay Core Team
/// @notice PreBluejayToken is the contract for the pBLU token. The token is a
/// non-transferable token that can be redeemed for underlying BLU tokens. The
/// redemption ratio is proportional to the current total supply of the BLU token
/// against the targeted total supply of BLU tokens. The contract allows a mimimal
/// level of tokens to be redeemed by each account for initial liquidity.
/// ie If the target supply is 50M and the current supply is 10M, users will be
/// able to redeem 1/5 of their pBLU tokens as BLU tokens.
/// @dev The pBLU token is not an ERC20 token
contract PreBluejayToken is Ownable, MerkleDistributor, IPreBluejayToken {
uint256 constant WAD = 10**18;
/// @notice The contract address of the treasury, for minting BLU
ITreasury public immutable treasury;
/// @notice The contract address of the BLU token
IMintableBurnableERC20 public immutable BLU;
/// @notice Target BLU total supply when all pBLU are vested, in WAD
uint256 public immutable bluSupplyTarget;
/// @notice Amount claimable that does not require vesting, in WAD
uint256 public immutable vestingThreshold;
/// @notice Flag to pause contract
bool public paused;
/// @notice Mapping of addresses to allocated pBLU, in WAD
mapping(address => uint256) public quota;
/// @notice Mapping of addresses to redeemed pBLU, in WAD
mapping(address => uint256) public redeemed;
/// @notice Constructor to initialize the contract
/// @param _BLU Address of the BLU token
/// @param _treasury Address of the treasury
/// @param _merkleRoot Merkle root of the distribution
/// @param _bluSupplyTarget Target BLU total supply when all pBLU are vested, in WAD
/// @param _vestingThreshold Amount claimable that does not require vesting, in WAD
constructor(
address _BLU,
address _treasury,
bytes32 _merkleRoot,
uint256 _bluSupplyTarget,
uint256 _vestingThreshold
) {
}
// =============================== PUBLIC FUNCTIONS =================================
/// @notice Claims pBLU tokens
/// @dev The parameters of the function should come from the merkle distribution file.
/// @param index Index of the distribution
/// @param account Account where the distribution is credited to
/// @param amount Amount of pBLU allocated in the distribution, in WAD
/// @param merkleProof Array of bytes32s representing the merkle proof of the distribution
function claimQuota(
uint256 index,
address account,
uint256 amount,
bytes32[] calldata merkleProof
) public override {
}
/// @notice Redeem BLU token against pBLU tokens
/// @dev During redemption, the quota does not change. Instead the redeemed amount is
/// updated to reflect amount of pBLU redeemed.
/// @param amount Amount of BLU tokens to redeem
/// @param recipient Address where the BLU tokens will be sent to
function redeem(uint256 amount, address recipient) public override {
require(!paused, "Redemption paused");
require(<FILL_ME>)
redeemed[msg.sender] += amount;
treasury.mint(recipient, amount);
emit Redeemed(msg.sender, recipient, amount);
}
// =============================== VIEW FUNCTIONS =================================
/// @notice Gets the overall vesting progress
/// @return progress The vesting progress, in WAD
function vestingProgress() public view override returns (uint256) {
}
/// @notice Gets the amount of BLU that can be redeemed for a given address
/// @param account Address to get the redeemable balance for
/// @return redeemableAmount Amount of BLU that can be redeemed, in WAD
function redeemableTokens(address account)
public
view
override
returns (uint256)
{
}
// =============================== ADMIN FUNCTIONS =================================
/// @notice Pause and unpause the contract
/// @param _paused True to pause, false to unpause
function setPause(bool _paused) public onlyOwner {
}
/// @notice Set the merkle root for the distribution
/// @dev Setting the merkle root after distribution has begun may result in unintended consequences
/// @param _merkleRoot New merkle root of the distribution
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
}
| redeemableTokens(msg.sender)>=amount,"Insufficient redeemable balance" | 514,342 | redeemableTokens(msg.sender)>=amount |