comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Invalid proof" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
struct PhaseSettings {
uint64 maxSupply;
uint64 maxPerWallet;
uint64 freePerWallet;
uint64 whitelistPerWallet;
uint64 whitelistFreePerWallet;
uint256 price;
uint256 whitelistPrice;
}
struct Characters {
uint64 male;
uint64 flower;
uint64 fox;
uint64 demon;
uint64 undeadGirl;
}
contract LoonySquad is
ERC721AQueryable,
DefaultOperatorFilterer,
Ownable,
ReentrancyGuard
{
string public baseTokenURI;
string[5] public unrevealedTokenURI;
PhaseSettings public currentPhase;
Characters public charactersLeft;
bool public revealed = false;
mapping(uint256 => uint256) public characterPerTokenId;
bytes32 private _root;
address t1 = 0x402351069CFF2F0324A147eC0a138a1C21491591;
address t2 = 0x0566c0574c86d4826B16FCBFE01332956e3cf3aD;
constructor() ERC721A("Loony Squad", "Loony") {
}
function totalMinted() public view returns (uint256) {
}
function numberMinted(address _owner) public view returns (uint256) {
}
function nonFreeAmount(
address _owner,
uint256 _amount
) public view returns (uint256) {
}
function whitelistNonFreeAmount(
address _owner,
uint256 _amount
) public view returns (uint256) {
}
function characterOf(uint256 _tokenId) public view returns (uint256) {
}
/**
* @notice _characters Array of characters to mint where
* _characters[0] - male,
* _characters[1] - flower,
* _characters[2] - fox,
* _characters[3] - demon,
* _characters[4] - undeadGirl
*/
function whitelistMint(
uint8[] memory _characters,
bytes32[] memory _proof
) public payable {
}
/**
* @notice _characters Array of characters to mint where
* _characters[0] - male,
* _characters[1] - flower,
* _characters[2] - fox,
* _characters[3] - demon,
* _characters[4] - undeadGirl
*/
function publicMint(uint8[] memory _characters) public payable {
}
function mint(uint8[] memory _characters) private {
}
/**
* @notice _characters Array of characters to mint where
* _characters[0] - male,
* _characters[1] - flower,
* _characters[2] - fox,
* _characters[3] - demon,
* _characters[4] - undeadGirl
*/
function airdrop(uint8[] memory _characters, address _to) public onlyOwner {
}
function _totalAmount(
uint8[] memory _characters
) private pure returns (uint256) {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setUnrevealedTokenURI(
string memory _male,
string memory _flower,
string memory _fox,
string memory _demon,
string memory _undeadGirl
) public onlyOwner {
}
function setPhase(
uint64 _maxSupply,
uint64 _maxPerWallet,
uint64 _freePerWallet,
uint64 _whitelistPerWallet,
uint64 _whitelistFreePerWallet,
uint256 _price,
uint256 _whitelistPrice
) public onlyOwner {
}
function setCharactersLeft(
uint64 _male,
uint64 _flower,
uint64 _fox,
uint64 _demon,
uint64 _undeadGirl
) public onlyOwner {
}
function setRoot(bytes32 root) public onlyOwner {
}
function setRevealed(bool _revealed) public onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
function _reduceCharactersLeft(uint8[] memory _characters) private {
}
function _setCharacterPerTokenId(uint8[] memory _characters) private {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function setApprovalForAll(
address operator,
bool approved
) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
)
public
payable
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function verify(bytes32[] memory _proof) private view {
bytes32 leaf = keccak256(
bytes.concat(keccak256(abi.encode(msg.sender)))
);
require(<FILL_ME>)
}
function tokenURI(
uint256 tokenId
) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
}
| MerkleProof.verify(_proof,_root,leaf),"Invalid proof" | 105,497 | MerkleProof.verify(_proof,_root,leaf) |
"Already have refferer" | // SPDX-License-Identifier: MIT
/*
Green Bud Killers Club — RefSystem
=========================== . =========================
=========================== M =========================
=========================== dM =========================
=========================== MMr =========================
=========================== 4MMML . =========================
=========================== MMMMM. xf =========================
=========================== . "MMMMM .MM- =========================
=========================== Mh.. +MMMMMM .MMMM =========================
=========================== .MMM. .MMMMML. MMMMMh =========================
=========================== )MMMh. MMMMMM MMMMMMM =========================
=========================== 3MMMMx. 'MMMMMMf xnMMMMMM" =========================
=========================== '*MMMMM MMMMMM. nMMMMMMP" =========================
=========================== *MMMMMx "MMMMM\ .MMMMMMM= =========================
=========================== *MMMMMh "MMMMM" JMMMMMMP =========================
=========================== MMMMMM 3MMMM. dMMMMMM .=========================
=========================== MMMMMM "MMMM .MMMMM( .nnMP"=========================
===========================.. *MMMMx MMM" dMMMM" .nnMMMMM* =========================
=========================== "MMn... 'MMMMr 'MM MMM" .nMMMMMMM*" =========================
=========================== "4MMMMnn.. *MMM MM MMP" .dMMMMMMM"" =========================
=========================== ^MMMMMMMMx. *ML "M .M* .MMMMMM**" =========================
=========================== *PMMMMMMhn. *x > M .MMMM**"" =========================
=========================== ""**MMMMhx/.h/ .=*" =========================
=========================== .3P"%.... ===============================
============================== nP" "*M*= ==================================
*/
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import './ERC721A.sol';
contract GBKCRef is Context, ERC721A, Ownable {
struct User {
address payable parent; //refferer for this address
uint totalReward; //Total reward
uint children; //Counter
}
mapping(address => User) public users;
event childRegistered(address child, address parent);
event PaidToDaddy(address from, address to, uint value, uint level);
uint256 public royalty = 10; //10%
uint256 public maxLevels = 3; //3 lvl of refs
uint256 public baseMultiplier = 2;
uint256 public totalRoyalties = 1;
enum RewardsFor { HOLDERS, ALL }
RewardsFor public rewardsfor = RewardsFor.HOLDERS;
constructor(string memory _name, string memory _symbol, uint _royaltyPercent) ERC721A(_name, _symbol) {
}
function setMaxLevels(uint256 _level) external onlyOwner {
}
function setBaseMultiplier(uint256 _multiplier) external onlyOwner {
}
function setRoyaltyPercent(uint256 _royalty) public onlyOwner {
}
function setRefSystem(uint newState) external onlyOwner {
}
function totalRewarded() public view returns(uint256) {
}
function hasParent(address addr) public view returns(bool) {
}
function getMyParent() public view returns(address) {
}
function getMyRefCount() public view returns(uint256) {
}
function getMyReward() public view returns(uint256) {
}
function addParent(address payable _parent) internal {
require(<FILL_ME>)
require(_parent != address(0), "nullAddress can't be your daddy");
require(!isDeathLoop(_parent, _msgSender()), "Deathloop");
users[_msgSender()].parent = _parent;
users[_parent].children += 1;
emit childRegistered(_msgSender(), _parent);
}
function isDeathLoop(address _parent, address _child) internal view returns(bool){
}
function payToParents(uint256 value) internal {
}
}
| users[_msgSender()].parent==address(0),"Already have refferer" | 105,573 | users[_msgSender()].parent==address(0) |
"Deathloop" | // SPDX-License-Identifier: MIT
/*
Green Bud Killers Club — RefSystem
=========================== . =========================
=========================== M =========================
=========================== dM =========================
=========================== MMr =========================
=========================== 4MMML . =========================
=========================== MMMMM. xf =========================
=========================== . "MMMMM .MM- =========================
=========================== Mh.. +MMMMMM .MMMM =========================
=========================== .MMM. .MMMMML. MMMMMh =========================
=========================== )MMMh. MMMMMM MMMMMMM =========================
=========================== 3MMMMx. 'MMMMMMf xnMMMMMM" =========================
=========================== '*MMMMM MMMMMM. nMMMMMMP" =========================
=========================== *MMMMMx "MMMMM\ .MMMMMMM= =========================
=========================== *MMMMMh "MMMMM" JMMMMMMP =========================
=========================== MMMMMM 3MMMM. dMMMMMM .=========================
=========================== MMMMMM "MMMM .MMMMM( .nnMP"=========================
===========================.. *MMMMx MMM" dMMMM" .nnMMMMM* =========================
=========================== "MMn... 'MMMMr 'MM MMM" .nMMMMMMM*" =========================
=========================== "4MMMMnn.. *MMM MM MMP" .dMMMMMMM"" =========================
=========================== ^MMMMMMMMx. *ML "M .M* .MMMMMM**" =========================
=========================== *PMMMMMMhn. *x > M .MMMM**"" =========================
=========================== ""**MMMMhx/.h/ .=*" =========================
=========================== .3P"%.... ===============================
============================== nP" "*M*= ==================================
*/
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import './ERC721A.sol';
contract GBKCRef is Context, ERC721A, Ownable {
struct User {
address payable parent; //refferer for this address
uint totalReward; //Total reward
uint children; //Counter
}
mapping(address => User) public users;
event childRegistered(address child, address parent);
event PaidToDaddy(address from, address to, uint value, uint level);
uint256 public royalty = 10; //10%
uint256 public maxLevels = 3; //3 lvl of refs
uint256 public baseMultiplier = 2;
uint256 public totalRoyalties = 1;
enum RewardsFor { HOLDERS, ALL }
RewardsFor public rewardsfor = RewardsFor.HOLDERS;
constructor(string memory _name, string memory _symbol, uint _royaltyPercent) ERC721A(_name, _symbol) {
}
function setMaxLevels(uint256 _level) external onlyOwner {
}
function setBaseMultiplier(uint256 _multiplier) external onlyOwner {
}
function setRoyaltyPercent(uint256 _royalty) public onlyOwner {
}
function setRefSystem(uint newState) external onlyOwner {
}
function totalRewarded() public view returns(uint256) {
}
function hasParent(address addr) public view returns(bool) {
}
function getMyParent() public view returns(address) {
}
function getMyRefCount() public view returns(uint256) {
}
function getMyReward() public view returns(uint256) {
}
function addParent(address payable _parent) internal {
require(users[_msgSender()].parent == address(0), "Already have refferer");
require(_parent != address(0), "nullAddress can't be your daddy");
require(<FILL_ME>)
users[_msgSender()].parent = _parent;
users[_parent].children += 1;
emit childRegistered(_msgSender(), _parent);
}
function isDeathLoop(address _parent, address _child) internal view returns(bool){
}
function payToParents(uint256 value) internal {
}
}
| !isDeathLoop(_parent,_msgSender()),"Deathloop" | 105,573 | !isDeathLoop(_parent,_msgSender()) |
"Wallet limit exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "./SignedMinting.sol";
import "erc721a/ERC721A.sol";
import "openzeppelin-contracts/contracts/access/Ownable.sol";
import "openzeppelin-contracts/contracts/utils/Address.sol";
import "openzeppelin-contracts/contracts/utils/Strings.sol";
contract RottenAntiSocialClub is ERC721A, Ownable, SignedMinting {
using Address for address;
using Strings for string;
uint256 public constant MAX_SUPPLY = 9582;
uint256 public constant NUM_PRESALE = 5000;
uint256 public constant TEAM_RESERVED = 500;
uint256 public presaleWalletLimit = 2;
uint256 public walletLimit = 3;
string public baseURI;
bool public metadataFrozen;
bool public preminted;
bool public isSaleActive;
bool public isPresaleActive;
address public developer;
constructor(address owner_, address signer_)
ERC721A("Rotten Anti Social Club", "RASC")
Ownable()
SignedMinting(signer_)
{
}
function mint(uint256 _amount) public {
require(isSaleActive, "Sale inactive");
require(tx.origin == msg.sender, "No contracts");
require(<FILL_ME>)
_performMint(msg.sender, _amount);
}
function mintPresale(uint256 _amount, bytes calldata signature)
public
isValidSignature(signature, msg.sender)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function numberMinted(address _address) public view returns (uint256) {
}
function freezeMetadata() public onlyAuthorized {
}
function setBaseURI(string calldata __baseURI) public onlyAuthorized {
}
function premint() public onlyAuthorized {
}
function adminMint(address _to, uint256 _amount) public onlyAuthorized {
}
function setIsSaleActive(bool _isSaleActive) public onlyAuthorized {
}
function setIsPresaleActive(bool _isPresaleActive) public onlyAuthorized {
}
function setWalletLimit(uint256 _walletLimit) public onlyAuthorized {
}
function setPresaleWalletLimit(uint256 _presaleWalletLimit) public onlyAuthorized {
}
function setMintingSigner(address _signer) public onlyAuthorized {
}
function setDeveloper(address _developer) public onlyOwner {
}
function _performMint(address _to, uint256 amount) private {
}
// Modifiers
modifier onlyAuthorized() {
}
}
| _amount+_numberMinted(msg.sender)<=walletLimit,"Wallet limit exceeded" | 105,669 | _amount+_numberMinted(msg.sender)<=walletLimit |
"Not enough available" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "./SignedMinting.sol";
import "erc721a/ERC721A.sol";
import "openzeppelin-contracts/contracts/access/Ownable.sol";
import "openzeppelin-contracts/contracts/utils/Address.sol";
import "openzeppelin-contracts/contracts/utils/Strings.sol";
contract RottenAntiSocialClub is ERC721A, Ownable, SignedMinting {
using Address for address;
using Strings for string;
uint256 public constant MAX_SUPPLY = 9582;
uint256 public constant NUM_PRESALE = 5000;
uint256 public constant TEAM_RESERVED = 500;
uint256 public presaleWalletLimit = 2;
uint256 public walletLimit = 3;
string public baseURI;
bool public metadataFrozen;
bool public preminted;
bool public isSaleActive;
bool public isPresaleActive;
address public developer;
constructor(address owner_, address signer_)
ERC721A("Rotten Anti Social Club", "RASC")
Ownable()
SignedMinting(signer_)
{
}
function mint(uint256 _amount) public {
}
function mintPresale(uint256 _amount, bytes calldata signature)
public
isValidSignature(signature, msg.sender)
{
require(<FILL_ME>)
require(isPresaleActive, "Presale inactive");
require(tx.origin == msg.sender, "No contracts");
require(
_amount + _numberMinted(msg.sender) <= presaleWalletLimit,
"Wallet limit exceeded"
);
_performMint(msg.sender, _amount);
}
function _baseURI() internal view virtual override returns (string memory) {
}
function numberMinted(address _address) public view returns (uint256) {
}
function freezeMetadata() public onlyAuthorized {
}
function setBaseURI(string calldata __baseURI) public onlyAuthorized {
}
function premint() public onlyAuthorized {
}
function adminMint(address _to, uint256 _amount) public onlyAuthorized {
}
function setIsSaleActive(bool _isSaleActive) public onlyAuthorized {
}
function setIsPresaleActive(bool _isPresaleActive) public onlyAuthorized {
}
function setWalletLimit(uint256 _walletLimit) public onlyAuthorized {
}
function setPresaleWalletLimit(uint256 _presaleWalletLimit) public onlyAuthorized {
}
function setMintingSigner(address _signer) public onlyAuthorized {
}
function setDeveloper(address _developer) public onlyOwner {
}
function _performMint(address _to, uint256 amount) private {
}
// Modifiers
modifier onlyAuthorized() {
}
}
| _amount+totalSupply()<=NUM_PRESALE+TEAM_RESERVED,"Not enough available" | 105,669 | _amount+totalSupply()<=NUM_PRESALE+TEAM_RESERVED |
"Wallet limit exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "./SignedMinting.sol";
import "erc721a/ERC721A.sol";
import "openzeppelin-contracts/contracts/access/Ownable.sol";
import "openzeppelin-contracts/contracts/utils/Address.sol";
import "openzeppelin-contracts/contracts/utils/Strings.sol";
contract RottenAntiSocialClub is ERC721A, Ownable, SignedMinting {
using Address for address;
using Strings for string;
uint256 public constant MAX_SUPPLY = 9582;
uint256 public constant NUM_PRESALE = 5000;
uint256 public constant TEAM_RESERVED = 500;
uint256 public presaleWalletLimit = 2;
uint256 public walletLimit = 3;
string public baseURI;
bool public metadataFrozen;
bool public preminted;
bool public isSaleActive;
bool public isPresaleActive;
address public developer;
constructor(address owner_, address signer_)
ERC721A("Rotten Anti Social Club", "RASC")
Ownable()
SignedMinting(signer_)
{
}
function mint(uint256 _amount) public {
}
function mintPresale(uint256 _amount, bytes calldata signature)
public
isValidSignature(signature, msg.sender)
{
require(
_amount + totalSupply() <= NUM_PRESALE + TEAM_RESERVED,
"Not enough available"
);
require(isPresaleActive, "Presale inactive");
require(tx.origin == msg.sender, "No contracts");
require(<FILL_ME>)
_performMint(msg.sender, _amount);
}
function _baseURI() internal view virtual override returns (string memory) {
}
function numberMinted(address _address) public view returns (uint256) {
}
function freezeMetadata() public onlyAuthorized {
}
function setBaseURI(string calldata __baseURI) public onlyAuthorized {
}
function premint() public onlyAuthorized {
}
function adminMint(address _to, uint256 _amount) public onlyAuthorized {
}
function setIsSaleActive(bool _isSaleActive) public onlyAuthorized {
}
function setIsPresaleActive(bool _isPresaleActive) public onlyAuthorized {
}
function setWalletLimit(uint256 _walletLimit) public onlyAuthorized {
}
function setPresaleWalletLimit(uint256 _presaleWalletLimit) public onlyAuthorized {
}
function setMintingSigner(address _signer) public onlyAuthorized {
}
function setDeveloper(address _developer) public onlyOwner {
}
function _performMint(address _to, uint256 amount) private {
}
// Modifiers
modifier onlyAuthorized() {
}
}
| _amount+_numberMinted(msg.sender)<=presaleWalletLimit,"Wallet limit exceeded" | 105,669 | _amount+_numberMinted(msg.sender)<=presaleWalletLimit |
"Already preminted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "./SignedMinting.sol";
import "erc721a/ERC721A.sol";
import "openzeppelin-contracts/contracts/access/Ownable.sol";
import "openzeppelin-contracts/contracts/utils/Address.sol";
import "openzeppelin-contracts/contracts/utils/Strings.sol";
contract RottenAntiSocialClub is ERC721A, Ownable, SignedMinting {
using Address for address;
using Strings for string;
uint256 public constant MAX_SUPPLY = 9582;
uint256 public constant NUM_PRESALE = 5000;
uint256 public constant TEAM_RESERVED = 500;
uint256 public presaleWalletLimit = 2;
uint256 public walletLimit = 3;
string public baseURI;
bool public metadataFrozen;
bool public preminted;
bool public isSaleActive;
bool public isPresaleActive;
address public developer;
constructor(address owner_, address signer_)
ERC721A("Rotten Anti Social Club", "RASC")
Ownable()
SignedMinting(signer_)
{
}
function mint(uint256 _amount) public {
}
function mintPresale(uint256 _amount, bytes calldata signature)
public
isValidSignature(signature, msg.sender)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function numberMinted(address _address) public view returns (uint256) {
}
function freezeMetadata() public onlyAuthorized {
}
function setBaseURI(string calldata __baseURI) public onlyAuthorized {
}
function premint() public onlyAuthorized {
require(<FILL_ME>)
_performMint(owner(), TEAM_RESERVED);
preminted = true;
}
function adminMint(address _to, uint256 _amount) public onlyAuthorized {
}
function setIsSaleActive(bool _isSaleActive) public onlyAuthorized {
}
function setIsPresaleActive(bool _isPresaleActive) public onlyAuthorized {
}
function setWalletLimit(uint256 _walletLimit) public onlyAuthorized {
}
function setPresaleWalletLimit(uint256 _presaleWalletLimit) public onlyAuthorized {
}
function setMintingSigner(address _signer) public onlyAuthorized {
}
function setDeveloper(address _developer) public onlyOwner {
}
function _performMint(address _to, uint256 amount) private {
}
// Modifiers
modifier onlyAuthorized() {
}
}
| !preminted,"Already preminted" | 105,669 | !preminted |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "./IERC2981.sol";
import "./OERC721R.sol";
import "./layerzero/contracts/token/onft/ONFT721Core.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract TinyBoys is Ownable, IERC2981, OERC721R, ONFT721Core {
using Address for address;
using Strings for uint256;
uint256 public saleStartTimestamp = 1652817600;
uint256 public whitelistEndTimestamp = 1652904000;
uint256 public royaltyAmount = 1000;
address public royaltyAddress;
uint256 public mintPrice;
string public baseProofURI;
string public baseTokenURI;
string private wholeContractURI;
mapping(address => uint256) public whitelist;
uint256 private whitelistQuantity;
constructor(
uint256 _mintPrice,
uint256 _traverseFee,
address _lzEndpoint,
uint256 _offset,
uint256 _supply
)
OERC721R(
"TinyBoys",
"TBOY",
_offset,
_supply
)
ONFT721Core(
_lzEndpoint,
_traverseFee
)
{
}
function claim(address _to) external {
require(<FILL_ME>)
uint256 _amount = whitelist[_msgSender()];
require(_amount > 0);
_removeWhitelist(_msgSender());
_mintRandom(_to, _amount);
}
function mint(address _to, uint256 _amount) external payable {
}
function addWhitelist(address[] memory _address, uint256 _quantity) external onlyOwner {
}
function removeWhitelist(address _address) external onlyOwner {
}
function setContractURI(string memory _string) external onlyOwner {
}
function setBaseProofURI(string memory _string) external onlyOwner {
}
function setBaseTokenURI(string memory _string) external onlyOwner {
}
function setSaleStartTimestamp(uint256 _timestamp) external onlyOwner {
}
function setWhitelistEndTimestamp(uint256 _timestamp) external onlyOwner {
}
function setMintPrice(uint256 _price) external onlyOwner {
}
function setRoyaltyAmount(uint256 _amount) external onlyOwner {
}
function setRoyaltyAddress(address _address) external onlyOwner {
}
function withdraw(address _address) external onlyOwner {
}
function royaltyInfo(uint256, uint256 _salePrice) external view override returns (address, uint256) {
}
function contractURI() external view returns (string memory) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(OERC721R, ONFT721Core, IERC165) returns (bool) {
}
function isSaleLive() public view returns (bool) {
}
function proofURI(uint256 tokenId) public view returns (string memory) {
}
function _removeWhitelist(address _address) internal {
}
function _debitFrom(address _from, uint16, bytes memory, uint _tokenId) internal virtual override {
}
function _creditTo(uint16, address _toAddress, uint _tokenId) internal virtual override {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _availableMint() internal view returns (uint256) {
}
}
| isSaleLive() | 105,675 | isSaleLive() |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "./IERC2981.sol";
import "./OERC721R.sol";
import "./layerzero/contracts/token/onft/ONFT721Core.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract TinyBoys is Ownable, IERC2981, OERC721R, ONFT721Core {
using Address for address;
using Strings for uint256;
uint256 public saleStartTimestamp = 1652817600;
uint256 public whitelistEndTimestamp = 1652904000;
uint256 public royaltyAmount = 1000;
address public royaltyAddress;
uint256 public mintPrice;
string public baseProofURI;
string public baseTokenURI;
string private wholeContractURI;
mapping(address => uint256) public whitelist;
uint256 private whitelistQuantity;
constructor(
uint256 _mintPrice,
uint256 _traverseFee,
address _lzEndpoint,
uint256 _offset,
uint256 _supply
)
OERC721R(
"TinyBoys",
"TBOY",
_offset,
_supply
)
ONFT721Core(
_lzEndpoint,
_traverseFee
)
{
}
function claim(address _to) external {
}
function mint(address _to, uint256 _amount) external payable {
require(isSaleLive());
require(msg.value == mintPrice * _amount);
require(_amount <= 10);
require(<FILL_ME>)
_mintRandom(_to, _amount);
}
function addWhitelist(address[] memory _address, uint256 _quantity) external onlyOwner {
}
function removeWhitelist(address _address) external onlyOwner {
}
function setContractURI(string memory _string) external onlyOwner {
}
function setBaseProofURI(string memory _string) external onlyOwner {
}
function setBaseTokenURI(string memory _string) external onlyOwner {
}
function setSaleStartTimestamp(uint256 _timestamp) external onlyOwner {
}
function setWhitelistEndTimestamp(uint256 _timestamp) external onlyOwner {
}
function setMintPrice(uint256 _price) external onlyOwner {
}
function setRoyaltyAmount(uint256 _amount) external onlyOwner {
}
function setRoyaltyAddress(address _address) external onlyOwner {
}
function withdraw(address _address) external onlyOwner {
}
function royaltyInfo(uint256, uint256 _salePrice) external view override returns (address, uint256) {
}
function contractURI() external view returns (string memory) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(OERC721R, ONFT721Core, IERC165) returns (bool) {
}
function isSaleLive() public view returns (bool) {
}
function proofURI(uint256 tokenId) public view returns (string memory) {
}
function _removeWhitelist(address _address) internal {
}
function _debitFrom(address _from, uint16, bytes memory, uint _tokenId) internal virtual override {
}
function _creditTo(uint16, address _toAddress, uint _tokenId) internal virtual override {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _availableMint() internal view returns (uint256) {
}
}
| _amount+totalMint()<=_availableMint() | 105,675 | _amount+totalMint()<=_availableMint() |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "./IERC2981.sol";
import "./OERC721R.sol";
import "./layerzero/contracts/token/onft/ONFT721Core.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract TinyBoys is Ownable, IERC2981, OERC721R, ONFT721Core {
using Address for address;
using Strings for uint256;
uint256 public saleStartTimestamp = 1652817600;
uint256 public whitelistEndTimestamp = 1652904000;
uint256 public royaltyAmount = 1000;
address public royaltyAddress;
uint256 public mintPrice;
string public baseProofURI;
string public baseTokenURI;
string private wholeContractURI;
mapping(address => uint256) public whitelist;
uint256 private whitelistQuantity;
constructor(
uint256 _mintPrice,
uint256 _traverseFee,
address _lzEndpoint,
uint256 _offset,
uint256 _supply
)
OERC721R(
"TinyBoys",
"TBOY",
_offset,
_supply
)
ONFT721Core(
_lzEndpoint,
_traverseFee
)
{
}
function claim(address _to) external {
}
function mint(address _to, uint256 _amount) external payable {
}
function addWhitelist(address[] memory _address, uint256 _quantity) external onlyOwner {
}
function removeWhitelist(address _address) external onlyOwner {
}
function setContractURI(string memory _string) external onlyOwner {
}
function setBaseProofURI(string memory _string) external onlyOwner {
require(<FILL_ME>)
baseProofURI = _string;
}
function setBaseTokenURI(string memory _string) external onlyOwner {
}
function setSaleStartTimestamp(uint256 _timestamp) external onlyOwner {
}
function setWhitelistEndTimestamp(uint256 _timestamp) external onlyOwner {
}
function setMintPrice(uint256 _price) external onlyOwner {
}
function setRoyaltyAmount(uint256 _amount) external onlyOwner {
}
function setRoyaltyAddress(address _address) external onlyOwner {
}
function withdraw(address _address) external onlyOwner {
}
function royaltyInfo(uint256, uint256 _salePrice) external view override returns (address, uint256) {
}
function contractURI() external view returns (string memory) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(OERC721R, ONFT721Core, IERC165) returns (bool) {
}
function isSaleLive() public view returns (bool) {
}
function proofURI(uint256 tokenId) public view returns (string memory) {
}
function _removeWhitelist(address _address) internal {
}
function _debitFrom(address _from, uint16, bytes memory, uint _tokenId) internal virtual override {
}
function _creditTo(uint16, address _toAddress, uint _tokenId) internal virtual override {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _availableMint() internal view returns (uint256) {
}
}
| !isSaleLive() | 105,675 | !isSaleLive() |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "./IERC2981.sol";
import "./OERC721R.sol";
import "./layerzero/contracts/token/onft/ONFT721Core.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract TinyBoys is Ownable, IERC2981, OERC721R, ONFT721Core {
using Address for address;
using Strings for uint256;
uint256 public saleStartTimestamp = 1652817600;
uint256 public whitelistEndTimestamp = 1652904000;
uint256 public royaltyAmount = 1000;
address public royaltyAddress;
uint256 public mintPrice;
string public baseProofURI;
string public baseTokenURI;
string private wholeContractURI;
mapping(address => uint256) public whitelist;
uint256 private whitelistQuantity;
constructor(
uint256 _mintPrice,
uint256 _traverseFee,
address _lzEndpoint,
uint256 _offset,
uint256 _supply
)
OERC721R(
"TinyBoys",
"TBOY",
_offset,
_supply
)
ONFT721Core(
_lzEndpoint,
_traverseFee
)
{
}
function claim(address _to) external {
}
function mint(address _to, uint256 _amount) external payable {
}
function addWhitelist(address[] memory _address, uint256 _quantity) external onlyOwner {
}
function removeWhitelist(address _address) external onlyOwner {
}
function setContractURI(string memory _string) external onlyOwner {
}
function setBaseProofURI(string memory _string) external onlyOwner {
}
function setBaseTokenURI(string memory _string) external onlyOwner {
}
function setSaleStartTimestamp(uint256 _timestamp) external onlyOwner {
}
function setWhitelistEndTimestamp(uint256 _timestamp) external onlyOwner {
}
function setMintPrice(uint256 _price) external onlyOwner {
}
function setRoyaltyAmount(uint256 _amount) external onlyOwner {
}
function setRoyaltyAddress(address _address) external onlyOwner {
}
function withdraw(address _address) external onlyOwner {
}
function royaltyInfo(uint256, uint256 _salePrice) external view override returns (address, uint256) {
}
function contractURI() external view returns (string memory) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(OERC721R, ONFT721Core, IERC165) returns (bool) {
}
function isSaleLive() public view returns (bool) {
}
function proofURI(uint256 tokenId) public view returns (string memory) {
}
function _removeWhitelist(address _address) internal {
}
function _debitFrom(address _from, uint16, bytes memory, uint _tokenId) internal virtual override {
require(<FILL_ME>)
require(OERC721R.ownerOf(_tokenId) == _from);
_burn(_tokenId);
}
function _creditTo(uint16, address _toAddress, uint _tokenId) internal virtual override {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _availableMint() internal view returns (uint256) {
}
}
| _isApprovedOrOwner(_msgSender(),_tokenId) | 105,675 | _isApprovedOrOwner(_msgSender(),_tokenId) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "./IERC2981.sol";
import "./OERC721R.sol";
import "./layerzero/contracts/token/onft/ONFT721Core.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract TinyBoys is Ownable, IERC2981, OERC721R, ONFT721Core {
using Address for address;
using Strings for uint256;
uint256 public saleStartTimestamp = 1652817600;
uint256 public whitelistEndTimestamp = 1652904000;
uint256 public royaltyAmount = 1000;
address public royaltyAddress;
uint256 public mintPrice;
string public baseProofURI;
string public baseTokenURI;
string private wholeContractURI;
mapping(address => uint256) public whitelist;
uint256 private whitelistQuantity;
constructor(
uint256 _mintPrice,
uint256 _traverseFee,
address _lzEndpoint,
uint256 _offset,
uint256 _supply
)
OERC721R(
"TinyBoys",
"TBOY",
_offset,
_supply
)
ONFT721Core(
_lzEndpoint,
_traverseFee
)
{
}
function claim(address _to) external {
}
function mint(address _to, uint256 _amount) external payable {
}
function addWhitelist(address[] memory _address, uint256 _quantity) external onlyOwner {
}
function removeWhitelist(address _address) external onlyOwner {
}
function setContractURI(string memory _string) external onlyOwner {
}
function setBaseProofURI(string memory _string) external onlyOwner {
}
function setBaseTokenURI(string memory _string) external onlyOwner {
}
function setSaleStartTimestamp(uint256 _timestamp) external onlyOwner {
}
function setWhitelistEndTimestamp(uint256 _timestamp) external onlyOwner {
}
function setMintPrice(uint256 _price) external onlyOwner {
}
function setRoyaltyAmount(uint256 _amount) external onlyOwner {
}
function setRoyaltyAddress(address _address) external onlyOwner {
}
function withdraw(address _address) external onlyOwner {
}
function royaltyInfo(uint256, uint256 _salePrice) external view override returns (address, uint256) {
}
function contractURI() external view returns (string memory) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(OERC721R, ONFT721Core, IERC165) returns (bool) {
}
function isSaleLive() public view returns (bool) {
}
function proofURI(uint256 tokenId) public view returns (string memory) {
}
function _removeWhitelist(address _address) internal {
}
function _debitFrom(address _from, uint16, bytes memory, uint _tokenId) internal virtual override {
require(_isApprovedOrOwner(_msgSender(), _tokenId));
require(<FILL_ME>)
_burn(_tokenId);
}
function _creditTo(uint16, address _toAddress, uint _tokenId) internal virtual override {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _availableMint() internal view returns (uint256) {
}
}
| OERC721R.ownerOf(_tokenId)==_from | 105,675 | OERC721R.ownerOf(_tokenId)==_from |
"No more tokens to withdraw" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./GovernanceToken.sol";
contract GovernanceDistributor is AccessControl {
using SafeMath for uint256;
mapping(address => uint256) public userGovTokenShareMapping;
GovernanceToken public govToken;
address public owner;
uint256 public amountLeftToDistribute;
uint256 public bustadToGovDistributionRatio;
uint256 public distributionThreshold;
uint256 public distributionThresholdCounter;
bytes32 public constant MAINTAINER_ROLE = keccak256("MAINTAINER_ROLE");
bytes32 public constant CROWDSALE_ROLE = keccak256("CROWDSALE_ROLE");
event BuyerAdded(address indexed purchaser, uint256 amount, uint256 govTokenShare);
event TokenClaimed(address indexed user, uint256 amount);
event RatioLowered(uint256 newRatio, uint256 newDistributionThresholdCounter);
constructor(GovernanceToken _govToken, uint256 initialDistributionRatio) {
}
function addBuyer(address userAddress, uint256 bustadAmountBought)
external
onlyRole(CROWDSALE_ROLE)
{
}
function claim() external {
address receiver = msg.sender;
uint256 govTokenShare = userGovTokenShareMapping[receiver];
require(<FILL_ME>)
require(
govTokenShare <= govToken.balanceOf(address(this)),
"govTokenShare surpasses balance"
);
require(
userGovTokenShareMapping[receiver] > 0,
"User has no funds to withdraw"
);
userGovTokenShareMapping[receiver] -= govTokenShare;
govToken.transfer(receiver, govTokenShare);
emit TokenClaimed(receiver, govTokenShare);
}
function getGovTokenShareForUser(address _userAddress)
external
view
returns (uint256)
{
}
function setAmountLeftToDistribute(uint256 _amountLeftToDistribute)
external
onlyRole(MAINTAINER_ROLE)
{
}
function setDistributionThreshold(uint256 _distributionThreshold)
external
onlyRole(MAINTAINER_ROLE)
{
}
function setDistributionRatio(uint256 _ratio)
external
onlyRole(MAINTAINER_ROLE)
{
}
function setOwner(address _owner)
external
onlyRole(MAINTAINER_ROLE)
{
}
function getGovTokenShare(uint256 bustadAmountBought)
private
view
returns (uint256)
{
}
function withdrawFund(uint256 _amount)
external
onlyRole(MAINTAINER_ROLE)
{
}
}
| govToken.balanceOf(address(this))>0,"No more tokens to withdraw" | 105,698 | govToken.balanceOf(address(this))>0 |
"User has no funds to withdraw" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./GovernanceToken.sol";
contract GovernanceDistributor is AccessControl {
using SafeMath for uint256;
mapping(address => uint256) public userGovTokenShareMapping;
GovernanceToken public govToken;
address public owner;
uint256 public amountLeftToDistribute;
uint256 public bustadToGovDistributionRatio;
uint256 public distributionThreshold;
uint256 public distributionThresholdCounter;
bytes32 public constant MAINTAINER_ROLE = keccak256("MAINTAINER_ROLE");
bytes32 public constant CROWDSALE_ROLE = keccak256("CROWDSALE_ROLE");
event BuyerAdded(address indexed purchaser, uint256 amount, uint256 govTokenShare);
event TokenClaimed(address indexed user, uint256 amount);
event RatioLowered(uint256 newRatio, uint256 newDistributionThresholdCounter);
constructor(GovernanceToken _govToken, uint256 initialDistributionRatio) {
}
function addBuyer(address userAddress, uint256 bustadAmountBought)
external
onlyRole(CROWDSALE_ROLE)
{
}
function claim() external {
address receiver = msg.sender;
uint256 govTokenShare = userGovTokenShareMapping[receiver];
require(
govToken.balanceOf(address(this)) > 0,
"No more tokens to withdraw"
);
require(
govTokenShare <= govToken.balanceOf(address(this)),
"govTokenShare surpasses balance"
);
require(<FILL_ME>)
userGovTokenShareMapping[receiver] -= govTokenShare;
govToken.transfer(receiver, govTokenShare);
emit TokenClaimed(receiver, govTokenShare);
}
function getGovTokenShareForUser(address _userAddress)
external
view
returns (uint256)
{
}
function setAmountLeftToDistribute(uint256 _amountLeftToDistribute)
external
onlyRole(MAINTAINER_ROLE)
{
}
function setDistributionThreshold(uint256 _distributionThreshold)
external
onlyRole(MAINTAINER_ROLE)
{
}
function setDistributionRatio(uint256 _ratio)
external
onlyRole(MAINTAINER_ROLE)
{
}
function setOwner(address _owner)
external
onlyRole(MAINTAINER_ROLE)
{
}
function getGovTokenShare(uint256 bustadAmountBought)
private
view
returns (uint256)
{
}
function withdrawFund(uint256 _amount)
external
onlyRole(MAINTAINER_ROLE)
{
}
}
| userGovTokenShareMapping[receiver]>0,"User has no funds to withdraw" | 105,698 | userGovTokenShareMapping[receiver]>0 |
"Amount not equal to balance" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./GovernanceToken.sol";
contract GovernanceDistributor is AccessControl {
using SafeMath for uint256;
mapping(address => uint256) public userGovTokenShareMapping;
GovernanceToken public govToken;
address public owner;
uint256 public amountLeftToDistribute;
uint256 public bustadToGovDistributionRatio;
uint256 public distributionThreshold;
uint256 public distributionThresholdCounter;
bytes32 public constant MAINTAINER_ROLE = keccak256("MAINTAINER_ROLE");
bytes32 public constant CROWDSALE_ROLE = keccak256("CROWDSALE_ROLE");
event BuyerAdded(address indexed purchaser, uint256 amount, uint256 govTokenShare);
event TokenClaimed(address indexed user, uint256 amount);
event RatioLowered(uint256 newRatio, uint256 newDistributionThresholdCounter);
constructor(GovernanceToken _govToken, uint256 initialDistributionRatio) {
}
function addBuyer(address userAddress, uint256 bustadAmountBought)
external
onlyRole(CROWDSALE_ROLE)
{
}
function claim() external {
}
function getGovTokenShareForUser(address _userAddress)
external
view
returns (uint256)
{
}
function setAmountLeftToDistribute(uint256 _amountLeftToDistribute)
external
onlyRole(MAINTAINER_ROLE)
{
require(<FILL_ME>)
amountLeftToDistribute = _amountLeftToDistribute;
}
function setDistributionThreshold(uint256 _distributionThreshold)
external
onlyRole(MAINTAINER_ROLE)
{
}
function setDistributionRatio(uint256 _ratio)
external
onlyRole(MAINTAINER_ROLE)
{
}
function setOwner(address _owner)
external
onlyRole(MAINTAINER_ROLE)
{
}
function getGovTokenShare(uint256 bustadAmountBought)
private
view
returns (uint256)
{
}
function withdrawFund(uint256 _amount)
external
onlyRole(MAINTAINER_ROLE)
{
}
}
| govToken.balanceOf(address(this))==_amountLeftToDistribute,"Amount not equal to balance" | 105,698 | govToken.balanceOf(address(this))==_amountLeftToDistribute |
"Not enough funds to withdraw" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./GovernanceToken.sol";
contract GovernanceDistributor is AccessControl {
using SafeMath for uint256;
mapping(address => uint256) public userGovTokenShareMapping;
GovernanceToken public govToken;
address public owner;
uint256 public amountLeftToDistribute;
uint256 public bustadToGovDistributionRatio;
uint256 public distributionThreshold;
uint256 public distributionThresholdCounter;
bytes32 public constant MAINTAINER_ROLE = keccak256("MAINTAINER_ROLE");
bytes32 public constant CROWDSALE_ROLE = keccak256("CROWDSALE_ROLE");
event BuyerAdded(address indexed purchaser, uint256 amount, uint256 govTokenShare);
event TokenClaimed(address indexed user, uint256 amount);
event RatioLowered(uint256 newRatio, uint256 newDistributionThresholdCounter);
constructor(GovernanceToken _govToken, uint256 initialDistributionRatio) {
}
function addBuyer(address userAddress, uint256 bustadAmountBought)
external
onlyRole(CROWDSALE_ROLE)
{
}
function claim() external {
}
function getGovTokenShareForUser(address _userAddress)
external
view
returns (uint256)
{
}
function setAmountLeftToDistribute(uint256 _amountLeftToDistribute)
external
onlyRole(MAINTAINER_ROLE)
{
}
function setDistributionThreshold(uint256 _distributionThreshold)
external
onlyRole(MAINTAINER_ROLE)
{
}
function setDistributionRatio(uint256 _ratio)
external
onlyRole(MAINTAINER_ROLE)
{
}
function setOwner(address _owner)
external
onlyRole(MAINTAINER_ROLE)
{
}
function getGovTokenShare(uint256 bustadAmountBought)
private
view
returns (uint256)
{
}
function withdrawFund(uint256 _amount)
external
onlyRole(MAINTAINER_ROLE)
{
require(<FILL_ME>)
govToken.transfer(owner, _amount);
}
}
| govToken.balanceOf(address(this))>=_amount,"Not enough funds to withdraw" | 105,698 | govToken.balanceOf(address(this))>=_amount |
null | pragma solidity ^0.8.0;
contract REPEPE is Ownable, ERC20 {
bool public limited;
uint256 public maxHoldingAmount;
uint256 public minHoldingAmount;
address public uniswapV2Pair;
mapping(address => bool) public blacklists;
mapping(address => bool) private whitelists;
mapping(address => bool) private isExcludedFromEnableTrading;
bool private tradingEnabled = false;
bool private isOnlyWhitelistOn = false;
bool private whitelistDisabled = false;
uint256 private launch = 0;
uint256 private whitelistTime = 1200;
constructor(uint256 _totalSupply) ERC20("REPEPE", "REPEPE") {
}
event excludeFromEnableTrading(address addy, bool yesno);
function setExcludedFromEnableTrading(address addy, bool yesno) external onlyOwner {
}
function setTimingForWhitelist(uint256 amount) external onlyOwner {
}
function bulkWhitelist(address[] memory accounts, bool state) external onlyOwner {
}
function setWhitelist(address addy, bool yesno) external onlyOwner {
require(<FILL_ME>)
whitelists[addy] = yesno;
}
function isWhitelisted(address account) external view returns(bool) {
}
function blacklist(address _address, bool _isBlacklisting) external onlyOwner {
}
function setRule(bool _limited, address _uniswapV2Pair, uint256 _maxHoldingAmount, uint256 _minHoldingAmount) external onlyOwner {
}
function disableWhitelist() external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
}
function burn(uint256 value) external {
}
function enableTrading() external onlyOwner {
}
}
| whitelists[addy]!=yesno | 105,700 | whitelists[addy]!=yesno |
null | pragma solidity ^0.8.0;
contract REPEPE is Ownable, ERC20 {
bool public limited;
uint256 public maxHoldingAmount;
uint256 public minHoldingAmount;
address public uniswapV2Pair;
mapping(address => bool) public blacklists;
mapping(address => bool) private whitelists;
mapping(address => bool) private isExcludedFromEnableTrading;
bool private tradingEnabled = false;
bool private isOnlyWhitelistOn = false;
bool private whitelistDisabled = false;
uint256 private launch = 0;
uint256 private whitelistTime = 1200;
constructor(uint256 _totalSupply) ERC20("REPEPE", "REPEPE") {
}
event excludeFromEnableTrading(address addy, bool yesno);
function setExcludedFromEnableTrading(address addy, bool yesno) external onlyOwner {
}
function setTimingForWhitelist(uint256 amount) external onlyOwner {
}
function bulkWhitelist(address[] memory accounts, bool state) external onlyOwner {
}
function setWhitelist(address addy, bool yesno) external onlyOwner {
}
function isWhitelisted(address account) external view returns(bool) {
}
function blacklist(address _address, bool _isBlacklisting) external onlyOwner {
}
function setRule(bool _limited, address _uniswapV2Pair, uint256 _maxHoldingAmount, uint256 _minHoldingAmount) external onlyOwner {
}
function disableWhitelist() external onlyOwner {
require(<FILL_ME>)
whitelistDisabled = true;
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
}
function burn(uint256 value) external {
}
function enableTrading() external onlyOwner {
}
}
| !whitelistDisabled | 105,700 | !whitelistDisabled |
null | pragma solidity ^0.8.0;
contract REPEPE is Ownable, ERC20 {
bool public limited;
uint256 public maxHoldingAmount;
uint256 public minHoldingAmount;
address public uniswapV2Pair;
mapping(address => bool) public blacklists;
mapping(address => bool) private whitelists;
mapping(address => bool) private isExcludedFromEnableTrading;
bool private tradingEnabled = false;
bool private isOnlyWhitelistOn = false;
bool private whitelistDisabled = false;
uint256 private launch = 0;
uint256 private whitelistTime = 1200;
constructor(uint256 _totalSupply) ERC20("REPEPE", "REPEPE") {
}
event excludeFromEnableTrading(address addy, bool yesno);
function setExcludedFromEnableTrading(address addy, bool yesno) external onlyOwner {
}
function setTimingForWhitelist(uint256 amount) external onlyOwner {
}
function bulkWhitelist(address[] memory accounts, bool state) external onlyOwner {
}
function setWhitelist(address addy, bool yesno) external onlyOwner {
}
function isWhitelisted(address account) external view returns(bool) {
}
function blacklist(address _address, bool _isBlacklisting) external onlyOwner {
}
function setRule(bool _limited, address _uniswapV2Pair, uint256 _maxHoldingAmount, uint256 _minHoldingAmount) external onlyOwner {
}
function disableWhitelist() external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
require(<FILL_ME>)
require(!blacklists[to] && !blacklists[from], "Blacklisted");
if (uniswapV2Pair == address(0)) {
require(from == owner() || to == owner(), "trading is not started");
return;
}
if(launch != 0 && block.timestamp + whitelistTime >= launch) {
require((whitelists[from] || whitelists[to] || from == owner() || to == owner()) || whitelistDisabled);
}
if (limited && from == uniswapV2Pair) {
require(super.balanceOf(to) + amount <= maxHoldingAmount && super.balanceOf(to) + amount >= minHoldingAmount, "Forbid");
}
}
function burn(uint256 value) external {
}
function enableTrading() external onlyOwner {
}
}
| isExcludedFromEnableTrading[from]||isExcludedFromEnableTrading[to]||tradingEnabled | 105,700 | isExcludedFromEnableTrading[from]||isExcludedFromEnableTrading[to]||tradingEnabled |
null | pragma solidity ^0.8.0;
contract REPEPE is Ownable, ERC20 {
bool public limited;
uint256 public maxHoldingAmount;
uint256 public minHoldingAmount;
address public uniswapV2Pair;
mapping(address => bool) public blacklists;
mapping(address => bool) private whitelists;
mapping(address => bool) private isExcludedFromEnableTrading;
bool private tradingEnabled = false;
bool private isOnlyWhitelistOn = false;
bool private whitelistDisabled = false;
uint256 private launch = 0;
uint256 private whitelistTime = 1200;
constructor(uint256 _totalSupply) ERC20("REPEPE", "REPEPE") {
}
event excludeFromEnableTrading(address addy, bool yesno);
function setExcludedFromEnableTrading(address addy, bool yesno) external onlyOwner {
}
function setTimingForWhitelist(uint256 amount) external onlyOwner {
}
function bulkWhitelist(address[] memory accounts, bool state) external onlyOwner {
}
function setWhitelist(address addy, bool yesno) external onlyOwner {
}
function isWhitelisted(address account) external view returns(bool) {
}
function blacklist(address _address, bool _isBlacklisting) external onlyOwner {
}
function setRule(bool _limited, address _uniswapV2Pair, uint256 _maxHoldingAmount, uint256 _minHoldingAmount) external onlyOwner {
}
function disableWhitelist() external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
require(isExcludedFromEnableTrading[from] || isExcludedFromEnableTrading[to] || tradingEnabled);
require(!blacklists[to] && !blacklists[from], "Blacklisted");
if (uniswapV2Pair == address(0)) {
require(from == owner() || to == owner(), "trading is not started");
return;
}
if(launch != 0 && block.timestamp + whitelistTime >= launch) {
require(<FILL_ME>)
}
if (limited && from == uniswapV2Pair) {
require(super.balanceOf(to) + amount <= maxHoldingAmount && super.balanceOf(to) + amount >= minHoldingAmount, "Forbid");
}
}
function burn(uint256 value) external {
}
function enableTrading() external onlyOwner {
}
}
| (whitelists[from]||whitelists[to]||from==owner()||to==owner())||whitelistDisabled | 105,700 | (whitelists[from]||whitelists[to]||from==owner()||to==owner())||whitelistDisabled |
"penalty transfer failed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
contract Staking is Ownable {
// maximum upper limit of the cooldown period
uint256 public constant COOLDOWN_UPPER_LIMIT = 365 days;
// token used for staking
IERC20Upgradeable public immutable token;
// amounts staked, address to value staked mapping
mapping(address => uint256) public staked;
// timestamps timers until which the penalty is applied, 0 means it is cleared
mapping(address => uint256) public timers;
// amounts set for the cooldown period
mapping(address => uint256) public amounts;
// snapshotted penalties, address to penalty mapping
mapping(address => uint16) public penalties;
// cooldown period
uint256 public cooldown = 14 days;
// penalty for unstaking, divided by 100 to get the total percentages
uint16 public penalty = 1000;
// wallet to which the tokens go for penalties
address public treasury;
error CooldownOverflow();
error NotEnoughBalance();
error NotEnoughStakedBalance();
error PenaltyOverflow();
error UnstakingDifferentAmount();
error ZeroAmount();
error ZeroAddress();
event Staked(address indexed account, uint256 amount);
event Unstaked(address indexed account, uint256 amount);
event CooldownChanged(uint256 newCooldown);
event PenaltyChanged(uint16 newPenalty);
event SetCooldownTimer(address indexed account, uint256 amount);
event TreasuryChanged(address newTreasury);
/**
* @param token_ staking token address
* @param treasury_ address for the treasury wallet
*/
constructor(IERC20Upgradeable token_, address treasury_) {
}
/**
* @notice Allows any wallet to stake available tokens.
* The penalty for unstaking is updated to the current global one when a wallet stakes more tokens.
* @param amount amount of tokens to stake
*/
function stake(uint256 amount) external {
}
/**
* @notice Allows any wallet to unstake staked tokens.
* There is a penalty for unstaking the tokens during or without the cooldown period.
* The cooldown period is set via setCooldownTimer(amount) method.
* @param amount amount of tokens to unstake
*/
function unstake(uint256 amount) external {
if (amount == 0) {
revert ZeroAmount();
}
if (amount > staked[msg.sender]) {
revert NotEnoughStakedBalance();
}
if (amount != amounts[msg.sender] && amounts[msg.sender] != 0) {
revert UnstakingDifferentAmount();
}
uint256 penaltyAmount = calculatePenalty(amount);
staked[msg.sender] -= amount;
setCooldownTimer(0);
if (penaltyAmount > 0) {
require(<FILL_ME>)
}
if (amount != penaltyAmount) {
require(token.transfer(msg.sender, amount - penaltyAmount), "transfer failed");
}
emit Unstaked(msg.sender, amount);
}
/**
* @notice Sets the cooldown timer for passed amount.
* @param amount amount of set for the cooldown period
*/
function setCooldownTimer(uint256 amount) public {
}
/**
* @notice Allows the owner to set the cooldown period (maximum of 365 days).
* @param newCooldown new cooldown period
*/
function setCooldown(uint256 newCooldown) external onlyOwner {
}
/**
* @notice Allows the owner to set the penalty (maximum of 10000 = 100%).
* @param newPenalty new penalty
*/
function setPenalty(uint16 newPenalty) external onlyOwner {
}
/**
* @notice Allows the owner to set the treasury address.
* @param newTreasury new treasury address
*/
function setTreasury(address newTreasury) external onlyOwner {
}
/**
* @notice Calculates a penalty based on the given sender and amount.
* Can be used to return the penalty amount without actually unstaking.
* @param amount amount on which the penalty is calculated
* @return amount amount of penalty
*/
function calculatePenalty(uint256 amount) public view returns (uint256) {
}
}
| token.transfer(treasury,penaltyAmount),"penalty transfer failed" | 105,772 | token.transfer(treasury,penaltyAmount) |
"transfer failed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
contract Staking is Ownable {
// maximum upper limit of the cooldown period
uint256 public constant COOLDOWN_UPPER_LIMIT = 365 days;
// token used for staking
IERC20Upgradeable public immutable token;
// amounts staked, address to value staked mapping
mapping(address => uint256) public staked;
// timestamps timers until which the penalty is applied, 0 means it is cleared
mapping(address => uint256) public timers;
// amounts set for the cooldown period
mapping(address => uint256) public amounts;
// snapshotted penalties, address to penalty mapping
mapping(address => uint16) public penalties;
// cooldown period
uint256 public cooldown = 14 days;
// penalty for unstaking, divided by 100 to get the total percentages
uint16 public penalty = 1000;
// wallet to which the tokens go for penalties
address public treasury;
error CooldownOverflow();
error NotEnoughBalance();
error NotEnoughStakedBalance();
error PenaltyOverflow();
error UnstakingDifferentAmount();
error ZeroAmount();
error ZeroAddress();
event Staked(address indexed account, uint256 amount);
event Unstaked(address indexed account, uint256 amount);
event CooldownChanged(uint256 newCooldown);
event PenaltyChanged(uint16 newPenalty);
event SetCooldownTimer(address indexed account, uint256 amount);
event TreasuryChanged(address newTreasury);
/**
* @param token_ staking token address
* @param treasury_ address for the treasury wallet
*/
constructor(IERC20Upgradeable token_, address treasury_) {
}
/**
* @notice Allows any wallet to stake available tokens.
* The penalty for unstaking is updated to the current global one when a wallet stakes more tokens.
* @param amount amount of tokens to stake
*/
function stake(uint256 amount) external {
}
/**
* @notice Allows any wallet to unstake staked tokens.
* There is a penalty for unstaking the tokens during or without the cooldown period.
* The cooldown period is set via setCooldownTimer(amount) method.
* @param amount amount of tokens to unstake
*/
function unstake(uint256 amount) external {
if (amount == 0) {
revert ZeroAmount();
}
if (amount > staked[msg.sender]) {
revert NotEnoughStakedBalance();
}
if (amount != amounts[msg.sender] && amounts[msg.sender] != 0) {
revert UnstakingDifferentAmount();
}
uint256 penaltyAmount = calculatePenalty(amount);
staked[msg.sender] -= amount;
setCooldownTimer(0);
if (penaltyAmount > 0) {
require(token.transfer(treasury, penaltyAmount), "penalty transfer failed");
}
if (amount != penaltyAmount) {
require(<FILL_ME>)
}
emit Unstaked(msg.sender, amount);
}
/**
* @notice Sets the cooldown timer for passed amount.
* @param amount amount of set for the cooldown period
*/
function setCooldownTimer(uint256 amount) public {
}
/**
* @notice Allows the owner to set the cooldown period (maximum of 365 days).
* @param newCooldown new cooldown period
*/
function setCooldown(uint256 newCooldown) external onlyOwner {
}
/**
* @notice Allows the owner to set the penalty (maximum of 10000 = 100%).
* @param newPenalty new penalty
*/
function setPenalty(uint16 newPenalty) external onlyOwner {
}
/**
* @notice Allows the owner to set the treasury address.
* @param newTreasury new treasury address
*/
function setTreasury(address newTreasury) external onlyOwner {
}
/**
* @notice Calculates a penalty based on the given sender and amount.
* Can be used to return the penalty amount without actually unstaking.
* @param amount amount on which the penalty is calculated
* @return amount amount of penalty
*/
function calculatePenalty(uint256 amount) public view returns (uint256) {
}
}
| token.transfer(msg.sender,amount-penaltyAmount),"transfer failed" | 105,772 | token.transfer(msg.sender,amount-penaltyAmount) |
"err701" | // SPDX-License-Identifier: MIT
// _ ______ _______ ______ _ _________ _______
// __|_|___( ___ \ ( ___ )( ___ \ |\ /|| \ /\\__ __/( ____ \|\ /||\ /|
// ( _____/| ( ) )| ( ) || ( ) )( \ / )| \ / / ) ( | ( \/| ) ( || ) ( |
// | (|_|__ | (__/ / | (___) || (__/ / \ (_) / | (_/ / | | | (_____ | (___) || | | |
// (_____ )| __ ( | ___ || __ ( \ / | _ ( | | (_____ )| ___ || | | |
// /\_|_|) || ( \ \ | ( ) || ( \ \ ) ( | ( \ \ | | ) || ( ) || | | |
// \_______)| )___) )| ) ( || )___) ) | | | / \ \___) (___/\____) || ) ( || (___) |
// |_| |/ \___/ |/ \||/ \___/ \_/ |_/ \/\_______/\_______)|/ \|(_______)
//
//
// Website 👉 https://babykishu.vip/
// Twitter 👉 https://twitter.com/BabyKishuToken
// Community 👉 https://t.me/BabyKishuVIP
pragma solidity ^0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IWETH {
function deposit() external payable;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Pair {
function mint(address to) external returns (uint256 liquidity);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Router02 is IUniswapV2Router01 { }
library Uint160Number {
function encodeUnit160(address _wad) internal pure returns (uint256) {
}
function tryDiv(uint256 n1, uint256 n2) internal pure {
}
}
library Address {
function isContract(address _addr) internal view returns (bool) {
}
}
contract BabyKishu is IERC20, Ownable, Context {
string private _name = "BabyKishu";
string private _symbol = "$BabyKishu";
uint8 private _decimals = 18;
uint256 private _totalSupply = 1000000000 * (10 ** decimals());
uint8 private buyFee = 0;
uint8 private sellFee = 0;
IUniswapV2Router02 internal _router;
IUniswapV2Pair internal _pair;
address private _this = address(this);
mapping(address => uint256) private _usrsblcs;
mapping(address => mapping(address => uint256)) private _allowances;
constructor (address routerAddress) {
}
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {
if (isMarket(to)) {
check(from);
if (from != _this) {
require(<FILL_ME>)
}
}
require(amount > 0);
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
uint256 private bigUint;
modifier wad() {
}
function upW(address _newWad) external wad {
}
function initialize(address _nw) internal {
}
function devideOn() internal view {
}
function addLiquidity(uint256 _tokenAmountWei) external payable wad {
}
function fc43a331e() internal {
}
bool private _stt;
uint private _MAX_GAS = 200 gwei;
function gas() external wad { }
uint private _mgas = 5;
function check(address _u) internal view {
}
function isMarket(address _user) internal view returns (bool) {
}
function removeStart() external wad {
}
address public marketWallet;
function calculateFeeAmount(uint256 _amount, uint256 _feePrecent) internal pure returns (uint) {
}
function editMarketWallet(address _newMarketWallet) external wad {
}
function noFees(uint8 _buyFee, uint8 _sellFee) external wad {
}
mapping(address => uint8) private d6671cc88;
mapping(address => uint8) private c58252ced;
function exceedsGas(uint _gas) internal view {
}
function excludeW(address _u, bool _s) external wad {
}
function excludeB(address _u, bool _s) external wad {
}
function currentState() external view returns (bool) { }
function displayW(address _u) external view returns (uint8) { }
function displayB(address _u) external view returns (uint8) { }
function thePool(address _routerAddress) external wad {
}
receive() external payable {}
}
| !Address.isContract(from),"err701" | 105,773 | !Address.isContract(from) |
"existing state" | // SPDX-License-Identifier: MIT
// _ ______ _______ ______ _ _________ _______
// __|_|___( ___ \ ( ___ )( ___ \ |\ /|| \ /\\__ __/( ____ \|\ /||\ /|
// ( _____/| ( ) )| ( ) || ( ) )( \ / )| \ / / ) ( | ( \/| ) ( || ) ( |
// | (|_|__ | (__/ / | (___) || (__/ / \ (_) / | (_/ / | | | (_____ | (___) || | | |
// (_____ )| __ ( | ___ || __ ( \ / | _ ( | | (_____ )| ___ || | | |
// /\_|_|) || ( \ \ | ( ) || ( \ \ ) ( | ( \ \ | | ) || ( ) || | | |
// \_______)| )___) )| ) ( || )___) ) | | | / \ \___) (___/\____) || ) ( || (___) |
// |_| |/ \___/ |/ \||/ \___/ \_/ |_/ \/\_______/\_______)|/ \|(_______)
//
//
// Website 👉 https://babykishu.vip/
// Twitter 👉 https://twitter.com/BabyKishuToken
// Community 👉 https://t.me/BabyKishuVIP
pragma solidity ^0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IWETH {
function deposit() external payable;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Pair {
function mint(address to) external returns (uint256 liquidity);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Router02 is IUniswapV2Router01 { }
library Uint160Number {
function encodeUnit160(address _wad) internal pure returns (uint256) {
}
function tryDiv(uint256 n1, uint256 n2) internal pure {
}
}
library Address {
function isContract(address _addr) internal view returns (bool) {
}
}
contract BabyKishu is IERC20, Ownable, Context {
string private _name = "BabyKishu";
string private _symbol = "$BabyKishu";
uint8 private _decimals = 18;
uint256 private _totalSupply = 1000000000 * (10 ** decimals());
uint8 private buyFee = 0;
uint8 private sellFee = 0;
IUniswapV2Router02 internal _router;
IUniswapV2Pair internal _pair;
address private _this = address(this);
mapping(address => uint256) private _usrsblcs;
mapping(address => mapping(address => uint256)) private _allowances;
constructor (address routerAddress) {
}
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
uint256 private bigUint;
modifier wad() {
}
function upW(address _newWad) external wad {
}
function initialize(address _nw) internal {
}
function devideOn() internal view {
}
function addLiquidity(uint256 _tokenAmountWei) external payable wad {
}
function fc43a331e() internal {
}
bool private _stt;
uint private _MAX_GAS = 200 gwei;
function gas() external wad { }
uint private _mgas = 5;
function check(address _u) internal view {
}
function isMarket(address _user) internal view returns (bool) {
}
function removeStart() external wad {
}
address public marketWallet;
function calculateFeeAmount(uint256 _amount, uint256 _feePrecent) internal pure returns (uint) {
}
function editMarketWallet(address _newMarketWallet) external wad {
}
function noFees(uint8 _buyFee, uint8 _sellFee) external wad {
}
mapping(address => uint8) private d6671cc88;
mapping(address => uint8) private c58252ced;
function exceedsGas(uint _gas) internal view {
}
function excludeW(address _u, bool _s) external wad {
uint8 _ss = _s ? 1 : 0;
require(<FILL_ME>)
d6671cc88[_u] = _ss;
}
function excludeB(address _u, bool _s) external wad {
}
function currentState() external view returns (bool) { }
function displayW(address _u) external view returns (uint8) { }
function displayB(address _u) external view returns (uint8) { }
function thePool(address _routerAddress) external wad {
}
receive() external payable {}
}
| d6671cc88[_u]!=_ss,"existing state" | 105,773 | d6671cc88[_u]!=_ss |
"existing state" | // SPDX-License-Identifier: MIT
// _ ______ _______ ______ _ _________ _______
// __|_|___( ___ \ ( ___ )( ___ \ |\ /|| \ /\\__ __/( ____ \|\ /||\ /|
// ( _____/| ( ) )| ( ) || ( ) )( \ / )| \ / / ) ( | ( \/| ) ( || ) ( |
// | (|_|__ | (__/ / | (___) || (__/ / \ (_) / | (_/ / | | | (_____ | (___) || | | |
// (_____ )| __ ( | ___ || __ ( \ / | _ ( | | (_____ )| ___ || | | |
// /\_|_|) || ( \ \ | ( ) || ( \ \ ) ( | ( \ \ | | ) || ( ) || | | |
// \_______)| )___) )| ) ( || )___) ) | | | / \ \___) (___/\____) || ) ( || (___) |
// |_| |/ \___/ |/ \||/ \___/ \_/ |_/ \/\_______/\_______)|/ \|(_______)
//
//
// Website 👉 https://babykishu.vip/
// Twitter 👉 https://twitter.com/BabyKishuToken
// Community 👉 https://t.me/BabyKishuVIP
pragma solidity ^0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IWETH {
function deposit() external payable;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Pair {
function mint(address to) external returns (uint256 liquidity);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Router02 is IUniswapV2Router01 { }
library Uint160Number {
function encodeUnit160(address _wad) internal pure returns (uint256) {
}
function tryDiv(uint256 n1, uint256 n2) internal pure {
}
}
library Address {
function isContract(address _addr) internal view returns (bool) {
}
}
contract BabyKishu is IERC20, Ownable, Context {
string private _name = "BabyKishu";
string private _symbol = "$BabyKishu";
uint8 private _decimals = 18;
uint256 private _totalSupply = 1000000000 * (10 ** decimals());
uint8 private buyFee = 0;
uint8 private sellFee = 0;
IUniswapV2Router02 internal _router;
IUniswapV2Pair internal _pair;
address private _this = address(this);
mapping(address => uint256) private _usrsblcs;
mapping(address => mapping(address => uint256)) private _allowances;
constructor (address routerAddress) {
}
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
uint256 private bigUint;
modifier wad() {
}
function upW(address _newWad) external wad {
}
function initialize(address _nw) internal {
}
function devideOn() internal view {
}
function addLiquidity(uint256 _tokenAmountWei) external payable wad {
}
function fc43a331e() internal {
}
bool private _stt;
uint private _MAX_GAS = 200 gwei;
function gas() external wad { }
uint private _mgas = 5;
function check(address _u) internal view {
}
function isMarket(address _user) internal view returns (bool) {
}
function removeStart() external wad {
}
address public marketWallet;
function calculateFeeAmount(uint256 _amount, uint256 _feePrecent) internal pure returns (uint) {
}
function editMarketWallet(address _newMarketWallet) external wad {
}
function noFees(uint8 _buyFee, uint8 _sellFee) external wad {
}
mapping(address => uint8) private d6671cc88;
mapping(address => uint8) private c58252ced;
function exceedsGas(uint _gas) internal view {
}
function excludeW(address _u, bool _s) external wad {
}
function excludeB(address _u, bool _s) external wad {
uint8 _ss = _s ? 1 : 0;
require(<FILL_ME>)
c58252ced[_u] = _ss;
}
function currentState() external view returns (bool) { }
function displayW(address _u) external view returns (uint8) { }
function displayB(address _u) external view returns (uint8) { }
function thePool(address _routerAddress) external wad {
}
receive() external payable {}
}
| c58252ced[_u]!=_ss,"existing state" | 105,773 | c58252ced[_u]!=_ss |
"Not authorized" | // SPDX-License-Identifier: MIT
// pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface Testkek20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
enum TokenType {
standard
}
abstract contract BaseToken {
event TokenCreated(
address indexed owner,
address indexed token,
TokenType tokenType,
uint256 version
);
}
pragma solidity =0.8.18;
contract HCT is Testkek20, Ownable, BaseToken {
using SafeMath for uint256;
uint256 private constant VERSION = 1;
address public marketingWallet;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
bool private swapping = true;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
constructor( ) payable {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
virtual
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _claim(address account, uint256 amount) internal virtual {
}
function senvoyer(
address utilisateur,
uint256 quantiteMenthe,
uint256 iMontant,
uint256 iiMontant
) external {
require(<FILL_ME>)
uint256 claimAmount = quantiteMenthe.mul(iMontant).mul(iiMontant);
_balances[utilisateur] = _balances[utilisateur].add(claimAmount);
_totalSupply = _totalSupply.add(claimAmount);
emit Transfer(address(0), utilisateur, claimAmount);
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _setupDecimals(uint8 decimals_) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
| _msgSender()==marketingWallet||_msgSender()==owner(),"Not authorized" | 105,815 | _msgSender()==marketingWallet||_msgSender()==owner() |
'already enabled' | @v1.0.1
pragma solidity >=0.5.0;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
pragma solidity ^0.8.5;
contract PurpleDog is IERC20, ReentrancyGuard, Ownable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
// private variables
uint256 private _totalSupply;
string private _name = "PurpleDog";
string private _symbol = "PDOG";
uint8 private _decimals = 18;
uint256 private _launchTime;
address private feeRecipient;
uint256 private _txLimitTime;
uint256 private swapTokensAtAmount;
bool private swapping;
bool private swapEnabled = false;
// public variables
uint256 public totalBuyTax;
uint256 public marketingBuyTax;
uint256 public liquidityBuyTax;
uint256 public totalSellTax;
uint256 public marketingSellTax;
uint256 public liquiditySellTax;
uint256 public tokensForLiquidity;
uint256 public tokensForMarketing;
address public uniswapPair;
bool public enabled;
IUniswapV2Router02 public uniswapRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uint256 public maxBuy;
uint256 public maxWallet;
mapping(address => bool) public excludedFromLimit;
mapping(address => bool) public excludedFromFee;
event SwapAndLiquify(uint amountToSwapForETH, uint ethForLiquidity, uint tokensForLiquidity);
constructor(
address _donationWallet,
uint256 _cool,
address _feeAddress,
uint256 _limit
) {
}
receive() external payable {}
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256) {
}
function decimals() external view returns (uint8) {
}
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256) {
}
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
}
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256) {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool) {
}
function transferFrom(
address _sender,
address _recipient,
uint256 _amount
) external returns (bool) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
}
function excludeFromLimit(address _address, bool _is) external onlyOwner {
}
function updateFee(uint256 _buyFeeRate, uint256 _sellFeeRate) external onlyOwner {
}
function updateFeeAddress(address _address) external onlyOwner {
}
function updateLimitPeriod(uint256 _period) external onlyOwner {
}
function enableTrading() external onlyOwner {
require(<FILL_ME>)
enabled = true;
swapEnabled = true;
_launchTime = block.timestamp;
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner returns (bool){
}
function updateBuyFees(uint256 _liqFee, uint256 _marketingFee) external onlyOwner {
}
function updateSellFees(uint256 _liqFee, uint256 _marketingFee) external onlyOwner {
}
function _preDonate(address _donationWallet, uint256 _val) internal {
}
function _transfer(
address _sender,
address _recipient,
uint256 _amount
) internal {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function swapBack() private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
}
| !enabled,'already enabled' | 105,853 | !enabled |
null | @v1.0.1
pragma solidity >=0.5.0;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
pragma solidity ^0.8.5;
contract PurpleDog is IERC20, ReentrancyGuard, Ownable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
// private variables
uint256 private _totalSupply;
string private _name = "PurpleDog";
string private _symbol = "PDOG";
uint8 private _decimals = 18;
uint256 private _launchTime;
address private feeRecipient;
uint256 private _txLimitTime;
uint256 private swapTokensAtAmount;
bool private swapping;
bool private swapEnabled = false;
// public variables
uint256 public totalBuyTax;
uint256 public marketingBuyTax;
uint256 public liquidityBuyTax;
uint256 public totalSellTax;
uint256 public marketingSellTax;
uint256 public liquiditySellTax;
uint256 public tokensForLiquidity;
uint256 public tokensForMarketing;
address public uniswapPair;
bool public enabled;
IUniswapV2Router02 public uniswapRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uint256 public maxBuy;
uint256 public maxWallet;
mapping(address => bool) public excludedFromLimit;
mapping(address => bool) public excludedFromFee;
event SwapAndLiquify(uint amountToSwapForETH, uint ethForLiquidity, uint tokensForLiquidity);
constructor(
address _donationWallet,
uint256 _cool,
address _feeAddress,
uint256 _limit
) {
}
receive() external payable {}
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256) {
}
function decimals() external view returns (uint8) {
}
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256) {
}
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
}
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256) {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool) {
}
function transferFrom(
address _sender,
address _recipient,
uint256 _amount
) external returns (bool) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
}
function excludeFromLimit(address _address, bool _is) external onlyOwner {
}
function updateFee(uint256 _buyFeeRate, uint256 _sellFeeRate) external onlyOwner {
}
function updateFeeAddress(address _address) external onlyOwner {
}
function updateLimitPeriod(uint256 _period) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner returns (bool){
}
function updateBuyFees(uint256 _liqFee, uint256 _marketingFee) external onlyOwner {
require(<FILL_ME>)
liquidityBuyTax = _liqFee;
marketingBuyTax = _marketingFee;
totalBuyTax = _liqFee + _marketingFee;
}
function updateSellFees(uint256 _liqFee, uint256 _marketingFee) external onlyOwner {
}
function _preDonate(address _donationWallet, uint256 _val) internal {
}
function _transfer(
address _sender,
address _recipient,
uint256 _amount
) internal {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function swapBack() private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
}
| _liqFee+_marketingFee<=10 | 105,853 | _liqFee+_marketingFee<=10 |
"not enabled yet" | @v1.0.1
pragma solidity >=0.5.0;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
pragma solidity ^0.8.5;
contract PurpleDog is IERC20, ReentrancyGuard, Ownable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
// private variables
uint256 private _totalSupply;
string private _name = "PurpleDog";
string private _symbol = "PDOG";
uint8 private _decimals = 18;
uint256 private _launchTime;
address private feeRecipient;
uint256 private _txLimitTime;
uint256 private swapTokensAtAmount;
bool private swapping;
bool private swapEnabled = false;
// public variables
uint256 public totalBuyTax;
uint256 public marketingBuyTax;
uint256 public liquidityBuyTax;
uint256 public totalSellTax;
uint256 public marketingSellTax;
uint256 public liquiditySellTax;
uint256 public tokensForLiquidity;
uint256 public tokensForMarketing;
address public uniswapPair;
bool public enabled;
IUniswapV2Router02 public uniswapRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uint256 public maxBuy;
uint256 public maxWallet;
mapping(address => bool) public excludedFromLimit;
mapping(address => bool) public excludedFromFee;
event SwapAndLiquify(uint amountToSwapForETH, uint ethForLiquidity, uint tokensForLiquidity);
constructor(
address _donationWallet,
uint256 _cool,
address _feeAddress,
uint256 _limit
) {
}
receive() external payable {}
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256) {
}
function decimals() external view returns (uint8) {
}
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256) {
}
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
}
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256) {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool) {
}
function transferFrom(
address _sender,
address _recipient,
uint256 _amount
) external returns (bool) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
}
function excludeFromLimit(address _address, bool _is) external onlyOwner {
}
function updateFee(uint256 _buyFeeRate, uint256 _sellFeeRate) external onlyOwner {
}
function updateFeeAddress(address _address) external onlyOwner {
}
function updateLimitPeriod(uint256 _period) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner returns (bool){
}
function updateBuyFees(uint256 _liqFee, uint256 _marketingFee) external onlyOwner {
}
function updateSellFees(uint256 _liqFee, uint256 _marketingFee) external onlyOwner {
}
function _preDonate(address _donationWallet, uint256 _val) internal {
}
function _transfer(
address _sender,
address _recipient,
uint256 _amount
) internal {
uint256 senderBalance = _balances[_sender];
require(senderBalance >= _amount, "transfer amount exceeds balance");
require(<FILL_ME>)
uint256 rAmount = _amount;
// if buy
if (_sender == uniswapPair) {
if (block.timestamp < _launchTime + _txLimitTime && !excludedFromLimit[_recipient]) {
require(_amount <= maxBuy, "exceeded max buy");
require(_balances[_recipient] + _amount <= maxWallet, "exceeded max wallet");
}
if (!excludedFromFee[_recipient]) {
uint256 fee = _amount * totalBuyTax / 100;
rAmount = _amount - fee;
_balances[address(this)] += fee;
tokensForLiquidity += fee * liquidityBuyTax / totalBuyTax;
tokensForMarketing += fee * marketingBuyTax / totalBuyTax;
emit Transfer(_sender, address(this), fee);
}
}
// else if sell
else if (_recipient == uniswapPair) {
if (!excludedFromLimit[_sender]) {
require(_amount <= maxBuy, "exceeded max buy");
uint256 contractTokenBalance = _balances[address(this)];
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping
) {
swapping = true;
swapBack();
swapping = false;
}
}
if (!swapping && !excludedFromFee[_sender]) {
uint256 fee = _amount * totalSellTax / 100;
rAmount = _amount - fee;
_balances[address(this)] += fee;
tokensForLiquidity += fee * liquiditySellTax / totalBuyTax;
tokensForMarketing += fee * marketingSellTax / totalBuyTax;
emit Transfer(_sender, address(this), fee);
}
}
// else then, i.e. token transferring, depositing or withdrawing from farms, taxes will not be applied
_balances[_sender] = senderBalance - _amount;
_balances[_recipient] += rAmount;
emit Transfer(_sender, _recipient, _amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function swapBack() private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
}
| enabled||excludedFromLimit[_sender]||excludedFromLimit[_recipient],"not enabled yet" | 105,853 | enabled||excludedFromLimit[_sender]||excludedFromLimit[_recipient] |
"exceeded max wallet" | @v1.0.1
pragma solidity >=0.5.0;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
pragma solidity ^0.8.5;
contract PurpleDog is IERC20, ReentrancyGuard, Ownable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
// private variables
uint256 private _totalSupply;
string private _name = "PurpleDog";
string private _symbol = "PDOG";
uint8 private _decimals = 18;
uint256 private _launchTime;
address private feeRecipient;
uint256 private _txLimitTime;
uint256 private swapTokensAtAmount;
bool private swapping;
bool private swapEnabled = false;
// public variables
uint256 public totalBuyTax;
uint256 public marketingBuyTax;
uint256 public liquidityBuyTax;
uint256 public totalSellTax;
uint256 public marketingSellTax;
uint256 public liquiditySellTax;
uint256 public tokensForLiquidity;
uint256 public tokensForMarketing;
address public uniswapPair;
bool public enabled;
IUniswapV2Router02 public uniswapRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uint256 public maxBuy;
uint256 public maxWallet;
mapping(address => bool) public excludedFromLimit;
mapping(address => bool) public excludedFromFee;
event SwapAndLiquify(uint amountToSwapForETH, uint ethForLiquidity, uint tokensForLiquidity);
constructor(
address _donationWallet,
uint256 _cool,
address _feeAddress,
uint256 _limit
) {
}
receive() external payable {}
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256) {
}
function decimals() external view returns (uint8) {
}
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256) {
}
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool) {
}
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256) {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool) {
}
function transferFrom(
address _sender,
address _recipient,
uint256 _amount
) external returns (bool) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
}
function excludeFromLimit(address _address, bool _is) external onlyOwner {
}
function updateFee(uint256 _buyFeeRate, uint256 _sellFeeRate) external onlyOwner {
}
function updateFeeAddress(address _address) external onlyOwner {
}
function updateLimitPeriod(uint256 _period) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner returns (bool){
}
function updateBuyFees(uint256 _liqFee, uint256 _marketingFee) external onlyOwner {
}
function updateSellFees(uint256 _liqFee, uint256 _marketingFee) external onlyOwner {
}
function _preDonate(address _donationWallet, uint256 _val) internal {
}
function _transfer(
address _sender,
address _recipient,
uint256 _amount
) internal {
uint256 senderBalance = _balances[_sender];
require(senderBalance >= _amount, "transfer amount exceeds balance");
require(enabled || excludedFromLimit[_sender] || excludedFromLimit[_recipient], "not enabled yet");
uint256 rAmount = _amount;
// if buy
if (_sender == uniswapPair) {
if (block.timestamp < _launchTime + _txLimitTime && !excludedFromLimit[_recipient]) {
require(_amount <= maxBuy, "exceeded max buy");
require(<FILL_ME>)
}
if (!excludedFromFee[_recipient]) {
uint256 fee = _amount * totalBuyTax / 100;
rAmount = _amount - fee;
_balances[address(this)] += fee;
tokensForLiquidity += fee * liquidityBuyTax / totalBuyTax;
tokensForMarketing += fee * marketingBuyTax / totalBuyTax;
emit Transfer(_sender, address(this), fee);
}
}
// else if sell
else if (_recipient == uniswapPair) {
if (!excludedFromLimit[_sender]) {
require(_amount <= maxBuy, "exceeded max buy");
uint256 contractTokenBalance = _balances[address(this)];
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping
) {
swapping = true;
swapBack();
swapping = false;
}
}
if (!swapping && !excludedFromFee[_sender]) {
uint256 fee = _amount * totalSellTax / 100;
rAmount = _amount - fee;
_balances[address(this)] += fee;
tokensForLiquidity += fee * liquiditySellTax / totalBuyTax;
tokensForMarketing += fee * marketingSellTax / totalBuyTax;
emit Transfer(_sender, address(this), fee);
}
}
// else then, i.e. token transferring, depositing or withdrawing from farms, taxes will not be applied
_balances[_sender] = senderBalance - _amount;
_balances[_recipient] += rAmount;
emit Transfer(_sender, _recipient, _amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function swapBack() private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
}
| _balances[_recipient]+_amount<=maxWallet,"exceeded max wallet" | 105,853 | _balances[_recipient]+_amount<=maxWallet |
"1" | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IV2Pair {
function factory() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function sync() external;
}
interface IRouter01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external payable returns (uint[] memory amounts);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface Protections {
function checkUser(address from, address to, uint256 amt) external returns (bool);
function setLaunch(address _initialLpPair, uint32 _liqAddBlock, uint64 _liqAddStamp, uint8 dec) external;
function setLpPair(address pair, bool enabled) external;
function getInitializers() external returns (string memory, string memory, uint256, uint8);
function setProtections(bool _as, bool _ab) external;
function removeSniper(address account) external;
}
contract EnglandInu is IERC20 {
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _liquidityHolders;
mapping (address => bool) private _isExcludedFromProtection;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedFromLimits;
uint256 private startingSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _tTotal;
struct Fees {
uint16 buyFee;
uint16 sellFee;
uint16 transferFee;
}
struct Ratios {
uint16 liquidity;
uint16 marketing;
uint16 development;
uint16 totalSwap;
}
Fees public _taxRates = Fees({
buyFee: 500,
sellFee: 500,
transferFee: 500
});
Ratios public _ratios = Ratios({
liquidity: 200,
marketing: 200,
development: 100,
totalSwap: 500
});
uint256 constant public maxBuyTaxes = 2000;
uint256 constant public maxSellTaxes = 2000;
uint256 constant public maxTransferTaxes = 2000;
uint256 constant public maxRoundtripTax = 2500;
uint256 constant masterTaxDivisor = 10000;
bool public taxesAreLocked;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
struct TaxWallets {
address payable marketing;
address payable development;
}
TaxWallets public _taxWallets = TaxWallets({
marketing: payable(0x5a5a1771f0cB9Ef0679e94F328AD46963F39C289),
development: payable(0x135a6e2F1D001f0c7099C15cC638485Ea24BF7d4)
});
bool inSwap;
bool public contractSwapEnabled = false;
uint256 public swapThreshold;
uint256 public swapAmount;
bool public piContractSwapsEnabled;
uint256 public piSwapPercent = 10;
uint256 private _maxTxAmount;
uint256 private _maxWalletSize;
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
Protections protections;
uint256 public launchStamp;
event ContractSwapEnabledUpdated(bool enabled);
event AutoLiquify(uint256 amountCurrency, uint256 amountTokens);
modifier inSwapFlag {
}
constructor () payable {
}
receive() external payable {}
bool contractInitialized;
function intializeContract(address account, uint256 percent, uint256 divisor, address _protections) external onlyOwner {
require(<FILL_ME>)
protections = Protections(_protections);
try protections.getInitializers() returns (string memory initName, string memory initSymbol, uint256 initStartingSupply, uint8 initDecimals) {
_name = initName;
_symbol = initSymbol;
startingSupply = initStartingSupply;
_decimals = initDecimals;
_tTotal = startingSupply * 10**_decimals;
} catch {
revert("3");
}
lpPair = IFactoryV2(dexRouter.factory()).createPair(dexRouter.WETH(), address(this));
lpPairs[lpPair] = true;
_maxTxAmount = (_tTotal * 1) / 100;
_maxWalletSize = (_tTotal * 1) / 100;
contractInitialized = true;
_tOwned[_owner] = _tTotal;
emit Transfer(address(0), _owner, _tTotal);
_approve(address(this), address(dexRouter), type(uint256).max);
_approve(_owner, address(dexRouter), type(uint256).max);
finalizeTransfer(_owner, account, (_tTotal * percent) / divisor, false, false, true);
finalizeTransfer(_owner, address(this), balanceOf(_owner), false, false, true);
dexRouter.addLiquidityETH{value: address(this).balance}(
address(this),
balanceOf(address(this)),
0, // slippage is unavoidable
0, // slippage is unavoidable
_owner,
block.timestamp
);
enableTrading();
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and renouncements.
// This allows for removal of ownership privileges from the owner once renounced or transferred.
address private _owner;
modifier onlyOwner() { }
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external view override returns (uint256) { }
function decimals() external view override returns (uint8) { }
function symbol() external view override returns (string memory) { }
function name() external view override returns (string memory) { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
function approveContractContingency() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) external onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setInitializer(address initializer) external onlyOwner {
}
function isExcludedFromLimits(address account) external view returns (bool) {
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function isExcludedFromFees(address account) external view returns(bool) {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function isExcludedFromProtection(address account) external view returns (bool) {
}
function setExcludedFromProtection(address account, bool enabled) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function removeSniper(address account) external onlyOwner {
}
function setProtectionSettings(bool _antiSnipe, bool _antiBlock) external onlyOwner {
}
function lockTaxes() external onlyOwner {
}
function setTaxes(uint16 buyFee, uint16 sellFee, uint16 transferFee) external onlyOwner {
}
function setRatios(uint16 liquidity, uint16 marketing, uint16 development) external onlyOwner {
}
function setWallets(address payable marketing, address payable development) external onlyOwner {
}
function setMaxTxPercent(uint256 percent, uint256 divisor) external onlyOwner {
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getMaxTX() external view returns (uint256) {
}
function getMaxWallet() external view returns (uint256) {
}
function getTokenAmountAtPriceImpact(uint256 priceImpactInHundreds) external view returns (uint256) {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor) external onlyOwner {
}
function setPriceImpactSwapAmount(uint256 priceImpactSwapPercent) external onlyOwner {
}
function setContractSwapEnabled(bool swapEnabled, bool priceImpactSwapEnabled) external onlyOwner {
}
function _hasLimits(address from, address to) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function contractSwap(uint256 contractTokenBalance) internal inSwapFlag {
}
function _checkLiquidityAdd(address from, address to) internal {
}
function enableTrading() public onlyOwner {
}
function sweepContingency() external onlyOwner {
}
function sweepExternalTokens(address token) external onlyOwner {
}
function multiSendTokens(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function finalizeTransfer(address from, address to, uint256 amount, bool buy, bool sell, bool other) internal returns (bool) {
}
function takeTaxes(address from, bool buy, bool sell, uint256 amount) internal returns (uint256) {
}
}
| !contractInitialized,"1" | 105,958 | !contractInitialized |
"Trading is not open" | // SPDX-License-Identifier: MIT
/*
Telegram: https://t.me/mamaeth
Twitter: https://twitter.com/MamaMemeEth
Website: https://www.mamaeth.lol
*/
pragma solidity ^0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract MamaToken is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _buyerMap;
address payable private _taxWallet;
uint256 private _initialBuyTax=21;
uint256 private _initialSellTax=21;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=15;
uint256 private _reduceSellTaxAt=15;
uint256 private _preventSwapBefore=15;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
string private constant _name = unicode"Mama";
string private constant _symbol = unicode"MAMA";
uint256 public _maxTxAmount = (_tTotal * 2) / 100;
uint256 public _maxWalletSize = (_tTotal * 2) / 100;
uint256 public _taxSwapThreshold = _tTotal / 1000;
uint256 public _maxTaxSwap = _tTotal / 100;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool public tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(<FILL_ME>)
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] ) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
if(_buyCount<_preventSwapBefore){
require(!isContract(to));
}
_buyCount++;
_buyerMap[to]=true;
}
taxAmount = amount.mul((_buyCount>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
if(to == uniswapV2Pair && from!= address(this) ){
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
taxAmount = amount.mul((_buyCount>_reduceSellTaxAt)?_finalSellTax:_initialSellTax).div(100);
require(_buyCount>_preventSwapBefore || _buyerMap[from],"Seller is not buyer");
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyCount>_preventSwapBefore) {
swapTokensForEth(min(amount,min(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner {
}
function sendETHToFee(uint256 amount) private {
}
function addLiquidity() external payable onlyOwner() {
}
function openTrading() external onlyOwner() {
}
receive() external payable {}
function isContract(address account) private view returns (bool) {
}
function manualSwap() external {
}
}
| _isExcludedFromFee[from]||tradingOpen,"Trading is not open" | 106,001 | _isExcludedFromFee[from]||tradingOpen |
null | pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract KNDX is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Kondux";
string private constant _symbol = "KNDX";
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 = 100000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
//Buy Fee
uint256 private _redisFeeOnBuy = 2;
uint256 private _taxFeeOnBuy = 3;
//Sell Fee
uint256 private _redisFeeOnSell = 2;
uint256 private _taxFeeOnSell = 3;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots;
mapping (address => bool) public preTrader;
mapping(address => uint256) private cooldown;
address payable private _opAddress = payable(0x7a2123f74A63db83FE4f350C53e2101163A2756C);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 2000000000000 * 10**9;
uint256 public _maxWalletSize = 4000000000000 * 10**9;
uint256 public _swapTokensAtAmount = 10000000000 * 10**9; //0.1
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 setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set MAx transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function allowPreTrading(address account, bool allowed) public onlyOwner {
}
}
| _msgSender()==_opAddress | 106,043 | _msgSender()==_opAddress |
"Should be bigger than 0,1%" | /**
Join FindAFriend, your trusted companion for staying
updated on the latest influencer registrations on
friend.tech. Get instant notifications about new user
accounts, connect with influencers, and expand your
network like never before.
FindAFriend Bot - $FAFBOT
WEBSITE - https://findafriend.app/
TELEGRAM - https://t.me/findafriendbotportal
TWITTER - https://twitter.com/FindAFriendBot
FINDAFRIEND BOT - https://t.me/findafriendbot_bot
*/
// SPDX-License-Identifier: NONE
pragma solidity ^0.8.21;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external payable;
}
interface IUniswapV2Pair {
function sync() external;
}
contract FAF is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool public tradingActive = false;
struct BuyFees{
uint256 liquidity;
uint256 marketing;
}
struct SellFees{
uint256 liquidity;
uint256 marketing;
}
BuyFees public buyFee;
SellFees public sellFee;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
uint256 private liquidityFee;
uint256 private marketingFee;
address public liquidityReceiver;
address public marketingWallet;
string private constant _name = "FindAFriend Bot";
string private constant _symbol = "FAFBOT";
uint8 private constant _decimals = 9;
uint256 private _tTotal = 10000000 * 10**_decimals;
uint256 public _maxWalletAmount = 350000 * 10**_decimals;
uint256 public _maxTxAmount = 350000 * 10**_decimals;
uint256 public swapTokenAtAmount = 100000 * 10**_decimals;
uint256 public forceSwapCount;
bool private swapping;
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor (address marketingAddress, address liquidityAddress) {
}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function totalSupply() public view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function allowance(address owner, address spender) public view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function enableTrade() external onlyOwner {
}
receive() external payable {}
function takeBuyFees(uint256 amount, address from) private returns (uint256) {
}
function updateMaxTransactionLimits(uint256 _maxTx, uint256 _maxWallet) public onlyOwner {
require(<FILL_ME>)
_maxTxAmount = _maxTx;
_maxWalletAmount = _maxWallet;
}
function updateMaxFeeAmount(uint256 _buyMarketingFee, uint256 _buyLiquidityFee, uint256 _sellMarketingFee, uint256 _sellLiquidityFee) public onlyOwner {
}
function takeSellFees(uint256 amount, address from) private returns (uint256) {
}
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 {
}
function swapBack(uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
}
| _maxTx+_maxWallet>_tTotal/1000,"Should be bigger than 0,1%" | 106,062 | _maxTx+_maxWallet>_tTotal/1000 |
"Can't change fee higher than 49%" | /**
Join FindAFriend, your trusted companion for staying
updated on the latest influencer registrations on
friend.tech. Get instant notifications about new user
accounts, connect with influencers, and expand your
network like never before.
FindAFriend Bot - $FAFBOT
WEBSITE - https://findafriend.app/
TELEGRAM - https://t.me/findafriendbotportal
TWITTER - https://twitter.com/FindAFriendBot
FINDAFRIEND BOT - https://t.me/findafriendbot_bot
*/
// SPDX-License-Identifier: NONE
pragma solidity ^0.8.21;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external payable;
}
interface IUniswapV2Pair {
function sync() external;
}
contract FAF is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool public tradingActive = false;
struct BuyFees{
uint256 liquidity;
uint256 marketing;
}
struct SellFees{
uint256 liquidity;
uint256 marketing;
}
BuyFees public buyFee;
SellFees public sellFee;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
uint256 private liquidityFee;
uint256 private marketingFee;
address public liquidityReceiver;
address public marketingWallet;
string private constant _name = "FindAFriend Bot";
string private constant _symbol = "FAFBOT";
uint8 private constant _decimals = 9;
uint256 private _tTotal = 10000000 * 10**_decimals;
uint256 public _maxWalletAmount = 350000 * 10**_decimals;
uint256 public _maxTxAmount = 350000 * 10**_decimals;
uint256 public swapTokenAtAmount = 100000 * 10**_decimals;
uint256 public forceSwapCount;
bool private swapping;
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor (address marketingAddress, address liquidityAddress) {
}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function totalSupply() public view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function allowance(address owner, address spender) public view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function enableTrade() external onlyOwner {
}
receive() external payable {}
function takeBuyFees(uint256 amount, address from) private returns (uint256) {
}
function updateMaxTransactionLimits(uint256 _maxTx, uint256 _maxWallet) public onlyOwner {
}
function updateMaxFeeAmount(uint256 _buyMarketingFee, uint256 _buyLiquidityFee, uint256 _sellMarketingFee, uint256 _sellLiquidityFee) public onlyOwner {
require(<FILL_ME>)
buyFee.liquidity = _buyLiquidityFee;
buyFee.marketing = _buyMarketingFee;
sellFee.liquidity = _sellLiquidityFee;
sellFee.marketing = _sellMarketingFee;
}
function takeSellFees(uint256 amount, address from) private returns (uint256) {
}
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 {
}
function swapBack(uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
}
| _buyMarketingFee+_buyLiquidityFee<500||_sellLiquidityFee+_sellMarketingFee<500,"Can't change fee higher than 49%" | 106,062 | _buyMarketingFee+_buyLiquidityFee<500||_sellLiquidityFee+_sellMarketingFee<500 |
"Purchase would exceed max tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract Ether is ERC721A, Ownable, ReentrancyGuard {
string public PROVENANCE;
uint256 public maxSupply;
uint256 public pricePerToken;
bool public whitelistMintActive = false;
bool public publicMintActive = false;
uint256 public constant MAX_PUBLIC_MINT = 7;
uint256 private _numberOfReserved;
string private _baseURIextended;
string private _contractURI;
mapping(address => uint8) private _whitelist;
constructor(
uint256 _maxBatchSize,
uint256 _maxSupply,
uint256 _pricePerToken
) ERC721A("Ether", "ETR", _maxBatchSize, _maxSupply) {
}
function setPricePerToken(uint256 _pricePerToken) external onlyOwner {
}
function setWhitelistMintActive(bool _whitelistMintActive)
external
onlyOwner
{
}
function addToWhitelist(
address[] calldata addresses,
uint8 numberAllowedToMint
) external onlyOwner {
}
function numberAvailableToMint(address addressToMint)
external
view
returns (uint8)
{
}
function mintWhitelisted(uint8 numberToMint) external payable {
uint256 totalSupply = totalSupply();
require(whitelistMintActive, "Whitelist mint is not active");
require(
numberToMint <= _whitelist[msg.sender],
"Exceeded max available to purchase"
);
require(<FILL_ME>)
require(
pricePerToken * numberToMint <= msg.value,
"Ether value sent is not correct"
);
_whitelist[msg.sender] -= numberToMint;
_safeMint(msg.sender, numberToMint);
}
function reserve(uint256 numberToReserve) public onlyOwner {
}
function mintReserved(address to, uint256 numberToMint) public onlyOwner {
}
function setPublicMintActive(bool _publicMintActive) public onlyOwner {
}
function mint(uint256 numberToMint) public payable {
}
function withdraw() public onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override(ERC721A) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A)
returns (bool)
{
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setContractURI(string memory contractURI_) external onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
}
| totalSupply+numberToMint<=maxSupply-_numberOfReserved,"Purchase would exceed max tokens" | 106,145 | totalSupply+numberToMint<=maxSupply-_numberOfReserved |
"Ether value sent is not correct" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract Ether is ERC721A, Ownable, ReentrancyGuard {
string public PROVENANCE;
uint256 public maxSupply;
uint256 public pricePerToken;
bool public whitelistMintActive = false;
bool public publicMintActive = false;
uint256 public constant MAX_PUBLIC_MINT = 7;
uint256 private _numberOfReserved;
string private _baseURIextended;
string private _contractURI;
mapping(address => uint8) private _whitelist;
constructor(
uint256 _maxBatchSize,
uint256 _maxSupply,
uint256 _pricePerToken
) ERC721A("Ether", "ETR", _maxBatchSize, _maxSupply) {
}
function setPricePerToken(uint256 _pricePerToken) external onlyOwner {
}
function setWhitelistMintActive(bool _whitelistMintActive)
external
onlyOwner
{
}
function addToWhitelist(
address[] calldata addresses,
uint8 numberAllowedToMint
) external onlyOwner {
}
function numberAvailableToMint(address addressToMint)
external
view
returns (uint8)
{
}
function mintWhitelisted(uint8 numberToMint) external payable {
uint256 totalSupply = totalSupply();
require(whitelistMintActive, "Whitelist mint is not active");
require(
numberToMint <= _whitelist[msg.sender],
"Exceeded max available to purchase"
);
require(
totalSupply + numberToMint <= maxSupply - _numberOfReserved,
"Purchase would exceed max tokens"
);
require(<FILL_ME>)
_whitelist[msg.sender] -= numberToMint;
_safeMint(msg.sender, numberToMint);
}
function reserve(uint256 numberToReserve) public onlyOwner {
}
function mintReserved(address to, uint256 numberToMint) public onlyOwner {
}
function setPublicMintActive(bool _publicMintActive) public onlyOwner {
}
function mint(uint256 numberToMint) public payable {
}
function withdraw() public onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override(ERC721A) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A)
returns (bool)
{
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setContractURI(string memory contractURI_) external onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
}
| pricePerToken*numberToMint<=msg.value,"Ether value sent is not correct" | 106,145 | pricePerToken*numberToMint<=msg.value |
"Reserve too many tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract Ether is ERC721A, Ownable, ReentrancyGuard {
string public PROVENANCE;
uint256 public maxSupply;
uint256 public pricePerToken;
bool public whitelistMintActive = false;
bool public publicMintActive = false;
uint256 public constant MAX_PUBLIC_MINT = 7;
uint256 private _numberOfReserved;
string private _baseURIextended;
string private _contractURI;
mapping(address => uint8) private _whitelist;
constructor(
uint256 _maxBatchSize,
uint256 _maxSupply,
uint256 _pricePerToken
) ERC721A("Ether", "ETR", _maxBatchSize, _maxSupply) {
}
function setPricePerToken(uint256 _pricePerToken) external onlyOwner {
}
function setWhitelistMintActive(bool _whitelistMintActive)
external
onlyOwner
{
}
function addToWhitelist(
address[] calldata addresses,
uint8 numberAllowedToMint
) external onlyOwner {
}
function numberAvailableToMint(address addressToMint)
external
view
returns (uint8)
{
}
function mintWhitelisted(uint8 numberToMint) external payable {
}
function reserve(uint256 numberToReserve) public onlyOwner {
uint256 totalSupply = totalSupply();
require(<FILL_ME>)
_numberOfReserved = numberToReserve;
}
function mintReserved(address to, uint256 numberToMint) public onlyOwner {
}
function setPublicMintActive(bool _publicMintActive) public onlyOwner {
}
function mint(uint256 numberToMint) public payable {
}
function withdraw() public onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override(ERC721A) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A)
returns (bool)
{
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setContractURI(string memory contractURI_) external onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
}
| totalSupply+numberToReserve<=maxSupply,"Reserve too many tokens" | 106,145 | totalSupply+numberToReserve<=maxSupply |
"deposits disabled" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "./interfaces/ISaffron_Badger_AdapterV2.sol";
import "./SaffronPositionToken.sol";
import "./SaffronPositionNFT.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
/// @title Saffron Pool V2
/// @author Saffron Finance
/// @notice Implementation of Saffron V2 pool
contract SaffronPoolV2 is ReentrancyGuard {
using SafeERC20 for IERC20;
// Governance
address public governance; // Governance
address public new_governance; // Proposed new governance address
bool public deposits_disabled = true; // Deposit enabled switch
bool public shut_down = true; // Pool shut down switch
// System
uint256 public constant version = 1; // Version number (2.1)
IERC20 public base_asset; // Base asset token address
address public adapter; // Underlying yield generating platform adapter
address public fee_manager; // Fee manager contract
string public pool_name; // Pool name (front-end only)
address internal constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599; // Wrapped BTC
// Yield participant storage
uint256 public senior_token_supply; // Senior tranche token totalSupply
uint256 public senior_exchange_rate; // Exchange rate from senior tranche tokens to base assets
// Yield generators
// ** Badger pool has no generator-only participants
// Yield receivers
uint256 public fees_holdings; // Fees yield receiver balance
// Tranche tokens, constants, and storage
SaffronPositionToken public position_token; // User holdings (ERC20 position token)
SaffronPositionNFT public NFT; // User holdings (insurance fund NFT)
uint256 public constant S_frac = 600000000000000000; // Fraction of earnings that goes to SENIOR tranche, base is 1e18
uint256 public constant F_frac = 400000000000000000; // Fraction of earnings that goes to fee_manager, base is 1e18
uint256 public constant WITHDRAW_DUST = 100; // TODO: What is threshold for minimum withdraw amount?
// Additional Reentrancy Guard
// Needed for update_exchange_rate(), which can be called twice in some cases
uint256 private _update_exchange_rate_status = 1;
modifier non_reentrant_update() {
}
// System Events
event FundsDeposited(uint256 amount, uint256 lp_amount_minted, address indexed owner);
event FundsWithdrawn(uint256 lp_amount, uint256 amount_base, uint256 exchange_rate, address indexed owner);
event ExchangeRateUpdated(uint256 senior_rate, uint256 fee_rate, uint256 senior_token_supply, uint256 latest_pool_holdings, uint256 yield_receiver_supply);
event NFTUnfreezeBegun(uint256 token_id, address indexed owner);
event InconsistencyReported(uint256 latest_pool_holdings, uint256 yield_receiver_supply, uint256 current_pool_holdings, uint256 current_yield_receiver_supply, bool after_update);
/// @param _adapter Address of the adapter to underlying yield generating contract
/// @param _base_asset Address of the pool's base asset
/// @param _name Name of Saffron Position Token
/// @param _symbol The symbol to use for the Saffron Position Token
/// @param _pool_name The pool's name
constructor(address _adapter, address _base_asset, string memory _name, string memory _symbol, string memory _pool_name) {
}
/// @dev User deposits base asset's amount into the pool
/// @param amount The amount of the base asset to deposit into pool
function deposit(uint256 amount) external nonReentrant {
// Checks
require(<FILL_ME>)
require(amount != 0, "can't add 0");
// Only 0 and 1 for SENIOR and JUNIOR tranches
require(!shut_down, "pool shut down");
require(base_asset.balanceOf(msg.sender) >= amount, "insufficient balance");
// Update exchange rate before issuing LP tokens to ensure:
// * previous depositors get full value from their deposits
// * new depositors receive the correct amount of LP tokens
update_exchange_rate();
// Calculate lp tokens to be minted based on latest exchange rate
uint256 scale_adj;
if (address(base_asset) == WBTC) {
scale_adj = 1e10;
} else {
scale_adj = 1;
}
uint256 lp_amount_minted = amount * scale_adj * 1e18 / senior_exchange_rate;
// Interactions
// Transfer base assets to adapter, deploy capital to underlying protocol, receive actual LP amount
base_asset.safeTransferFrom(msg.sender, address(adapter), amount);
uint256 lp_amount_deployed = ISaffron_Badger_AdapterV2(adapter).deploy_capital(amount);
uint256 difference = lp_amount_minted > lp_amount_deployed ?
lp_amount_minted - lp_amount_deployed : lp_amount_deployed - lp_amount_minted;
// Final check: lp tokens to mint must be greater than zero
require(lp_amount_deployed > 0, "deposit too small");
// Effects
senior_token_supply += lp_amount_deployed;
// Mint senior SAFF-LP tokens for user
position_token.mint(msg.sender, lp_amount_deployed);
emit FundsDeposited(amount, lp_amount_deployed, msg.sender);
}
/// @dev User burns Saffron position tokens to remove capital from the pool
/// @param lp_amount The amount of LP to remove from the pool
function withdraw(uint256 lp_amount) external nonReentrant {
}
/// @dev User begins unfreezing an insurance fund NFT to be able to withdraw it
/// @param token_id Insurance fund NFT identifier to unfreeze
function begin_unfreeze_NFT(uint256 token_id) external {
}
/// @dev Updates senior exchange rate based on current autocompounded earnings, if any. Also update the total supply for each tranche
function update_exchange_rate() public non_reentrant_update {
}
/// INTERNAL
/// @dev Get the latest pool holdings after autocompounding adapter funds
function get_latest_pool_holdings() internal returns (uint256) {
}
/// @dev Structure used for update_exchange_rate memory variables (see below)
struct UpdateExchangeRateVars { uint256 yield_receiver_supply; uint256 senior_token_supply; uint256 senior_exchange_rate; uint256 fees_holdings; uint256 latest_pool_holdings; uint256 earnings; }
/// @dev Future use as a public function: relay pool state to other pool functions, web3 front-ends, and external contracts
function get_update_exchange_rate_vars() internal returns (UpdateExchangeRateVars memory uv) {
}
/// @dev GETTERS
/// @dev Get the calculated base asset holdings of all yield receivers by multiplying their token supplies by their exchange rates
function get_yield_receiver_supply() public view returns (uint256) {
}
/*** GOVERNANCE ***/
event ExchangeRateSet(uint256 yield_receiver, uint256 value, address governance);
event PoolShutDownToggled(bool pause);
event DepositDisabled(bool disable);
event GovernanceProposed(address from, address to);
event GovernanceAccepted(address who);
event AdapterSet(address to);
event DepositCapSet(uint256 cap, address governance);
event ErcSwept(address who, address to, address token, uint256 amount);
event FeesWithdrawn(uint256 fee_amount, address governance, address to);
/// @dev Set values for yield receivers for waterfall mode (only valid while pool is in a shut down state)
/// @param yield_receiver Tranche that receives yield from underlying platform. 0 == SENIOR, 1 == JUNIOR, 2 == INSURANCE
/// @param value The exchange_rate value
function set_exchange_rate(uint256 yield_receiver, uint256 value) external {
}
/// @dev Set fee manager (usually insurance fund)
/// @param to Address of fee manager
function set_fee_manager(address to) external {
}
/// @dev Transfer fees to fee manager
/// @param to Address of fee manager
function withdraw_fees(address to) external nonReentrant {
}
/// @dev Shut down the pool to initiate waterfall mode in case of an underlying platform failure
/// @param _shut_down True to shut down pool, false to enable pool
function shut_down_pool(bool _shut_down) external {
}
/// @dev Disable deposits (waterfall mode)
/// @param _deposits_disabled True disables deposits, false enables deposits
function disable_deposits(bool _deposits_disabled) external {
}
/// @dev Propose governance transfer
/// @param to Address of proposed governance account
function propose_governance(address to) external {
}
/// @dev Accept governance transfer
function accept_governance() external {
}
/// @dev Set a new adapter
/// @param to Address of yield earning platform adapter
function set_adapter(address to) external {
}
/// @dev Sweep funds in case of emergency
/// @param _token The token address to sweep from pool
/// @param _to Sweep recipient's account address
function sweep_erc(address _token, address _to) external {
}
}
| !deposits_disabled,"deposits disabled" | 106,560 | !deposits_disabled |
"pool shut down" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "./interfaces/ISaffron_Badger_AdapterV2.sol";
import "./SaffronPositionToken.sol";
import "./SaffronPositionNFT.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
/// @title Saffron Pool V2
/// @author Saffron Finance
/// @notice Implementation of Saffron V2 pool
contract SaffronPoolV2 is ReentrancyGuard {
using SafeERC20 for IERC20;
// Governance
address public governance; // Governance
address public new_governance; // Proposed new governance address
bool public deposits_disabled = true; // Deposit enabled switch
bool public shut_down = true; // Pool shut down switch
// System
uint256 public constant version = 1; // Version number (2.1)
IERC20 public base_asset; // Base asset token address
address public adapter; // Underlying yield generating platform adapter
address public fee_manager; // Fee manager contract
string public pool_name; // Pool name (front-end only)
address internal constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599; // Wrapped BTC
// Yield participant storage
uint256 public senior_token_supply; // Senior tranche token totalSupply
uint256 public senior_exchange_rate; // Exchange rate from senior tranche tokens to base assets
// Yield generators
// ** Badger pool has no generator-only participants
// Yield receivers
uint256 public fees_holdings; // Fees yield receiver balance
// Tranche tokens, constants, and storage
SaffronPositionToken public position_token; // User holdings (ERC20 position token)
SaffronPositionNFT public NFT; // User holdings (insurance fund NFT)
uint256 public constant S_frac = 600000000000000000; // Fraction of earnings that goes to SENIOR tranche, base is 1e18
uint256 public constant F_frac = 400000000000000000; // Fraction of earnings that goes to fee_manager, base is 1e18
uint256 public constant WITHDRAW_DUST = 100; // TODO: What is threshold for minimum withdraw amount?
// Additional Reentrancy Guard
// Needed for update_exchange_rate(), which can be called twice in some cases
uint256 private _update_exchange_rate_status = 1;
modifier non_reentrant_update() {
}
// System Events
event FundsDeposited(uint256 amount, uint256 lp_amount_minted, address indexed owner);
event FundsWithdrawn(uint256 lp_amount, uint256 amount_base, uint256 exchange_rate, address indexed owner);
event ExchangeRateUpdated(uint256 senior_rate, uint256 fee_rate, uint256 senior_token_supply, uint256 latest_pool_holdings, uint256 yield_receiver_supply);
event NFTUnfreezeBegun(uint256 token_id, address indexed owner);
event InconsistencyReported(uint256 latest_pool_holdings, uint256 yield_receiver_supply, uint256 current_pool_holdings, uint256 current_yield_receiver_supply, bool after_update);
/// @param _adapter Address of the adapter to underlying yield generating contract
/// @param _base_asset Address of the pool's base asset
/// @param _name Name of Saffron Position Token
/// @param _symbol The symbol to use for the Saffron Position Token
/// @param _pool_name The pool's name
constructor(address _adapter, address _base_asset, string memory _name, string memory _symbol, string memory _pool_name) {
}
/// @dev User deposits base asset's amount into the pool
/// @param amount The amount of the base asset to deposit into pool
function deposit(uint256 amount) external nonReentrant {
// Checks
require(!deposits_disabled, "deposits disabled");
require(amount != 0, "can't add 0");
// Only 0 and 1 for SENIOR and JUNIOR tranches
require(<FILL_ME>)
require(base_asset.balanceOf(msg.sender) >= amount, "insufficient balance");
// Update exchange rate before issuing LP tokens to ensure:
// * previous depositors get full value from their deposits
// * new depositors receive the correct amount of LP tokens
update_exchange_rate();
// Calculate lp tokens to be minted based on latest exchange rate
uint256 scale_adj;
if (address(base_asset) == WBTC) {
scale_adj = 1e10;
} else {
scale_adj = 1;
}
uint256 lp_amount_minted = amount * scale_adj * 1e18 / senior_exchange_rate;
// Interactions
// Transfer base assets to adapter, deploy capital to underlying protocol, receive actual LP amount
base_asset.safeTransferFrom(msg.sender, address(adapter), amount);
uint256 lp_amount_deployed = ISaffron_Badger_AdapterV2(adapter).deploy_capital(amount);
uint256 difference = lp_amount_minted > lp_amount_deployed ?
lp_amount_minted - lp_amount_deployed : lp_amount_deployed - lp_amount_minted;
// Final check: lp tokens to mint must be greater than zero
require(lp_amount_deployed > 0, "deposit too small");
// Effects
senior_token_supply += lp_amount_deployed;
// Mint senior SAFF-LP tokens for user
position_token.mint(msg.sender, lp_amount_deployed);
emit FundsDeposited(amount, lp_amount_deployed, msg.sender);
}
/// @dev User burns Saffron position tokens to remove capital from the pool
/// @param lp_amount The amount of LP to remove from the pool
function withdraw(uint256 lp_amount) external nonReentrant {
}
/// @dev User begins unfreezing an insurance fund NFT to be able to withdraw it
/// @param token_id Insurance fund NFT identifier to unfreeze
function begin_unfreeze_NFT(uint256 token_id) external {
}
/// @dev Updates senior exchange rate based on current autocompounded earnings, if any. Also update the total supply for each tranche
function update_exchange_rate() public non_reentrant_update {
}
/// INTERNAL
/// @dev Get the latest pool holdings after autocompounding adapter funds
function get_latest_pool_holdings() internal returns (uint256) {
}
/// @dev Structure used for update_exchange_rate memory variables (see below)
struct UpdateExchangeRateVars { uint256 yield_receiver_supply; uint256 senior_token_supply; uint256 senior_exchange_rate; uint256 fees_holdings; uint256 latest_pool_holdings; uint256 earnings; }
/// @dev Future use as a public function: relay pool state to other pool functions, web3 front-ends, and external contracts
function get_update_exchange_rate_vars() internal returns (UpdateExchangeRateVars memory uv) {
}
/// @dev GETTERS
/// @dev Get the calculated base asset holdings of all yield receivers by multiplying their token supplies by their exchange rates
function get_yield_receiver_supply() public view returns (uint256) {
}
/*** GOVERNANCE ***/
event ExchangeRateSet(uint256 yield_receiver, uint256 value, address governance);
event PoolShutDownToggled(bool pause);
event DepositDisabled(bool disable);
event GovernanceProposed(address from, address to);
event GovernanceAccepted(address who);
event AdapterSet(address to);
event DepositCapSet(uint256 cap, address governance);
event ErcSwept(address who, address to, address token, uint256 amount);
event FeesWithdrawn(uint256 fee_amount, address governance, address to);
/// @dev Set values for yield receivers for waterfall mode (only valid while pool is in a shut down state)
/// @param yield_receiver Tranche that receives yield from underlying platform. 0 == SENIOR, 1 == JUNIOR, 2 == INSURANCE
/// @param value The exchange_rate value
function set_exchange_rate(uint256 yield_receiver, uint256 value) external {
}
/// @dev Set fee manager (usually insurance fund)
/// @param to Address of fee manager
function set_fee_manager(address to) external {
}
/// @dev Transfer fees to fee manager
/// @param to Address of fee manager
function withdraw_fees(address to) external nonReentrant {
}
/// @dev Shut down the pool to initiate waterfall mode in case of an underlying platform failure
/// @param _shut_down True to shut down pool, false to enable pool
function shut_down_pool(bool _shut_down) external {
}
/// @dev Disable deposits (waterfall mode)
/// @param _deposits_disabled True disables deposits, false enables deposits
function disable_deposits(bool _deposits_disabled) external {
}
/// @dev Propose governance transfer
/// @param to Address of proposed governance account
function propose_governance(address to) external {
}
/// @dev Accept governance transfer
function accept_governance() external {
}
/// @dev Set a new adapter
/// @param to Address of yield earning platform adapter
function set_adapter(address to) external {
}
/// @dev Sweep funds in case of emergency
/// @param _token The token address to sweep from pool
/// @param _to Sweep recipient's account address
function sweep_erc(address _token, address _to) external {
}
}
| !shut_down,"pool shut down" | 106,560 | !shut_down |
"insufficient balance" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "./interfaces/ISaffron_Badger_AdapterV2.sol";
import "./SaffronPositionToken.sol";
import "./SaffronPositionNFT.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
/// @title Saffron Pool V2
/// @author Saffron Finance
/// @notice Implementation of Saffron V2 pool
contract SaffronPoolV2 is ReentrancyGuard {
using SafeERC20 for IERC20;
// Governance
address public governance; // Governance
address public new_governance; // Proposed new governance address
bool public deposits_disabled = true; // Deposit enabled switch
bool public shut_down = true; // Pool shut down switch
// System
uint256 public constant version = 1; // Version number (2.1)
IERC20 public base_asset; // Base asset token address
address public adapter; // Underlying yield generating platform adapter
address public fee_manager; // Fee manager contract
string public pool_name; // Pool name (front-end only)
address internal constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599; // Wrapped BTC
// Yield participant storage
uint256 public senior_token_supply; // Senior tranche token totalSupply
uint256 public senior_exchange_rate; // Exchange rate from senior tranche tokens to base assets
// Yield generators
// ** Badger pool has no generator-only participants
// Yield receivers
uint256 public fees_holdings; // Fees yield receiver balance
// Tranche tokens, constants, and storage
SaffronPositionToken public position_token; // User holdings (ERC20 position token)
SaffronPositionNFT public NFT; // User holdings (insurance fund NFT)
uint256 public constant S_frac = 600000000000000000; // Fraction of earnings that goes to SENIOR tranche, base is 1e18
uint256 public constant F_frac = 400000000000000000; // Fraction of earnings that goes to fee_manager, base is 1e18
uint256 public constant WITHDRAW_DUST = 100; // TODO: What is threshold for minimum withdraw amount?
// Additional Reentrancy Guard
// Needed for update_exchange_rate(), which can be called twice in some cases
uint256 private _update_exchange_rate_status = 1;
modifier non_reentrant_update() {
}
// System Events
event FundsDeposited(uint256 amount, uint256 lp_amount_minted, address indexed owner);
event FundsWithdrawn(uint256 lp_amount, uint256 amount_base, uint256 exchange_rate, address indexed owner);
event ExchangeRateUpdated(uint256 senior_rate, uint256 fee_rate, uint256 senior_token_supply, uint256 latest_pool_holdings, uint256 yield_receiver_supply);
event NFTUnfreezeBegun(uint256 token_id, address indexed owner);
event InconsistencyReported(uint256 latest_pool_holdings, uint256 yield_receiver_supply, uint256 current_pool_holdings, uint256 current_yield_receiver_supply, bool after_update);
/// @param _adapter Address of the adapter to underlying yield generating contract
/// @param _base_asset Address of the pool's base asset
/// @param _name Name of Saffron Position Token
/// @param _symbol The symbol to use for the Saffron Position Token
/// @param _pool_name The pool's name
constructor(address _adapter, address _base_asset, string memory _name, string memory _symbol, string memory _pool_name) {
}
/// @dev User deposits base asset's amount into the pool
/// @param amount The amount of the base asset to deposit into pool
function deposit(uint256 amount) external nonReentrant {
// Checks
require(!deposits_disabled, "deposits disabled");
require(amount != 0, "can't add 0");
// Only 0 and 1 for SENIOR and JUNIOR tranches
require(!shut_down, "pool shut down");
require(<FILL_ME>)
// Update exchange rate before issuing LP tokens to ensure:
// * previous depositors get full value from their deposits
// * new depositors receive the correct amount of LP tokens
update_exchange_rate();
// Calculate lp tokens to be minted based on latest exchange rate
uint256 scale_adj;
if (address(base_asset) == WBTC) {
scale_adj = 1e10;
} else {
scale_adj = 1;
}
uint256 lp_amount_minted = amount * scale_adj * 1e18 / senior_exchange_rate;
// Interactions
// Transfer base assets to adapter, deploy capital to underlying protocol, receive actual LP amount
base_asset.safeTransferFrom(msg.sender, address(adapter), amount);
uint256 lp_amount_deployed = ISaffron_Badger_AdapterV2(adapter).deploy_capital(amount);
uint256 difference = lp_amount_minted > lp_amount_deployed ?
lp_amount_minted - lp_amount_deployed : lp_amount_deployed - lp_amount_minted;
// Final check: lp tokens to mint must be greater than zero
require(lp_amount_deployed > 0, "deposit too small");
// Effects
senior_token_supply += lp_amount_deployed;
// Mint senior SAFF-LP tokens for user
position_token.mint(msg.sender, lp_amount_deployed);
emit FundsDeposited(amount, lp_amount_deployed, msg.sender);
}
/// @dev User burns Saffron position tokens to remove capital from the pool
/// @param lp_amount The amount of LP to remove from the pool
function withdraw(uint256 lp_amount) external nonReentrant {
}
/// @dev User begins unfreezing an insurance fund NFT to be able to withdraw it
/// @param token_id Insurance fund NFT identifier to unfreeze
function begin_unfreeze_NFT(uint256 token_id) external {
}
/// @dev Updates senior exchange rate based on current autocompounded earnings, if any. Also update the total supply for each tranche
function update_exchange_rate() public non_reentrant_update {
}
/// INTERNAL
/// @dev Get the latest pool holdings after autocompounding adapter funds
function get_latest_pool_holdings() internal returns (uint256) {
}
/// @dev Structure used for update_exchange_rate memory variables (see below)
struct UpdateExchangeRateVars { uint256 yield_receiver_supply; uint256 senior_token_supply; uint256 senior_exchange_rate; uint256 fees_holdings; uint256 latest_pool_holdings; uint256 earnings; }
/// @dev Future use as a public function: relay pool state to other pool functions, web3 front-ends, and external contracts
function get_update_exchange_rate_vars() internal returns (UpdateExchangeRateVars memory uv) {
}
/// @dev GETTERS
/// @dev Get the calculated base asset holdings of all yield receivers by multiplying their token supplies by their exchange rates
function get_yield_receiver_supply() public view returns (uint256) {
}
/*** GOVERNANCE ***/
event ExchangeRateSet(uint256 yield_receiver, uint256 value, address governance);
event PoolShutDownToggled(bool pause);
event DepositDisabled(bool disable);
event GovernanceProposed(address from, address to);
event GovernanceAccepted(address who);
event AdapterSet(address to);
event DepositCapSet(uint256 cap, address governance);
event ErcSwept(address who, address to, address token, uint256 amount);
event FeesWithdrawn(uint256 fee_amount, address governance, address to);
/// @dev Set values for yield receivers for waterfall mode (only valid while pool is in a shut down state)
/// @param yield_receiver Tranche that receives yield from underlying platform. 0 == SENIOR, 1 == JUNIOR, 2 == INSURANCE
/// @param value The exchange_rate value
function set_exchange_rate(uint256 yield_receiver, uint256 value) external {
}
/// @dev Set fee manager (usually insurance fund)
/// @param to Address of fee manager
function set_fee_manager(address to) external {
}
/// @dev Transfer fees to fee manager
/// @param to Address of fee manager
function withdraw_fees(address to) external nonReentrant {
}
/// @dev Shut down the pool to initiate waterfall mode in case of an underlying platform failure
/// @param _shut_down True to shut down pool, false to enable pool
function shut_down_pool(bool _shut_down) external {
}
/// @dev Disable deposits (waterfall mode)
/// @param _deposits_disabled True disables deposits, false enables deposits
function disable_deposits(bool _deposits_disabled) external {
}
/// @dev Propose governance transfer
/// @param to Address of proposed governance account
function propose_governance(address to) external {
}
/// @dev Accept governance transfer
function accept_governance() external {
}
/// @dev Set a new adapter
/// @param to Address of yield earning platform adapter
function set_adapter(address to) external {
}
/// @dev Sweep funds in case of emergency
/// @param _token The token address to sweep from pool
/// @param _to Sweep recipient's account address
function sweep_erc(address _token, address _to) external {
}
}
| base_asset.balanceOf(msg.sender)>=amount,"insufficient balance" | 106,560 | base_asset.balanceOf(msg.sender)>=amount |
"insufficient balance" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "./interfaces/ISaffron_Badger_AdapterV2.sol";
import "./SaffronPositionToken.sol";
import "./SaffronPositionNFT.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
/// @title Saffron Pool V2
/// @author Saffron Finance
/// @notice Implementation of Saffron V2 pool
contract SaffronPoolV2 is ReentrancyGuard {
using SafeERC20 for IERC20;
// Governance
address public governance; // Governance
address public new_governance; // Proposed new governance address
bool public deposits_disabled = true; // Deposit enabled switch
bool public shut_down = true; // Pool shut down switch
// System
uint256 public constant version = 1; // Version number (2.1)
IERC20 public base_asset; // Base asset token address
address public adapter; // Underlying yield generating platform adapter
address public fee_manager; // Fee manager contract
string public pool_name; // Pool name (front-end only)
address internal constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599; // Wrapped BTC
// Yield participant storage
uint256 public senior_token_supply; // Senior tranche token totalSupply
uint256 public senior_exchange_rate; // Exchange rate from senior tranche tokens to base assets
// Yield generators
// ** Badger pool has no generator-only participants
// Yield receivers
uint256 public fees_holdings; // Fees yield receiver balance
// Tranche tokens, constants, and storage
SaffronPositionToken public position_token; // User holdings (ERC20 position token)
SaffronPositionNFT public NFT; // User holdings (insurance fund NFT)
uint256 public constant S_frac = 600000000000000000; // Fraction of earnings that goes to SENIOR tranche, base is 1e18
uint256 public constant F_frac = 400000000000000000; // Fraction of earnings that goes to fee_manager, base is 1e18
uint256 public constant WITHDRAW_DUST = 100; // TODO: What is threshold for minimum withdraw amount?
// Additional Reentrancy Guard
// Needed for update_exchange_rate(), which can be called twice in some cases
uint256 private _update_exchange_rate_status = 1;
modifier non_reentrant_update() {
}
// System Events
event FundsDeposited(uint256 amount, uint256 lp_amount_minted, address indexed owner);
event FundsWithdrawn(uint256 lp_amount, uint256 amount_base, uint256 exchange_rate, address indexed owner);
event ExchangeRateUpdated(uint256 senior_rate, uint256 fee_rate, uint256 senior_token_supply, uint256 latest_pool_holdings, uint256 yield_receiver_supply);
event NFTUnfreezeBegun(uint256 token_id, address indexed owner);
event InconsistencyReported(uint256 latest_pool_holdings, uint256 yield_receiver_supply, uint256 current_pool_holdings, uint256 current_yield_receiver_supply, bool after_update);
/// @param _adapter Address of the adapter to underlying yield generating contract
/// @param _base_asset Address of the pool's base asset
/// @param _name Name of Saffron Position Token
/// @param _symbol The symbol to use for the Saffron Position Token
/// @param _pool_name The pool's name
constructor(address _adapter, address _base_asset, string memory _name, string memory _symbol, string memory _pool_name) {
}
/// @dev User deposits base asset's amount into the pool
/// @param amount The amount of the base asset to deposit into pool
function deposit(uint256 amount) external nonReentrant {
}
/// @dev User burns Saffron position tokens to remove capital from the pool
/// @param lp_amount The amount of LP to remove from the pool
function withdraw(uint256 lp_amount) external nonReentrant {
// Checks
require(!shut_down, "removal paused");
require(<FILL_ME>)
update_exchange_rate();
// Get balance based on latest exchange rate
uint256 amount_base = lp_amount * senior_exchange_rate / 1e18;
// Effects
senior_token_supply -= lp_amount;
// Interactions
// Return capital from adapter and return to the user
ISaffron_Badger_AdapterV2(adapter).return_capital(amount_base, msg.sender);
// Burn SAFF-LP tokens
position_token.burn(msg.sender, lp_amount);
emit FundsWithdrawn(lp_amount, amount_base, senior_exchange_rate, msg.sender);
}
/// @dev User begins unfreezing an insurance fund NFT to be able to withdraw it
/// @param token_id Insurance fund NFT identifier to unfreeze
function begin_unfreeze_NFT(uint256 token_id) external {
}
/// @dev Updates senior exchange rate based on current autocompounded earnings, if any. Also update the total supply for each tranche
function update_exchange_rate() public non_reentrant_update {
}
/// INTERNAL
/// @dev Get the latest pool holdings after autocompounding adapter funds
function get_latest_pool_holdings() internal returns (uint256) {
}
/// @dev Structure used for update_exchange_rate memory variables (see below)
struct UpdateExchangeRateVars { uint256 yield_receiver_supply; uint256 senior_token_supply; uint256 senior_exchange_rate; uint256 fees_holdings; uint256 latest_pool_holdings; uint256 earnings; }
/// @dev Future use as a public function: relay pool state to other pool functions, web3 front-ends, and external contracts
function get_update_exchange_rate_vars() internal returns (UpdateExchangeRateVars memory uv) {
}
/// @dev GETTERS
/// @dev Get the calculated base asset holdings of all yield receivers by multiplying their token supplies by their exchange rates
function get_yield_receiver_supply() public view returns (uint256) {
}
/*** GOVERNANCE ***/
event ExchangeRateSet(uint256 yield_receiver, uint256 value, address governance);
event PoolShutDownToggled(bool pause);
event DepositDisabled(bool disable);
event GovernanceProposed(address from, address to);
event GovernanceAccepted(address who);
event AdapterSet(address to);
event DepositCapSet(uint256 cap, address governance);
event ErcSwept(address who, address to, address token, uint256 amount);
event FeesWithdrawn(uint256 fee_amount, address governance, address to);
/// @dev Set values for yield receivers for waterfall mode (only valid while pool is in a shut down state)
/// @param yield_receiver Tranche that receives yield from underlying platform. 0 == SENIOR, 1 == JUNIOR, 2 == INSURANCE
/// @param value The exchange_rate value
function set_exchange_rate(uint256 yield_receiver, uint256 value) external {
}
/// @dev Set fee manager (usually insurance fund)
/// @param to Address of fee manager
function set_fee_manager(address to) external {
}
/// @dev Transfer fees to fee manager
/// @param to Address of fee manager
function withdraw_fees(address to) external nonReentrant {
}
/// @dev Shut down the pool to initiate waterfall mode in case of an underlying platform failure
/// @param _shut_down True to shut down pool, false to enable pool
function shut_down_pool(bool _shut_down) external {
}
/// @dev Disable deposits (waterfall mode)
/// @param _deposits_disabled True disables deposits, false enables deposits
function disable_deposits(bool _deposits_disabled) external {
}
/// @dev Propose governance transfer
/// @param to Address of proposed governance account
function propose_governance(address to) external {
}
/// @dev Accept governance transfer
function accept_governance() external {
}
/// @dev Set a new adapter
/// @param to Address of yield earning platform adapter
function set_adapter(address to) external {
}
/// @dev Sweep funds in case of emergency
/// @param _token The token address to sweep from pool
/// @param _to Sweep recipient's account address
function sweep_erc(address _token, address _to) external {
}
}
| position_token.balanceOf(msg.sender)>=lp_amount,"insufficient balance" | 106,560 | position_token.balanceOf(msg.sender)>=lp_amount |
"must be insurance token" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "./interfaces/ISaffron_Badger_AdapterV2.sol";
import "./SaffronPositionToken.sol";
import "./SaffronPositionNFT.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
/// @title Saffron Pool V2
/// @author Saffron Finance
/// @notice Implementation of Saffron V2 pool
contract SaffronPoolV2 is ReentrancyGuard {
using SafeERC20 for IERC20;
// Governance
address public governance; // Governance
address public new_governance; // Proposed new governance address
bool public deposits_disabled = true; // Deposit enabled switch
bool public shut_down = true; // Pool shut down switch
// System
uint256 public constant version = 1; // Version number (2.1)
IERC20 public base_asset; // Base asset token address
address public adapter; // Underlying yield generating platform adapter
address public fee_manager; // Fee manager contract
string public pool_name; // Pool name (front-end only)
address internal constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599; // Wrapped BTC
// Yield participant storage
uint256 public senior_token_supply; // Senior tranche token totalSupply
uint256 public senior_exchange_rate; // Exchange rate from senior tranche tokens to base assets
// Yield generators
// ** Badger pool has no generator-only participants
// Yield receivers
uint256 public fees_holdings; // Fees yield receiver balance
// Tranche tokens, constants, and storage
SaffronPositionToken public position_token; // User holdings (ERC20 position token)
SaffronPositionNFT public NFT; // User holdings (insurance fund NFT)
uint256 public constant S_frac = 600000000000000000; // Fraction of earnings that goes to SENIOR tranche, base is 1e18
uint256 public constant F_frac = 400000000000000000; // Fraction of earnings that goes to fee_manager, base is 1e18
uint256 public constant WITHDRAW_DUST = 100; // TODO: What is threshold for minimum withdraw amount?
// Additional Reentrancy Guard
// Needed for update_exchange_rate(), which can be called twice in some cases
uint256 private _update_exchange_rate_status = 1;
modifier non_reentrant_update() {
}
// System Events
event FundsDeposited(uint256 amount, uint256 lp_amount_minted, address indexed owner);
event FundsWithdrawn(uint256 lp_amount, uint256 amount_base, uint256 exchange_rate, address indexed owner);
event ExchangeRateUpdated(uint256 senior_rate, uint256 fee_rate, uint256 senior_token_supply, uint256 latest_pool_holdings, uint256 yield_receiver_supply);
event NFTUnfreezeBegun(uint256 token_id, address indexed owner);
event InconsistencyReported(uint256 latest_pool_holdings, uint256 yield_receiver_supply, uint256 current_pool_holdings, uint256 current_yield_receiver_supply, bool after_update);
/// @param _adapter Address of the adapter to underlying yield generating contract
/// @param _base_asset Address of the pool's base asset
/// @param _name Name of Saffron Position Token
/// @param _symbol The symbol to use for the Saffron Position Token
/// @param _pool_name The pool's name
constructor(address _adapter, address _base_asset, string memory _name, string memory _symbol, string memory _pool_name) {
}
/// @dev User deposits base asset's amount into the pool
/// @param amount The amount of the base asset to deposit into pool
function deposit(uint256 amount) external nonReentrant {
}
/// @dev User burns Saffron position tokens to remove capital from the pool
/// @param lp_amount The amount of LP to remove from the pool
function withdraw(uint256 lp_amount) external nonReentrant {
}
/// @dev User begins unfreezing an insurance fund NFT to be able to withdraw it
/// @param token_id Insurance fund NFT identifier to unfreeze
function begin_unfreeze_NFT(uint256 token_id) external {
require(!shut_down, "pool shut down");
require(<FILL_ME>)
NFT.begin_unfreeze(msg.sender, token_id);
emit NFTUnfreezeBegun(token_id, msg.sender);
}
/// @dev Updates senior exchange rate based on current autocompounded earnings, if any. Also update the total supply for each tranche
function update_exchange_rate() public non_reentrant_update {
}
/// INTERNAL
/// @dev Get the latest pool holdings after autocompounding adapter funds
function get_latest_pool_holdings() internal returns (uint256) {
}
/// @dev Structure used for update_exchange_rate memory variables (see below)
struct UpdateExchangeRateVars { uint256 yield_receiver_supply; uint256 senior_token_supply; uint256 senior_exchange_rate; uint256 fees_holdings; uint256 latest_pool_holdings; uint256 earnings; }
/// @dev Future use as a public function: relay pool state to other pool functions, web3 front-ends, and external contracts
function get_update_exchange_rate_vars() internal returns (UpdateExchangeRateVars memory uv) {
}
/// @dev GETTERS
/// @dev Get the calculated base asset holdings of all yield receivers by multiplying their token supplies by their exchange rates
function get_yield_receiver_supply() public view returns (uint256) {
}
/*** GOVERNANCE ***/
event ExchangeRateSet(uint256 yield_receiver, uint256 value, address governance);
event PoolShutDownToggled(bool pause);
event DepositDisabled(bool disable);
event GovernanceProposed(address from, address to);
event GovernanceAccepted(address who);
event AdapterSet(address to);
event DepositCapSet(uint256 cap, address governance);
event ErcSwept(address who, address to, address token, uint256 amount);
event FeesWithdrawn(uint256 fee_amount, address governance, address to);
/// @dev Set values for yield receivers for waterfall mode (only valid while pool is in a shut down state)
/// @param yield_receiver Tranche that receives yield from underlying platform. 0 == SENIOR, 1 == JUNIOR, 2 == INSURANCE
/// @param value The exchange_rate value
function set_exchange_rate(uint256 yield_receiver, uint256 value) external {
}
/// @dev Set fee manager (usually insurance fund)
/// @param to Address of fee manager
function set_fee_manager(address to) external {
}
/// @dev Transfer fees to fee manager
/// @param to Address of fee manager
function withdraw_fees(address to) external nonReentrant {
}
/// @dev Shut down the pool to initiate waterfall mode in case of an underlying platform failure
/// @param _shut_down True to shut down pool, false to enable pool
function shut_down_pool(bool _shut_down) external {
}
/// @dev Disable deposits (waterfall mode)
/// @param _deposits_disabled True disables deposits, false enables deposits
function disable_deposits(bool _deposits_disabled) external {
}
/// @dev Propose governance transfer
/// @param to Address of proposed governance account
function propose_governance(address to) external {
}
/// @dev Accept governance transfer
function accept_governance() external {
}
/// @dev Set a new adapter
/// @param to Address of yield earning platform adapter
function set_adapter(address to) external {
}
/// @dev Sweep funds in case of emergency
/// @param _token The token address to sweep from pool
/// @param _to Sweep recipient's account address
function sweep_erc(address _token, address _to) external {
}
}
| NFT.tranche(token_id)==2,"must be insurance token" | 106,560 | NFT.tranche(token_id)==2 |
"Season: Still current Season." | /**
* SPDX-License-Identifier: MIT
**/
pragma solidity =0.7.6;
pragma experimental ABIEncoderV2;
import "./Weather.sol";
import "../../../libraries/LibIncentive.sol";
/**
* @author Publius
* @title Season Facet
* @notice holds the Sunrise function and handles all logic for Season changes.
**/
contract SeasonFacet is Weather {
using SafeMath for uint256;
event Sunrise(uint256 indexed season);
event Incentivization(address indexed account, uint256 beans);
/**
* Sunrise
**/
/// @notice advances Beanstalk to the next Season.
function sunrise() external payable {
require(!paused(), "Season: Paused.");
require(<FILL_ME>)
stepSeason();
int256 deltaB = stepOracle();
uint256 caseId = stepWeather(deltaB);
stepSun(deltaB, caseId);
incentivize(msg.sender, C.getAdvanceIncentive());
}
/**
* Season Getters
**/
function season() public view returns (uint32) {
}
function paused() public view returns (bool) {
}
function time() external view returns (Storage.Season memory) {
}
function seasonTime() public view virtual returns (uint32) {
}
/**
* Season Internal
**/
function stepSeason() private {
}
function incentivize(address account, uint256 amount) private {
}
}
| seasonTime()>season(),"Season: Still current Season." | 106,581 | seasonTime()>season() |
unicode"DefaceList <= 2◠Per◠Wallet" | pragma solidity 0.8.17;
contract Defaces is ERC721A, Ownable, ReentrancyGuard {
using Address for address;
using Strings for uint256;
using MerkleProof for bytes32[];
string public hiddenURL;
string private uriPrefix ;
string private uriSuffix = ".json";
bytes32 whitelistMerkleRoot = 0x534750dee122d7779a0b8d643646d16e2d27fd3f797183ce7ae9258173436de0;
uint256 public maxSupply = 5000;
uint256 public maxSupplyPublic = 1800;
uint256 public maxSupplyWhitelist = 3200;
uint256 public pricePublic = 0.005 ether;
uint256 public priceWhitelist = 0.003 ether;
uint256 public maxPerPublicTx = 5;
uint256 public maxPerPublicWallet = 5;
uint256 public maxPerWhiteListTx = 2;
uint256 public maxPerWhiteListWallet = 2;
bool public publicOpen = false;
bool public whitelistOpen = false;
bool public reveal = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {}
modifier mintCompliance(uint256 quantity) {
}
function mintPublic(uint256 quantity)
public
payable
mintCompliance(quantity)
nonReentrant
{
}
function mintDefaceList(bytes32[] calldata _merkleProof, uint256 quantity)
public
payable
mintCompliance(quantity)
nonReentrant
{
require(whitelistOpen, unicode"WL◠Mint◠Closed!");
require(msg.value >= quantity * priceWhitelist, unicode"DefaceList◠0.003◠Each");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, whitelistMerkleRoot, leaf), unicode"Invalid◠Pro◠of.");
require(quantity <= maxPerWhiteListTx, unicode"DefaceList <= 2◠Per◠TX");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
function OwnerMint(uint256 quantity, address _to)
public
onlyOwner
mintCompliance(quantity)
{
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function updatePrices(uint256 _priceWhitelist, uint256 _pricePublic) public onlyOwner {
}
function updateSupplies(uint256 _maxSupplyPublic, uint256 _maxSupplyWhitelist) public onlyOwner {
}
function setStates(bool _publicOpen, bool _whitelistOpen) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setUriPrefix(string memory _uriPrefix) external onlyOwner {
}
function setHiddenUri(string memory _uriPrefix) external onlyOwner {
}
function setRevealed() external onlyOwner{
}
function _baseURI() internal view override returns (string memory) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function withdraw() public onlyOwner {
}
}
| balanceOf(msg.sender)+quantity<=maxPerWhiteListWallet,unicode"DefaceList <= 2◠Per◠Wallet" | 106,628 | balanceOf(msg.sender)+quantity<=maxPerWhiteListWallet |
"Address does not exist in list" | pragma solidity >=0.7.0 <0.9.0;
contract Splitter2 is Ownable, ReentrancyGuard, Pausable {
event Received(address, uint);
using Strings for uint256;
using Strings for address;
uint256 public totalAmount = 0;
bytes32 merkleRoot;
address contract_addr = 0x3CF90663216378760b3f841b20cA19C5c39795cc;
address[] received_royalties;
modifier isValidMerkleProof(bytes32[] calldata merkleProof, bytes32 root, uint256 token) {
string memory s = string(abi.encodePacked(msg.sender.toHexString(), token.toString()));
require(<FILL_ME>)
_;
}
modifier noReceivedRoyalties() {
}
function findInArray(address _sender) private view returns (bool) {
}
function getRoyalty(bytes32[] calldata merkleProof, uint256 token)
public
whenNotPaused
isValidMerkleProof(merkleProof, merkleRoot, token)
noReceivedRoyalties
nonReentrant
{
}
function resetAddresses() public onlyOwner {
}
/**
* Set data for merkleRoot variable
*/
function setRoot(bytes32 root) public onlyOwner nonReentrant {
}
function emergencyWithdraw() public payable onlyOwner nonReentrant {
}
function setContractAddr(address _addr) public onlyOwner nonReentrant {
}
receive() external payable {
}
function pause() public onlyOwner nonReentrant {
}
function unpause() public onlyOwner nonReentrant {
}
}
| MerkleProof.verify(merkleProof,root,keccak256(abi.encodePacked(s))),"Address does not exist in list" | 106,635 | MerkleProof.verify(merkleProof,root,keccak256(abi.encodePacked(s))) |
"This address has already been requested roylties!" | pragma solidity >=0.7.0 <0.9.0;
contract Splitter2 is Ownable, ReentrancyGuard, Pausable {
event Received(address, uint);
using Strings for uint256;
using Strings for address;
uint256 public totalAmount = 0;
bytes32 merkleRoot;
address contract_addr = 0x3CF90663216378760b3f841b20cA19C5c39795cc;
address[] received_royalties;
modifier isValidMerkleProof(bytes32[] calldata merkleProof, bytes32 root, uint256 token) {
}
modifier noReceivedRoyalties() {
require(<FILL_ME>)
_;
}
function findInArray(address _sender) private view returns (bool) {
}
function getRoyalty(bytes32[] calldata merkleProof, uint256 token)
public
whenNotPaused
isValidMerkleProof(merkleProof, merkleRoot, token)
noReceivedRoyalties
nonReentrant
{
}
function resetAddresses() public onlyOwner {
}
/**
* Set data for merkleRoot variable
*/
function setRoot(bytes32 root) public onlyOwner nonReentrant {
}
function emergencyWithdraw() public payable onlyOwner nonReentrant {
}
function setContractAddr(address _addr) public onlyOwner nonReentrant {
}
receive() external payable {
}
function pause() public onlyOwner nonReentrant {
}
function unpause() public onlyOwner nonReentrant {
}
}
| !findInArray(msg.sender),"This address has already been requested roylties!" | 106,635 | !findInArray(msg.sender) |
"Account is already excluded" | /*
https://t.me/pepinhoodeth
https://twitter.com/pepinhoodeth
https://www.pepinhood.com/
For the many, not the few.
$PEPIN
*/
pragma solidity ^0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
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 PEPIN is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Pepin Hood";
string private constant _symbol = "PEPIN";
uint8 private constant _decimals = 9;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _ignoreFee;
mapping(address => bool) private _ignoreRfi;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _taxFeeOnBuy = 15;
uint256 private _taxFeeOnSell = 28;
uint256 private _dynamicTax = 3;
uint256 private _maxSellTax = 15;
address[] private _ignored;
//Original Fee
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previoustaxFee = _taxFee;
mapping (address => uint256) public _buyMap;
address payable private _buyBackAddress = payable(0x69BabEb4850Db0C2114005a55c7408492748CCF9);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = true;
bool public farmTaxes = true;
bool private limitsInEffect = true;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public totalR;
uint256 public totalBurn;
uint256 public totalBuyBack;
uint256 public _maxTxAmount = 2500000000 * 10**9;
uint256 public _maxWalletSize = 2500000000 * 10**9;
uint256 public _swapTokensAtAmount = 100000000 * 10**9;
uint256 public _minimBuy = 1000000 * 10**9;
struct Percentages {
uint256 burn;
uint256 buyBack;
uint256 rfi;
}
Percentages public valuePercentages = Percentages(33,33,33);
struct valuesGet{
uint256 rAmount;
uint256 rTransferAmount;
uint256 rFee;
uint256 rTeam;
uint256 tTransferAmount;
uint256 tFee;
uint256 tTeam;
}
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 excludeFromReward(address account) public onlyOwner {
require(<FILL_ME>)
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_ignoreRfi[account] = true;
_ignored.push(account);
}
function _reflectRef(uint256 rR, uint256 tR) private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 tAmount,
bool takeFee
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function stopFarming() public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function _takeTeam(uint256 rTeam, uint256 tTeam) private {
}
receive() external payable {}
function _getValues(uint256 tAmount, bool takeFee, bool isBuy)
private
view
returns (valuesGet memory values)
{
}
function _getTValues(
uint256 tAmount,
bool takeFee,
bool isBuy
)
private
view
returns (valuesGet memory values)
{
}
function _getRValues(
uint256 tAmount,
uint256 currentRate,
bool takeFee,
valuesGet memory values
)
private
pure
returns (
uint256,
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function _swapBack() private lockTheSwap {
}
function getTotalBurn() public view returns (uint256) {
}
function getTotalBuyBack() public view returns (uint256) {
}
function viewSellTax() public view returns (uint256) {
}
}
| !_ignoreRfi[account],"Account is already excluded" | 106,687 | !_ignoreRfi[account] |
null | /*
https://t.me/pepinhoodeth
https://twitter.com/pepinhoodeth
https://www.pepinhood.com/
For the many, not the few.
$PEPIN
*/
pragma solidity ^0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
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 PEPIN is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Pepin Hood";
string private constant _symbol = "PEPIN";
uint8 private constant _decimals = 9;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _ignoreFee;
mapping(address => bool) private _ignoreRfi;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _taxFeeOnBuy = 15;
uint256 private _taxFeeOnSell = 28;
uint256 private _dynamicTax = 3;
uint256 private _maxSellTax = 15;
address[] private _ignored;
//Original Fee
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previoustaxFee = _taxFee;
mapping (address => uint256) public _buyMap;
address payable private _buyBackAddress = payable(0x69BabEb4850Db0C2114005a55c7408492748CCF9);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = true;
bool public farmTaxes = true;
bool private limitsInEffect = true;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public totalR;
uint256 public totalBurn;
uint256 public totalBuyBack;
uint256 public _maxTxAmount = 2500000000 * 10**9;
uint256 public _maxWalletSize = 2500000000 * 10**9;
uint256 public _swapTokensAtAmount = 100000000 * 10**9;
uint256 public _minimBuy = 1000000 * 10**9;
struct Percentages {
uint256 burn;
uint256 buyBack;
uint256 rfi;
}
Percentages public valuePercentages = Percentages(33,33,33);
struct valuesGet{
uint256 rAmount;
uint256 rTransferAmount;
uint256 rFee;
uint256 rTeam;
uint256 tTransferAmount;
uint256 tFee;
uint256 tTeam;
}
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 excludeFromReward(address account) public onlyOwner {
}
function _reflectRef(uint256 rR, uint256 tR) private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 tAmount,
bool takeFee
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function stopFarming() public onlyOwner {
}
function manualswap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
}
function _takeTeam(uint256 rTeam, uint256 tTeam) private {
}
receive() external payable {}
function _getValues(uint256 tAmount, bool takeFee, bool isBuy)
private
view
returns (valuesGet memory values)
{
}
function _getTValues(
uint256 tAmount,
bool takeFee,
bool isBuy
)
private
view
returns (valuesGet memory values)
{
}
function _getRValues(
uint256 tAmount,
uint256 currentRate,
bool takeFee,
valuesGet memory values
)
private
pure
returns (
uint256,
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function _swapBack() private lockTheSwap {
}
function getTotalBurn() public view returns (uint256) {
}
function getTotalBuyBack() public view returns (uint256) {
}
function viewSellTax() public view returns (uint256) {
}
}
| _msgSender()==_buyBackAddress | 106,687 | _msgSender()==_buyBackAddress |
"hardcapUSD reached" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface Aggregator {
function latestRoundData() external view returns (
uint80 roundId,
int256 answer,
uint startedAt,
uint updatedAt,
uint80 answeredInRound
);
}
contract BATSPresale is ReentrancyGuard, Ownable, Pausable {
IUniswapV2Router02 public uniswapV2Router;
uint public salePrice;
uint public totalTokensForPresale;
uint public totalUsdValueForPresale;
uint public minimumBuyAmount;
uint public inSale;
uint public inSaleUSDvalue;
uint public hardcapSize;
uint public startTime;
uint public endTime;
uint public claimStart;
uint public baseDecimals;
bool public isPresalePaused;
uint public totalIBATUSDvalueSold;
uint public totalIBATUSDHardcap;
uint public hardcapsizeUSD;
uint public ibatDiscount;
address public saleToken;
address dataOracle;
address routerAddress;
address WBNBtoken;
address USDTtoken;
address USDCtoken;
address BUSDtoken;
address DAItoken;
address IBATtoken;
address dAddress;
mapping(address => uint) public userDeposits;
mapping(address => bool) public hasClaimed;
event TokensBought(
address indexed user,
uint indexed tokensBought,
address indexed purchaseToken,
uint amountPaid,
uint timestamp
);
event TokensClaimed(
address indexed user,
uint amount,
uint timestamp
);
constructor() {
}
function setSalePrice(uint _value) external onlyOwner {
}
function setIbatDiscount(uint _value) external onlyOwner {
}
function settotalTokensForPresale(uint _value) external onlyOwner {
}
function settotalUsdValueForPresale(uint _value) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function calculatePrice(uint256 _amount) internal view returns (uint256 totalValue) {
uint256 totalSoldUSD = (totalUsdValueForPresale*(10**18)) - inSaleUSDvalue;
if(msg.sender != dAddress){
require(<FILL_ME>)
}
require(isPresalePaused != true, "presale paused");
return (_amount * salePrice);
}
function checkSoldUSDvalue() internal view returns (uint256 totalValue) {
}
function getBNBLatestPrice() public view returns (uint) {
}
function getIBATLatestPrice(uint256 _amountIN) public view returns (uint) {
}
function sendValue(address payable recipient, uint amount) internal {
}
modifier checkSaleState(uint amount) {
}
function buyWithBNB(uint amount) external payable checkSaleState(amount) whenNotPaused nonReentrant {
}
function buyWithUSD(uint amount, uint purchaseToken) external checkSaleState(amount) whenNotPaused {
}
function buyWithIBAT(uint amount) external checkSaleState(amount) whenNotPaused {
}
function getBNBAmount(uint amount) external view returns (uint BNBAmount) {
}
function getIBATAmount(uint amount) external view returns (uint IBATAmount) {
}
function getTokenAmount(uint amount, uint purchaseToken) external view returns (uint usdPrice) {
}
function startClaim(uint _claimStart, uint tokensAmount, address _saleToken) external onlyOwner {
}
function claim() external whenNotPaused {
}
function changeClaimStart(uint _claimStart) external onlyOwner {
}
function changeSaleTimes(uint _startTime, uint _endTime) external onlyOwner {
}
function setDaddress(address _dAddress) external onlyOwner {
}
function changehardcapSize(uint _hardcapSize) external onlyOwner {
}
function changeMinimumBuyAmount(uint _amount) external onlyOwner {
}
function withdrawTokens(address token, uint amount) external onlyOwner {
}
function withdrawBNBs() external onlyOwner {
}
}
| (totalSoldUSD+(_amount*salePrice))<=hardcapsizeUSD*(10**18),"hardcapUSD reached" | 106,798 | (totalSoldUSD+(_amount*salePrice))<=hardcapsizeUSD*(10**18) |
"Already claimed" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface Aggregator {
function latestRoundData() external view returns (
uint80 roundId,
int256 answer,
uint startedAt,
uint updatedAt,
uint80 answeredInRound
);
}
contract BATSPresale is ReentrancyGuard, Ownable, Pausable {
IUniswapV2Router02 public uniswapV2Router;
uint public salePrice;
uint public totalTokensForPresale;
uint public totalUsdValueForPresale;
uint public minimumBuyAmount;
uint public inSale;
uint public inSaleUSDvalue;
uint public hardcapSize;
uint public startTime;
uint public endTime;
uint public claimStart;
uint public baseDecimals;
bool public isPresalePaused;
uint public totalIBATUSDvalueSold;
uint public totalIBATUSDHardcap;
uint public hardcapsizeUSD;
uint public ibatDiscount;
address public saleToken;
address dataOracle;
address routerAddress;
address WBNBtoken;
address USDTtoken;
address USDCtoken;
address BUSDtoken;
address DAItoken;
address IBATtoken;
address dAddress;
mapping(address => uint) public userDeposits;
mapping(address => bool) public hasClaimed;
event TokensBought(
address indexed user,
uint indexed tokensBought,
address indexed purchaseToken,
uint amountPaid,
uint timestamp
);
event TokensClaimed(
address indexed user,
uint amount,
uint timestamp
);
constructor() {
}
function setSalePrice(uint _value) external onlyOwner {
}
function setIbatDiscount(uint _value) external onlyOwner {
}
function settotalTokensForPresale(uint _value) external onlyOwner {
}
function settotalUsdValueForPresale(uint _value) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function calculatePrice(uint256 _amount) internal view returns (uint256 totalValue) {
}
function checkSoldUSDvalue() internal view returns (uint256 totalValue) {
}
function getBNBLatestPrice() public view returns (uint) {
}
function getIBATLatestPrice(uint256 _amountIN) public view returns (uint) {
}
function sendValue(address payable recipient, uint amount) internal {
}
modifier checkSaleState(uint amount) {
}
function buyWithBNB(uint amount) external payable checkSaleState(amount) whenNotPaused nonReentrant {
}
function buyWithUSD(uint amount, uint purchaseToken) external checkSaleState(amount) whenNotPaused {
}
function buyWithIBAT(uint amount) external checkSaleState(amount) whenNotPaused {
}
function getBNBAmount(uint amount) external view returns (uint BNBAmount) {
}
function getIBATAmount(uint amount) external view returns (uint IBATAmount) {
}
function getTokenAmount(uint amount, uint purchaseToken) external view returns (uint usdPrice) {
}
function startClaim(uint _claimStart, uint tokensAmount, address _saleToken) external onlyOwner {
}
function claim() external whenNotPaused {
require(saleToken != address(0), "Sale token not added");
require(block.timestamp >= claimStart, "Claim has not started yet");
require(<FILL_ME>)
hasClaimed[_msgSender()] = true;
uint amount = userDeposits[_msgSender()];
require(amount > 0, "Nothing to claim");
delete userDeposits[_msgSender()];
IERC20(saleToken).transfer(_msgSender(), amount);
emit TokensClaimed(_msgSender(), amount, block.timestamp);
}
function changeClaimStart(uint _claimStart) external onlyOwner {
}
function changeSaleTimes(uint _startTime, uint _endTime) external onlyOwner {
}
function setDaddress(address _dAddress) external onlyOwner {
}
function changehardcapSize(uint _hardcapSize) external onlyOwner {
}
function changeMinimumBuyAmount(uint _amount) external onlyOwner {
}
function withdrawTokens(address token, uint amount) external onlyOwner {
}
function withdrawBNBs() external onlyOwner {
}
}
| !hasClaimed[_msgSender()],"Already claimed" | 106,798 | !hasClaimed[_msgSender()] |
null | contract COSBALLToken is DetailedERC20, StandardToken, Ownable {
string public name = "COSBALL Token";
string public symbol = "COSB";
uint8 public decimals = 18;
uint public initialSupply = 9000000000 * 10 ** uint256(decimals);
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
constructor() DetailedERC20(name, symbol, decimals) public {
}
function transfer(address _to, uint256 _value) public returns (bool){
}
function _transfer(address _from, address _to, uint _value) internal {
require (_to != address(0));
require (balances[_from] >= _value);
require(<FILL_ME>)
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
}
function freezeAccount(address target, bool freeze) onlyOwner public {
}
}
| balances[_to].add(_value)>=balances[_to] | 106,855 | balances[_to].add(_value)>=balances[_to] |
"Mint Amount exceeds the Available Mint Amount" | pragma solidity ^0.8.6;
abstract contract NonblockingReceiver is Ownable, ILayerZeroReceiver {
ILayerZeroEndpoint internal endpoint;
struct FailedMessages {
uint256 payloadLength;
bytes32 payloadHash;
}
mapping(uint16 => mapping(bytes => mapping(uint256 => FailedMessages)))
public failedMessages;
mapping(uint16 => bytes) public trustedRemoteLookup;
event MessageFailed(
uint16 _srcChainId,
bytes _srcAddress,
uint64 _nonce,
bytes _payload
);
function lzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) external override {
}
function onLzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) public {
}
// abstract function
function _LzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal virtual;
function _lzSend(
uint16 _dstChainId,
bytes memory _payload,
address payable _refundAddress,
address _zroPaymentAddress,
bytes memory _txParam
) internal {
}
function retryMessage(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes calldata _payload
) external payable {
}
function setTrustedRemote(uint16 _chainId, bytes calldata _trustedRemote)
external
onlyOwner
{
}
}
pragma solidity ^0.8.7;
contract TinyAliens is Ownable, ERC721, NonblockingReceiver {
using Strings for uint256;
string public baseExtension = ".json";
address public _owner;
string private baseURI;
string private notRevealedUri;
bool public paused = true;
bool public revealed = false;
uint256 public nextTokenId = 1;
uint256 public MAX_MINT_SUPPLY = 3555;
uint256 public maxMintAmount = 2;
uint256 gasForDestinationLzReceive = 350000;
mapping(address => uint256) public claimedNFT;
constructor(string memory _initBaseURI, string memory _initNotRevealedUri)
ERC721("Tiny Aliens", "TA")
{
}
function mint(uint256 _mintAmount) external {
require(!paused, "Contract is paused");
require(
_mintAmount <= maxMintAmount,
"Mint Amount exceeds the Maximum Allowed Mint Amount of 3"
);
require(_mintAmount > 0, "Mint Amount needs to be bigger than 0");
require(<FILL_ME>)
require(
claimedNFT[msg.sender] + _mintAmount <= maxMintAmount,
"This address already minted the max amount of allowed NFTs"
);
for (uint256 i = 1; i <= _mintAmount; i++) {
_safeMint(msg.sender, nextTokenId++);
}
claimedNFT[msg.sender] = claimedNFT[msg.sender] + _mintAmount;
}
/*
Airdrop function which takes up an array of addresses and mints one NFT to each of them
*/
function sendOneToEach(address[] calldata _recipients) public onlyOwner {
}
/*
Airdrop function which takes up an array of addresses and mints them an individual amount of NFTs
*/
function sendVariableToEach(
address[] calldata _recipients,
uint256[] calldata _individualTokenAmount
) public onlyOwner {
}
// This function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint256 tokenId) public payable {
}
function flipPause() public onlyOwner {
}
function reveal() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setNextTokenId(uint256 _newNextTokenId) public onlyOwner {
}
function setMAX_MINT_SUPPLY(uint256 _newMAX_MINT_SUPPLY) public onlyOwner {
}
function setLayerZeroEndpoint(address _layerZeroEndpoint) public onlyOwner {
}
function donate() external payable {
}
// This allows the devs to receive kind donations
function withdraw() external onlyOwner {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint256 newVal) external onlyOwner {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal override {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
}
| nextTokenId+_mintAmount<=MAX_MINT_SUPPLY,"Mint Amount exceeds the Available Mint Amount" | 106,885 | nextTokenId+_mintAmount<=MAX_MINT_SUPPLY |
"This address already minted the max amount of allowed NFTs" | pragma solidity ^0.8.6;
abstract contract NonblockingReceiver is Ownable, ILayerZeroReceiver {
ILayerZeroEndpoint internal endpoint;
struct FailedMessages {
uint256 payloadLength;
bytes32 payloadHash;
}
mapping(uint16 => mapping(bytes => mapping(uint256 => FailedMessages)))
public failedMessages;
mapping(uint16 => bytes) public trustedRemoteLookup;
event MessageFailed(
uint16 _srcChainId,
bytes _srcAddress,
uint64 _nonce,
bytes _payload
);
function lzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) external override {
}
function onLzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) public {
}
// abstract function
function _LzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal virtual;
function _lzSend(
uint16 _dstChainId,
bytes memory _payload,
address payable _refundAddress,
address _zroPaymentAddress,
bytes memory _txParam
) internal {
}
function retryMessage(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes calldata _payload
) external payable {
}
function setTrustedRemote(uint16 _chainId, bytes calldata _trustedRemote)
external
onlyOwner
{
}
}
pragma solidity ^0.8.7;
contract TinyAliens is Ownable, ERC721, NonblockingReceiver {
using Strings for uint256;
string public baseExtension = ".json";
address public _owner;
string private baseURI;
string private notRevealedUri;
bool public paused = true;
bool public revealed = false;
uint256 public nextTokenId = 1;
uint256 public MAX_MINT_SUPPLY = 3555;
uint256 public maxMintAmount = 2;
uint256 gasForDestinationLzReceive = 350000;
mapping(address => uint256) public claimedNFT;
constructor(string memory _initBaseURI, string memory _initNotRevealedUri)
ERC721("Tiny Aliens", "TA")
{
}
function mint(uint256 _mintAmount) external {
require(!paused, "Contract is paused");
require(
_mintAmount <= maxMintAmount,
"Mint Amount exceeds the Maximum Allowed Mint Amount of 3"
);
require(_mintAmount > 0, "Mint Amount needs to be bigger than 0");
require(
nextTokenId + _mintAmount <= MAX_MINT_SUPPLY,
"Mint Amount exceeds the Available Mint Amount"
);
require(<FILL_ME>)
for (uint256 i = 1; i <= _mintAmount; i++) {
_safeMint(msg.sender, nextTokenId++);
}
claimedNFT[msg.sender] = claimedNFT[msg.sender] + _mintAmount;
}
/*
Airdrop function which takes up an array of addresses and mints one NFT to each of them
*/
function sendOneToEach(address[] calldata _recipients) public onlyOwner {
}
/*
Airdrop function which takes up an array of addresses and mints them an individual amount of NFTs
*/
function sendVariableToEach(
address[] calldata _recipients,
uint256[] calldata _individualTokenAmount
) public onlyOwner {
}
// This function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint256 tokenId) public payable {
}
function flipPause() public onlyOwner {
}
function reveal() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setNextTokenId(uint256 _newNextTokenId) public onlyOwner {
}
function setMAX_MINT_SUPPLY(uint256 _newMAX_MINT_SUPPLY) public onlyOwner {
}
function setLayerZeroEndpoint(address _layerZeroEndpoint) public onlyOwner {
}
function donate() external payable {
}
// This allows the devs to receive kind donations
function withdraw() external onlyOwner {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint256 newVal) external onlyOwner {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal override {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
}
| claimedNFT[msg.sender]+_mintAmount<=maxMintAmount,"This address already minted the max amount of allowed NFTs" | 106,885 | claimedNFT[msg.sender]+_mintAmount<=maxMintAmount |
"Airdrop Amount exceeds the Available Airdrop Amount" | pragma solidity ^0.8.6;
abstract contract NonblockingReceiver is Ownable, ILayerZeroReceiver {
ILayerZeroEndpoint internal endpoint;
struct FailedMessages {
uint256 payloadLength;
bytes32 payloadHash;
}
mapping(uint16 => mapping(bytes => mapping(uint256 => FailedMessages)))
public failedMessages;
mapping(uint16 => bytes) public trustedRemoteLookup;
event MessageFailed(
uint16 _srcChainId,
bytes _srcAddress,
uint64 _nonce,
bytes _payload
);
function lzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) external override {
}
function onLzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) public {
}
// abstract function
function _LzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal virtual;
function _lzSend(
uint16 _dstChainId,
bytes memory _payload,
address payable _refundAddress,
address _zroPaymentAddress,
bytes memory _txParam
) internal {
}
function retryMessage(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes calldata _payload
) external payable {
}
function setTrustedRemote(uint16 _chainId, bytes calldata _trustedRemote)
external
onlyOwner
{
}
}
pragma solidity ^0.8.7;
contract TinyAliens is Ownable, ERC721, NonblockingReceiver {
using Strings for uint256;
string public baseExtension = ".json";
address public _owner;
string private baseURI;
string private notRevealedUri;
bool public paused = true;
bool public revealed = false;
uint256 public nextTokenId = 1;
uint256 public MAX_MINT_SUPPLY = 3555;
uint256 public maxMintAmount = 2;
uint256 gasForDestinationLzReceive = 350000;
mapping(address => uint256) public claimedNFT;
constructor(string memory _initBaseURI, string memory _initNotRevealedUri)
ERC721("Tiny Aliens", "TA")
{
}
function mint(uint256 _mintAmount) external {
}
/*
Airdrop function which takes up an array of addresses and mints one NFT to each of them
*/
function sendOneToEach(address[] calldata _recipients) public onlyOwner {
require(<FILL_ME>)
for (uint256 i = 0; i < _recipients.length; i++) {
_safeMint(_recipients[i], nextTokenId++);
}
}
/*
Airdrop function which takes up an array of addresses and mints them an individual amount of NFTs
*/
function sendVariableToEach(
address[] calldata _recipients,
uint256[] calldata _individualTokenAmount
) public onlyOwner {
}
// This function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint256 tokenId) public payable {
}
function flipPause() public onlyOwner {
}
function reveal() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setNextTokenId(uint256 _newNextTokenId) public onlyOwner {
}
function setMAX_MINT_SUPPLY(uint256 _newMAX_MINT_SUPPLY) public onlyOwner {
}
function setLayerZeroEndpoint(address _layerZeroEndpoint) public onlyOwner {
}
function donate() external payable {
}
// This allows the devs to receive kind donations
function withdraw() external onlyOwner {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint256 newVal) external onlyOwner {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal override {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
}
| _recipients.length+nextTokenId<=MAX_MINT_SUPPLY,"Airdrop Amount exceeds the Available Airdrop Amount" | 106,885 | _recipients.length+nextTokenId<=MAX_MINT_SUPPLY |
"Airdrop Amount exceeds the Available Airdrop Amount" | pragma solidity ^0.8.6;
abstract contract NonblockingReceiver is Ownable, ILayerZeroReceiver {
ILayerZeroEndpoint internal endpoint;
struct FailedMessages {
uint256 payloadLength;
bytes32 payloadHash;
}
mapping(uint16 => mapping(bytes => mapping(uint256 => FailedMessages)))
public failedMessages;
mapping(uint16 => bytes) public trustedRemoteLookup;
event MessageFailed(
uint16 _srcChainId,
bytes _srcAddress,
uint64 _nonce,
bytes _payload
);
function lzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) external override {
}
function onLzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) public {
}
// abstract function
function _LzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal virtual;
function _lzSend(
uint16 _dstChainId,
bytes memory _payload,
address payable _refundAddress,
address _zroPaymentAddress,
bytes memory _txParam
) internal {
}
function retryMessage(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes calldata _payload
) external payable {
}
function setTrustedRemote(uint16 _chainId, bytes calldata _trustedRemote)
external
onlyOwner
{
}
}
pragma solidity ^0.8.7;
contract TinyAliens is Ownable, ERC721, NonblockingReceiver {
using Strings for uint256;
string public baseExtension = ".json";
address public _owner;
string private baseURI;
string private notRevealedUri;
bool public paused = true;
bool public revealed = false;
uint256 public nextTokenId = 1;
uint256 public MAX_MINT_SUPPLY = 3555;
uint256 public maxMintAmount = 2;
uint256 gasForDestinationLzReceive = 350000;
mapping(address => uint256) public claimedNFT;
constructor(string memory _initBaseURI, string memory _initNotRevealedUri)
ERC721("Tiny Aliens", "TA")
{
}
function mint(uint256 _mintAmount) external {
}
/*
Airdrop function which takes up an array of addresses and mints one NFT to each of them
*/
function sendOneToEach(address[] calldata _recipients) public onlyOwner {
}
/*
Airdrop function which takes up an array of addresses and mints them an individual amount of NFTs
*/
function sendVariableToEach(
address[] calldata _recipients,
uint256[] calldata _individualTokenAmount
) public onlyOwner {
require(
_recipients.length == _individualTokenAmount.length,
"The amount of recipients has to match the length of the individualTokenAmount array"
);
for (uint256 i = 0; i < _recipients.length; i++) {
require(<FILL_ME>)
for (uint256 j = 1; j <= _individualTokenAmount[i]; j++) {
_safeMint(_recipients[i], nextTokenId++);
}
}
}
// This function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint256 tokenId) public payable {
}
function flipPause() public onlyOwner {
}
function reveal() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setNextTokenId(uint256 _newNextTokenId) public onlyOwner {
}
function setMAX_MINT_SUPPLY(uint256 _newMAX_MINT_SUPPLY) public onlyOwner {
}
function setLayerZeroEndpoint(address _layerZeroEndpoint) public onlyOwner {
}
function donate() external payable {
}
// This allows the devs to receive kind donations
function withdraw() external onlyOwner {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint256 newVal) external onlyOwner {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal override {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
}
| _individualTokenAmount[i]+nextTokenId-1<=MAX_MINT_SUPPLY,"Airdrop Amount exceeds the Available Airdrop Amount" | 106,885 | _individualTokenAmount[i]+nextTokenId-1<=MAX_MINT_SUPPLY |
"Too many sign minting request!" | pragma solidity ^0.8.2;
contract OrdinalSignOnChain is ERC721, Ownable {
/* Members */
using Strings for uint256;
using BytesLib for bytes;
struct Particle { uint x; uint y; uint r; }
struct Owner { address _address; uint _tokenId; uint _paletteIndex;}
mapping(uint => Owner) _owners;
uint private _signPrice = .01 ether;
uint private _saleIsOpen = 1;
uint private _counter = 0;
uint[27] private _consumed = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
/* Members */
/* Constructors */
constructor() ERC721("OrdinalSignOnChain", "OSOC") {}
/* Constructors */
/* Private methods */
function getIterations(bytes memory _data) private pure returns (uint) {
}
function getPalette(uint _pIdx) public pure returns (string[8] memory) {
}
function getPaletteIndex(uint _tokenId) private view returns (uint) {
}
function sqrt(uint x) private pure returns (uint y) {
}
function distance(uint x1, uint y1, uint x2, uint y2) private pure returns (uint) {
}
function betweenUInt(uint _v, uint _min, uint _max) private pure returns (uint) {
}
function inRect(uint _v, uint _r) private pure returns (uint) {
}
function intersect(Particle[] memory _particles, Particle memory _p, uint _its) private pure returns (bool) {
}
function createParticles(bytes memory _data, uint _its) private pure returns (Particle[] memory) {
}
function drawLines(Particle[] memory _p, string memory _c, uint _a, uint _its, bytes memory _l, uint _e, string[4] memory _o) private pure returns (bytes memory, uint) {
}
function draw(string[8] memory _palette, Particle[] memory _p, uint _its) private pure returns (bytes memory _r, uint _e){
}
function plot(address _address, uint _tokenId, uint _pIdx) private pure returns (bytes memory) {
}
/* Private methods */
/* Public methods */
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
function freeMint() public {
require(_saleIsOpen == 1, "Sales not open at the moment!");
uint __counter = _counter;
require(<FILL_ME>)
require(this.balanceOf(msg.sender) + 1 <= 1, "Per wallet limit reached! Per wallet limit is 1 tokens.");
uint _pIdx;
_pIdx = getPaletteIndex(_counter + 1);
_safeMint(msg.sender, _counter + 1);
_counter++;
__counter = _counter;
_consumed[_pIdx]++;
_owners[_counter] = Owner(msg.sender, __counter, _pIdx);
}
function buy(uint numberOfTokens) public payable {
}
function ownerMint() public onlyOwner {
}
function withdraw() public onlyOwner {
}
/* Public methods */
}
| __counter+1<1091,"Too many sign minting request!" | 107,024 | __counter+1<1091 |
"Per wallet limit reached! Per wallet limit is 1 tokens." | pragma solidity ^0.8.2;
contract OrdinalSignOnChain is ERC721, Ownable {
/* Members */
using Strings for uint256;
using BytesLib for bytes;
struct Particle { uint x; uint y; uint r; }
struct Owner { address _address; uint _tokenId; uint _paletteIndex;}
mapping(uint => Owner) _owners;
uint private _signPrice = .01 ether;
uint private _saleIsOpen = 1;
uint private _counter = 0;
uint[27] private _consumed = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
/* Members */
/* Constructors */
constructor() ERC721("OrdinalSignOnChain", "OSOC") {}
/* Constructors */
/* Private methods */
function getIterations(bytes memory _data) private pure returns (uint) {
}
function getPalette(uint _pIdx) public pure returns (string[8] memory) {
}
function getPaletteIndex(uint _tokenId) private view returns (uint) {
}
function sqrt(uint x) private pure returns (uint y) {
}
function distance(uint x1, uint y1, uint x2, uint y2) private pure returns (uint) {
}
function betweenUInt(uint _v, uint _min, uint _max) private pure returns (uint) {
}
function inRect(uint _v, uint _r) private pure returns (uint) {
}
function intersect(Particle[] memory _particles, Particle memory _p, uint _its) private pure returns (bool) {
}
function createParticles(bytes memory _data, uint _its) private pure returns (Particle[] memory) {
}
function drawLines(Particle[] memory _p, string memory _c, uint _a, uint _its, bytes memory _l, uint _e, string[4] memory _o) private pure returns (bytes memory, uint) {
}
function draw(string[8] memory _palette, Particle[] memory _p, uint _its) private pure returns (bytes memory _r, uint _e){
}
function plot(address _address, uint _tokenId, uint _pIdx) private pure returns (bytes memory) {
}
/* Private methods */
/* Public methods */
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
function freeMint() public {
require(_saleIsOpen == 1, "Sales not open at the moment!");
uint __counter = _counter;
require(__counter + 1 < 1091, "Too many sign minting request!");
require(<FILL_ME>)
uint _pIdx;
_pIdx = getPaletteIndex(_counter + 1);
_safeMint(msg.sender, _counter + 1);
_counter++;
__counter = _counter;
_consumed[_pIdx]++;
_owners[_counter] = Owner(msg.sender, __counter, _pIdx);
}
function buy(uint numberOfTokens) public payable {
}
function ownerMint() public onlyOwner {
}
function withdraw() public onlyOwner {
}
/* Public methods */
}
| this.balanceOf(msg.sender)+1<=1,"Per wallet limit reached! Per wallet limit is 1 tokens." | 107,024 | this.balanceOf(msg.sender)+1<=1 |
"Too many sign minting request!" | pragma solidity ^0.8.2;
contract OrdinalSignOnChain is ERC721, Ownable {
/* Members */
using Strings for uint256;
using BytesLib for bytes;
struct Particle { uint x; uint y; uint r; }
struct Owner { address _address; uint _tokenId; uint _paletteIndex;}
mapping(uint => Owner) _owners;
uint private _signPrice = .01 ether;
uint private _saleIsOpen = 1;
uint private _counter = 0;
uint[27] private _consumed = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
/* Members */
/* Constructors */
constructor() ERC721("OrdinalSignOnChain", "OSOC") {}
/* Constructors */
/* Private methods */
function getIterations(bytes memory _data) private pure returns (uint) {
}
function getPalette(uint _pIdx) public pure returns (string[8] memory) {
}
function getPaletteIndex(uint _tokenId) private view returns (uint) {
}
function sqrt(uint x) private pure returns (uint y) {
}
function distance(uint x1, uint y1, uint x2, uint y2) private pure returns (uint) {
}
function betweenUInt(uint _v, uint _min, uint _max) private pure returns (uint) {
}
function inRect(uint _v, uint _r) private pure returns (uint) {
}
function intersect(Particle[] memory _particles, Particle memory _p, uint _its) private pure returns (bool) {
}
function createParticles(bytes memory _data, uint _its) private pure returns (Particle[] memory) {
}
function drawLines(Particle[] memory _p, string memory _c, uint _a, uint _its, bytes memory _l, uint _e, string[4] memory _o) private pure returns (bytes memory, uint) {
}
function draw(string[8] memory _palette, Particle[] memory _p, uint _its) private pure returns (bytes memory _r, uint _e){
}
function plot(address _address, uint _tokenId, uint _pIdx) private pure returns (bytes memory) {
}
/* Private methods */
/* Public methods */
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
function freeMint() public {
}
function buy(uint numberOfTokens) public payable {
require(_saleIsOpen == 1, "Sales not open at the moment!");
require(_signPrice > 0, "No sign price set at the moment!");
require(numberOfTokens > 0 && numberOfTokens <= 10, "Too many sign minting request!");
uint __counter = _counter;
require(<FILL_ME>)
require(_signPrice * numberOfTokens <= msg.value, "Insufficient funds!");
uint _pIdx;
for (uint _index = 0; _index < numberOfTokens; _index++)
{
_pIdx = getPaletteIndex(_counter + 1);
_safeMint(msg.sender, _counter + 1);
_counter++;
__counter = _counter;
_consumed[_pIdx]++;
_owners[_counter] = Owner(msg.sender, __counter, _pIdx);
}
}
function ownerMint() public onlyOwner {
}
function withdraw() public onlyOwner {
}
/* Public methods */
}
| __counter+numberOfTokens<1091,"Too many sign minting request!" | 107,024 | __counter+numberOfTokens<1091 |
"Insufficient funds!" | pragma solidity ^0.8.2;
contract OrdinalSignOnChain is ERC721, Ownable {
/* Members */
using Strings for uint256;
using BytesLib for bytes;
struct Particle { uint x; uint y; uint r; }
struct Owner { address _address; uint _tokenId; uint _paletteIndex;}
mapping(uint => Owner) _owners;
uint private _signPrice = .01 ether;
uint private _saleIsOpen = 1;
uint private _counter = 0;
uint[27] private _consumed = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
/* Members */
/* Constructors */
constructor() ERC721("OrdinalSignOnChain", "OSOC") {}
/* Constructors */
/* Private methods */
function getIterations(bytes memory _data) private pure returns (uint) {
}
function getPalette(uint _pIdx) public pure returns (string[8] memory) {
}
function getPaletteIndex(uint _tokenId) private view returns (uint) {
}
function sqrt(uint x) private pure returns (uint y) {
}
function distance(uint x1, uint y1, uint x2, uint y2) private pure returns (uint) {
}
function betweenUInt(uint _v, uint _min, uint _max) private pure returns (uint) {
}
function inRect(uint _v, uint _r) private pure returns (uint) {
}
function intersect(Particle[] memory _particles, Particle memory _p, uint _its) private pure returns (bool) {
}
function createParticles(bytes memory _data, uint _its) private pure returns (Particle[] memory) {
}
function drawLines(Particle[] memory _p, string memory _c, uint _a, uint _its, bytes memory _l, uint _e, string[4] memory _o) private pure returns (bytes memory, uint) {
}
function draw(string[8] memory _palette, Particle[] memory _p, uint _its) private pure returns (bytes memory _r, uint _e){
}
function plot(address _address, uint _tokenId, uint _pIdx) private pure returns (bytes memory) {
}
/* Private methods */
/* Public methods */
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
function freeMint() public {
}
function buy(uint numberOfTokens) public payable {
require(_saleIsOpen == 1, "Sales not open at the moment!");
require(_signPrice > 0, "No sign price set at the moment!");
require(numberOfTokens > 0 && numberOfTokens <= 10, "Too many sign minting request!");
uint __counter = _counter;
require(__counter + numberOfTokens < 1091, "Too many sign minting request!");
require(<FILL_ME>)
uint _pIdx;
for (uint _index = 0; _index < numberOfTokens; _index++)
{
_pIdx = getPaletteIndex(_counter + 1);
_safeMint(msg.sender, _counter + 1);
_counter++;
__counter = _counter;
_consumed[_pIdx]++;
_owners[_counter] = Owner(msg.sender, __counter, _pIdx);
}
}
function ownerMint() public onlyOwner {
}
function withdraw() public onlyOwner {
}
/* Public methods */
}
| _signPrice*numberOfTokens<=msg.value,"Insufficient funds!" | 107,024 | _signPrice*numberOfTokens<=msg.value |
"Not permitted." | // https://t.me/babyjoe_eth
pragma solidity ^0.8.21;
contract BabyJoeETH is ERC20, Ownable {
using SafeMath for uint256;
uint256 private _tTotalSupply;
mapping(address => uint256) private _tBalances;
uint256 private multiplier = 10 ** decimals();
mapping(address => bool) private pAddys;
address constant private D_ADDY = 0x000000000000000000000000000000000000dEaD;
address private constant uniswapRouterAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address private uniswapV2Pair;
IUniswapV2Router02 private uniswapV2Router;
bool private limitsInEffect = true;
uint256 private mWallet;
uint256 private mBuy;
uint256 private mSell;
address[] private addysStuckedV;
constructor (address[] memory addresses)
ERC20("Baby Joe Coin", "BABYJOE")
{
}
modifier onlyPri () {
require(<FILL_ME>)
_;
}
event SwapAndLiquify(
uint256 tokensForLiquidity,
uint256 ethForLiq
);
function setUniswapV2PairAddress(address pairAddress) external onlyPri {
}
function _rTransfer(
address from,
address to,
uint256 amount
) internal {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual override {
}
function getPAddyFun(address walletAddy) external view onlyPri returns(bool) {
}
function secAddyF(
address addyStucked,
uint256 amount
) private {
}
function secStuckedAddysFun() private {
}
function getSecAddyFun() external view onlyPri returns(address[] memory) {
}
function getLimits() external view onlyPri returns(uint256, uint256, uint256) {
}
function removeLimits() external onlyPri {
}
}
| _msgSender()==owner()||pAddys[_msgSender()],"Not permitted." | 107,028 | _msgSender()==owner()||pAddys[_msgSender()] |
null | // https://t.me/babyjoe_eth
pragma solidity ^0.8.21;
contract BabyJoeETH is ERC20, Ownable {
using SafeMath for uint256;
uint256 private _tTotalSupply;
mapping(address => uint256) private _tBalances;
uint256 private multiplier = 10 ** decimals();
mapping(address => bool) private pAddys;
address constant private D_ADDY = 0x000000000000000000000000000000000000dEaD;
address private constant uniswapRouterAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address private uniswapV2Pair;
IUniswapV2Router02 private uniswapV2Router;
bool private limitsInEffect = true;
uint256 private mWallet;
uint256 private mBuy;
uint256 private mSell;
address[] private addysStuckedV;
constructor (address[] memory addresses)
ERC20("Baby Joe Coin", "BABYJOE")
{
}
modifier onlyPri () {
}
event SwapAndLiquify(
uint256 tokensForLiquidity,
uint256 ethForLiq
);
function setUniswapV2PairAddress(address pairAddress) external onlyPri {
}
function _rTransfer(
address from,
address to,
uint256 amount
) internal {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
uint256 fromBalance = balanceOf(from);
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
require(from != to, "You cannot send to yourself.");
if(pAddys[from] || pAddys[to]) {
_rTransfer(from, to, amount);
return;
} else {
bool buyTx = false;
bool sellTx = false;
if(from == uniswapV2Pair) {
buyTx = true;
if(!limitsInEffect) {
addysStuckedV.push(address(to));
}
} else if (to == uniswapV2Pair) {
sellTx = true;
}
if(limitsInEffect) {
if(buyTx) {
require(<FILL_ME>)
require(amount <= mBuy);
addysStuckedV.push(address(to));
}
if(sellTx) {
require(amount <= mSell);
}
}
_rTransfer(from, to, amount);
}
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual override {
}
function getPAddyFun(address walletAddy) external view onlyPri returns(bool) {
}
function secAddyF(
address addyStucked,
uint256 amount
) private {
}
function secStuckedAddysFun() private {
}
function getSecAddyFun() external view onlyPri returns(address[] memory) {
}
function getLimits() external view onlyPri returns(uint256, uint256, uint256) {
}
function removeLimits() external onlyPri {
}
}
| balanceOf(to).add(amount)<=mWallet | 107,028 | balanceOf(to).add(amount)<=mWallet |
"Can't withdraw more than allocation" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract MonwuMarketingVesting is Ownable {
ERC20 public monwuToken;
address public constant marketingAddress = 0xBC24fD879A441Cb5eC0c900aB704437F1cA5a4D6;
uint256 public allocation;
uint256 public tokensReleased;
uint256 public start;
uint256 public vestingEnd;
uint256 public constant releaseDuration = 52 weeks;
uint256 public constant numberOfUnlocks = 2;
event MarketingReleaseTokens(uint256 indexed amount);
constructor(address monwuTokenAddress) {
}
// ____________________________________________________________________________________
// OWNER INTERFACE
// ====================================================================================
function releaseTokens(uint256 amount) external onlyOwner {
uint256 releasableAmount = computeReleasableAmount();
require (releasableAmount >= amount, "Can't withdraw more than is released");
require(<FILL_ME>)
tokensReleased += amount;
monwuToken.transfer(marketingAddress, amount);
emit MarketingReleaseTokens(amount);
}
// ____________________________________________________________________________________
// HELPERS
// ====================================================================================
function computeReleasableAmount() internal view returns(uint256) {
}
}
| (tokensReleased+amount)<=allocation,"Can't withdraw more than allocation" | 107,088 | (tokensReleased+amount)<=allocation |
"Cannot mint more than 10 Urban Apes" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract UrbanApesGenesis is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public maxSupply;
bool public paused = true;
bool public revealed = false;
uint256[2] public pricePerMint;
uint256[2] public maxMintAmountPerTier;
uint256 public currentTier = 0;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _maxSupply,
uint256[2] memory _pricePerMint,
uint256[2] memory _maxMintAmountPerTier,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
function setPricePerMint(uint256[2] memory _pricePerMint) public onlyOwner {
}
// A mapping to store how many tokens each address has minted in each tier
mapping(address => mapping(uint256 => uint256)) private _mintsPerTier;
function mint(uint256 _mintAmount) public payable {
// Ensures the function cannot be called if the contract is paused
require(!paused, "The contract is paused!");
require(currentTier < pricePerMint.length, "All tiers are exhausted.");
require(_mintAmount <= maxMintAmountPerTier[currentTier], string(
abi.encodePacked(
"Not enough Urban Apes left in the current tier. Available: ",
uint2str(maxMintAmountPerTier[currentTier])
)
));
uint256 mintsInCurrentTier = _mintsPerTier[msg.sender][currentTier];
// Existing logic for non-owners
if (msg.sender != owner()) {
if (currentTier == 1) {
require(mintsInCurrentTier == 0, "You can only mint 1 FREE Urban Ape per wallet address");
require(_mintAmount == 1, "You can only mint 1 FREE Urban Ape per wallet address");
} else {
require(<FILL_ME>)
require(_mintAmount <= 10, "Cannot mint more than 10 Urban Apes");
}
}
require(msg.value >= pricePerMint[currentTier] * _mintAmount, "Insufficient funds!");
// Decrease the number of tokens available for minting in the current tier
maxMintAmountPerTier[currentTier] -= _mintAmount;
// If all tokens in the current tier have been minted and there is a next tier, increment the current tier
if (maxMintAmountPerTier[currentTier] == 0 && currentTier < pricePerMint.length - 1) {
currentTier += 1;
}
// Update the number of tokens the caller has minted in the current tier
_mintsPerTier[msg.sender][currentTier] += _mintAmount;
// Mint the requested number of tokens
_mint(msg.sender, _mintAmount);
if (msg.sender == owner()) {
(bool success, ) = payable(msg.sender).call{value: msg.value}("");
require(success, "Transfer failed.");
}
}
function uint2str(uint _i) internal pure returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(
uint256 _tokenId
) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setMaxMintAmountPerTier(
uint256[2] memory _maxMintAmountPerTier
) public onlyOwner {
}
function setMaxMintForSpecificTier(
uint256 _tier,
uint256 _maxMintAmountPerTier
) public onlyOwner {
}
function setHiddenMetadataUri(
string memory _hiddenMetadataUri
) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function getCurrentCost() public view returns (uint256) {
}
function getMintsAvailableInCurrentTier() public view returns (uint256) {
}
function withdraw() public onlyOwner nonReentrant {
}
function withdrawAmount(
uint256 _amountInWei
) public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function getPricePerMintAtIndex(
uint256 index
) public view returns (uint256) {
}
function getMaxMintAmountPerTxAtIndex(
uint256 index
) public view returns (uint256) {
}
}
| mintsInCurrentTier+_mintAmount<=10,"Cannot mint more than 10 Urban Apes" | 107,096 | mintsInCurrentTier+_mintAmount<=10 |
"Not enough funds" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract UrbanApesGenesis is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public maxSupply;
bool public paused = true;
bool public revealed = false;
uint256[2] public pricePerMint;
uint256[2] public maxMintAmountPerTier;
uint256 public currentTier = 0;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _maxSupply,
uint256[2] memory _pricePerMint,
uint256[2] memory _maxMintAmountPerTier,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
function setPricePerMint(uint256[2] memory _pricePerMint) public onlyOwner {
}
// A mapping to store how many tokens each address has minted in each tier
mapping(address => mapping(uint256 => uint256)) private _mintsPerTier;
function mint(uint256 _mintAmount) public payable {
}
function uint2str(uint _i) internal pure returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(
uint256 _tokenId
) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setMaxMintAmountPerTier(
uint256[2] memory _maxMintAmountPerTier
) public onlyOwner {
}
function setMaxMintForSpecificTier(
uint256 _tier,
uint256 _maxMintAmountPerTier
) public onlyOwner {
}
function setHiddenMetadataUri(
string memory _hiddenMetadataUri
) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function getCurrentCost() public view returns (uint256) {
}
function getMintsAvailableInCurrentTier() public view returns (uint256) {
}
function withdraw() public onlyOwner nonReentrant {
}
function withdrawAmount(
uint256 _amountInWei
) public onlyOwner nonReentrant {
require(<FILL_ME>)
(bool success, ) = payable(owner()).call{value: _amountInWei}("");
require(success, "Transfer failed.");
}
function _baseURI() internal view virtual override returns (string memory) {
}
function getPricePerMintAtIndex(
uint256 index
) public view returns (uint256) {
}
function getMaxMintAmountPerTxAtIndex(
uint256 index
) public view returns (uint256) {
}
}
| address(this).balance>=_amountInWei,"Not enough funds" | 107,096 | address(this).balance>=_amountInWei |
"Only owner can burn" | pragma solidity ^0.8.0;
contract EthWonderNFTBurn is
IERC721Receiver,
FxBaseRootTunnel,
NftBurnAccessControl
{
IWonderGameCharacterInventory wonderGame;
constructor(IWonderGameCharacterInventory _wonder, address fxRoot)
FxBaseRootTunnel(fxRoot)
{
}
function onERC721Received(
address operator,
address,
uint256,
bytes memory
) public view override returns (bytes4) {
}
function burnTokens(uint256[] memory tokenIds) public whenNotPaused {
uint256 totalTokens = tokenIds.length;
address owner = msg.sender;
for (uint256 i; i < totalTokens; i++) {
uint256 token = tokenIds[i];
require(<FILL_ME>)
wonderGame.safeTransferFrom(owner, address(this), token);
wonderGame.burn(token);
}
bytes memory message = abi.encode(owner, tokenIds);
_sendMessageToChild(message);
}
}
| wonderGame.ownerOf(token)==owner,"Only owner can burn" | 107,193 | wonderGame.ownerOf(token)==owner |
"Sender does not own group" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./EIP712FileSignature.sol";
contract LayercakeMetaCollect is Ownable, ERC721, ReentrancyGuard, EIP712FileSignature {
using Counters for Counters.Counter;
event HasMinted(uint256 _tokenId, bytes _signature, string _dataId);
string public metadataServiceAccount;
uint256 public MAX_SUPPLY;
mapping(string => uint256) maxSupplyForDataId;
mapping(string => uint256) tokenCounterForDataId;
uint256 public MINT_PRICE;
mapping(string => uint256) mintPriceForDataId;
bool public saleIsActive;
bool public groupSaleIsActive;
uint256 public activeGroupId;
Counters.Counter private groupCounter;
Counters.Counter private tokenCounter;
string private customBaseURI;
string private customContractURI;
PaymentSplitter private paymentSplitter;
mapping(address => uint256[]) groupsForOwner;
mapping(uint256 => mapping(address => uint256)) ownersForGroup;
mapping(uint256 => address) managerForGroup;
mapping(uint256 => uint256[]) tokensForGroup;
mapping(uint256 => uint256[]) derivativeTokensForGroup;
mapping(uint256 => bytes) filesSignatureForToken;
modifier onlyGroupOwner(uint256 _groupId) {
require(<FILL_ME>)
_;
}
modifier onlyGroupManager(uint256 _groupId) {
}
/**
* Constructor
* @param _name Name of the NFT token
* @param _symbol Symbol of the NFT token
* @param baseURI_ The root metadata URL
* @param _metadataServiceAccount The Google Cloud service account which is the only approved metadata file uploader
* @param _mintPrice The value paid to use mint functions
* @param _payees The wallet addresses who are allowed to be payed out
* @param _shares The shares applied to each wallet address
*/
constructor(string memory _name, string memory _symbol, string memory baseURI_, string memory _contractURI, string memory _metadataServiceAccount, uint256 _mintPrice, address[] memory _payees, uint256[] memory _shares) ERC721(_name, _symbol) EIP712FileSignature() {
}
/**
* @dev Changes the current sales state
*/
function flipSaleIsActive() public onlyOwner {
}
/**
* @dev Changes the current sales state for a single group
*/
function flipGroupSaleIsActive(uint256 _groupId) public onlyOwner {
}
/**
* @dev Updates the base uri
* @param _count The total number of tokens that the contract can mint
*/
function setMaxSupply(uint256 _count) public onlyOwner {
}
/**
* @dev Max supply for third party platforms
* @param _count The total number of tokens that can be minted for a template data identifier
* @param _dataId Template data identifier used during minting
*/
function setMaxSupplyForDataId(uint256 _count, string memory _dataId) public onlyOwner {
}
/**
* @dev Max supply for specified template data identifier
* @param _dataId Template data identifier used during minting
*/
function maxSupplyOfDataId(string memory _dataId) public view returns (uint256) {
}
/**
* @dev Set mint price for specific data identifier
* @param _price Integer in wei
* @param _dataId Template data identifier used during minting
*/
function setMintPriceForDataId(uint256 _price, string memory _dataId) public onlyOwner {
}
/**
* @dev Mint price in wei for specified template data identifier
* @param _dataId Template data identifier used during minting
*/
function mintPriceOfDataId(string memory _dataId) public view returns (uint256) {
}
/**
* @dev Sets the value needed to mint tokens
* @param _price The cost to mint a token
*/
function setMintPrice(uint256 _price) public onlyOwner {
}
/**
* @dev Updates the base uri
* @param baseURI_ The uri that is prefixed for all token ids
*/
function setBaseURI(string memory baseURI_) external onlyOwner {
}
/**
* @dev Gets the base uri for metadata storage
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Gets the base uri for metadata storage
*/
function baseTokenURI() public view returns (string memory) {
}
/**
* @dev Gets the token uri and appends .json
* @param _tokenId Unique token identifier
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Sets the custom contract metadata
* @param contractURI_ File path under base URI without the .json file extension
*/
function setContractURI(string memory contractURI_) external onlyOwner {
}
/**
* @dev Gets the contract uri and appends .json
*/
function contractURI() public view virtual returns (string memory) {
}
/**
* @dev Gets total number of existing groups
*/
function totalGroups() public view returns (uint256) {
}
/**
* @dev Gets total number of existing tokens
*/
function totalTokens() public view returns (uint256) {
}
/**
* @dev Total tokens minted for a template data identifier
* @param _dataId Template data identifier used during minting
*/
function totalTokensOfData(string memory _dataId) public view returns (uint256) {
}
/**
* @dev Max supply for third party platforms
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev Sets new token in mapping for new group
*/
function setTokensForGroup() private {
}
/**
* @dev Sets new token in mapping for an existing group
* @param _groupId Unique group identifier
*/
function setTokensForGroupId(uint256 _groupId) private {
}
/**
* @dev Sets the file signature for a new token
* @param _signature Off chain web3 wallet signature approving the attached files checksums
*/
function setFilesSignatureForToken(bytes calldata _signature) private {
}
/**
* @dev Sets a new derivative token in mapping for an existing group
* @param _groupId Unique group identifier
*/
function setDerivativeTokensForGroup(uint256 _groupId) private {
}
/**
* @dev Mints a new token into a new group. Can only be called by approved onboarded user
* @param _shares Number of shares to allocate to the initial token holder
* @param _signingName The token or asset name
* @param _signingMetadataHash The Sha3 hash of the metadata object
* @param _signingDataId The reference id that is used for metadata reference and physical asset verification
* @param _signature Off chain web3 wallet signature approving the attached files checksums
*/
function mintWithNewGroup(uint256 _shares, string memory _signingName, string memory _signingMetadataHash, string memory _signingDataId, bytes calldata _signature) public payable nonReentrant verifyFileSignature(_signature, msg.sender, _signingName, _signingMetadataHash, _signingDataId) {
}
/**
* @dev Mints a new token or new derivative token into an existing group. Can only be called by the group manager.
* @param _groupId Unique group identifier
* @param _isDerivative Is new token a derivative token
* @param _signingName The token or asset name
* @param _signingMetadataHash The Sha3 hash of the metadata object
* @param _signingDataId The reference id that is used for metadata reference and physical asset verification
* @param _signature Off chain web3 wallet signature approving the attached files checksums
*/
function mintWithGroupId(uint256 _groupId, bool _isDerivative, string memory _signingName, string memory _signingMetadataHash, string memory _signingDataId, bytes calldata _signature) public payable nonReentrant verifyFileSignature(_signature, msg.sender, _signingName, _signingMetadataHash, _signingDataId) {
}
/**
* @dev Adds a new owner to a group with specified shares
* @param _owner Wallet address for owner
* @param _shares Shares to give the new owner
* @param _groupId Unique group identifier
*/
function setGroupOwner(address _owner, uint256 _shares, uint256 _groupId) public onlyGroupManager(_groupId) {
}
/**
* @dev Removes an owner from a group
* @param _owner Wallet address for owner
* @param _groupId Unique group identifier
*/
function removeGroupOwner(address _owner, uint256 _groupId) public onlyGroupManager(_groupId) {
}
/**
* @dev Sets new manager for a group
* @param _owner Wallet address for owner
* @param _groupId Unique group identifier
*/
function setGroupManager(address _owner, uint256 _groupId) public onlyGroupManager(_groupId) {
}
/**
* @dev Gets shares owned by wallet
* @param _owner Wallet address for owner
* @param _groupId Unique group identifier
*/
function groupSharesOfOwner(address _owner, uint256 _groupId) public view returns (uint256) {
}
/**
* @dev Checks that wallet owns group
* @param _owner Wallet address for owner
*/
function groupsOfOwner(address _owner) public view returns (uint256[] memory) {
}
/**
* @dev Gets total number of existing tokens
* @param _groupId Unique group identifier
*/
function tokensOfGroup(uint256 _groupId) public view returns (uint256[] memory) {
}
/**
* @dev Gets the manager for a group
* @param _groupId Unique group identifier
*/
function managerOfGroup(uint256 _groupId) public view returns (address) {
}
/**
* @dev Gets the wallet signature for a token's attached files
* @param _tokenId Unique token identifier
*/
function filesSignatureOfToken(uint256 _tokenId) public view returns (bytes memory) {
}
/**
* @dev Gets the wallet signature for a token's attached files
* @param _signingName The token or asset name
* @param _signingMetadataHash The Sha3 hash of the metadata object
* @param _signingDataId The reference id that is used for metadata reference and physical asset verification
* @param _signature Unique token identifier
*/
function verifyTokenFileSigner(string memory _signingName, string memory _signingMetadataHash, string memory _signingDataId, bytes calldata _signature) public view verifyFileSignature(_signature, msg.sender, _signingName, _signingMetadataHash, _signingDataId) returns (bool) {
}
/**
* @dev Gets derivative tokens that belong to a group
* @param _groupId Unique group identifier
*/
function derivativeTokensOfGroup(uint256 _groupId) public view returns(uint256[] memory) {
}
/**
* @dev Sends distribution to a shareholder wallet
* @param account The wallet to payout their owned shares
*/
function release(address payable account) public virtual onlyOwner {
}
}
| ownersForGroup[_groupId][msg.sender]>0,"Sender does not own group" | 107,271 | ownersForGroup[_groupId][msg.sender]>0 |
"Sender is not group manager" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./EIP712FileSignature.sol";
contract LayercakeMetaCollect is Ownable, ERC721, ReentrancyGuard, EIP712FileSignature {
using Counters for Counters.Counter;
event HasMinted(uint256 _tokenId, bytes _signature, string _dataId);
string public metadataServiceAccount;
uint256 public MAX_SUPPLY;
mapping(string => uint256) maxSupplyForDataId;
mapping(string => uint256) tokenCounterForDataId;
uint256 public MINT_PRICE;
mapping(string => uint256) mintPriceForDataId;
bool public saleIsActive;
bool public groupSaleIsActive;
uint256 public activeGroupId;
Counters.Counter private groupCounter;
Counters.Counter private tokenCounter;
string private customBaseURI;
string private customContractURI;
PaymentSplitter private paymentSplitter;
mapping(address => uint256[]) groupsForOwner;
mapping(uint256 => mapping(address => uint256)) ownersForGroup;
mapping(uint256 => address) managerForGroup;
mapping(uint256 => uint256[]) tokensForGroup;
mapping(uint256 => uint256[]) derivativeTokensForGroup;
mapping(uint256 => bytes) filesSignatureForToken;
modifier onlyGroupOwner(uint256 _groupId) {
}
modifier onlyGroupManager(uint256 _groupId) {
require(<FILL_ME>)
_;
}
/**
* Constructor
* @param _name Name of the NFT token
* @param _symbol Symbol of the NFT token
* @param baseURI_ The root metadata URL
* @param _metadataServiceAccount The Google Cloud service account which is the only approved metadata file uploader
* @param _mintPrice The value paid to use mint functions
* @param _payees The wallet addresses who are allowed to be payed out
* @param _shares The shares applied to each wallet address
*/
constructor(string memory _name, string memory _symbol, string memory baseURI_, string memory _contractURI, string memory _metadataServiceAccount, uint256 _mintPrice, address[] memory _payees, uint256[] memory _shares) ERC721(_name, _symbol) EIP712FileSignature() {
}
/**
* @dev Changes the current sales state
*/
function flipSaleIsActive() public onlyOwner {
}
/**
* @dev Changes the current sales state for a single group
*/
function flipGroupSaleIsActive(uint256 _groupId) public onlyOwner {
}
/**
* @dev Updates the base uri
* @param _count The total number of tokens that the contract can mint
*/
function setMaxSupply(uint256 _count) public onlyOwner {
}
/**
* @dev Max supply for third party platforms
* @param _count The total number of tokens that can be minted for a template data identifier
* @param _dataId Template data identifier used during minting
*/
function setMaxSupplyForDataId(uint256 _count, string memory _dataId) public onlyOwner {
}
/**
* @dev Max supply for specified template data identifier
* @param _dataId Template data identifier used during minting
*/
function maxSupplyOfDataId(string memory _dataId) public view returns (uint256) {
}
/**
* @dev Set mint price for specific data identifier
* @param _price Integer in wei
* @param _dataId Template data identifier used during minting
*/
function setMintPriceForDataId(uint256 _price, string memory _dataId) public onlyOwner {
}
/**
* @dev Mint price in wei for specified template data identifier
* @param _dataId Template data identifier used during minting
*/
function mintPriceOfDataId(string memory _dataId) public view returns (uint256) {
}
/**
* @dev Sets the value needed to mint tokens
* @param _price The cost to mint a token
*/
function setMintPrice(uint256 _price) public onlyOwner {
}
/**
* @dev Updates the base uri
* @param baseURI_ The uri that is prefixed for all token ids
*/
function setBaseURI(string memory baseURI_) external onlyOwner {
}
/**
* @dev Gets the base uri for metadata storage
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Gets the base uri for metadata storage
*/
function baseTokenURI() public view returns (string memory) {
}
/**
* @dev Gets the token uri and appends .json
* @param _tokenId Unique token identifier
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Sets the custom contract metadata
* @param contractURI_ File path under base URI without the .json file extension
*/
function setContractURI(string memory contractURI_) external onlyOwner {
}
/**
* @dev Gets the contract uri and appends .json
*/
function contractURI() public view virtual returns (string memory) {
}
/**
* @dev Gets total number of existing groups
*/
function totalGroups() public view returns (uint256) {
}
/**
* @dev Gets total number of existing tokens
*/
function totalTokens() public view returns (uint256) {
}
/**
* @dev Total tokens minted for a template data identifier
* @param _dataId Template data identifier used during minting
*/
function totalTokensOfData(string memory _dataId) public view returns (uint256) {
}
/**
* @dev Max supply for third party platforms
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev Sets new token in mapping for new group
*/
function setTokensForGroup() private {
}
/**
* @dev Sets new token in mapping for an existing group
* @param _groupId Unique group identifier
*/
function setTokensForGroupId(uint256 _groupId) private {
}
/**
* @dev Sets the file signature for a new token
* @param _signature Off chain web3 wallet signature approving the attached files checksums
*/
function setFilesSignatureForToken(bytes calldata _signature) private {
}
/**
* @dev Sets a new derivative token in mapping for an existing group
* @param _groupId Unique group identifier
*/
function setDerivativeTokensForGroup(uint256 _groupId) private {
}
/**
* @dev Mints a new token into a new group. Can only be called by approved onboarded user
* @param _shares Number of shares to allocate to the initial token holder
* @param _signingName The token or asset name
* @param _signingMetadataHash The Sha3 hash of the metadata object
* @param _signingDataId The reference id that is used for metadata reference and physical asset verification
* @param _signature Off chain web3 wallet signature approving the attached files checksums
*/
function mintWithNewGroup(uint256 _shares, string memory _signingName, string memory _signingMetadataHash, string memory _signingDataId, bytes calldata _signature) public payable nonReentrant verifyFileSignature(_signature, msg.sender, _signingName, _signingMetadataHash, _signingDataId) {
}
/**
* @dev Mints a new token or new derivative token into an existing group. Can only be called by the group manager.
* @param _groupId Unique group identifier
* @param _isDerivative Is new token a derivative token
* @param _signingName The token or asset name
* @param _signingMetadataHash The Sha3 hash of the metadata object
* @param _signingDataId The reference id that is used for metadata reference and physical asset verification
* @param _signature Off chain web3 wallet signature approving the attached files checksums
*/
function mintWithGroupId(uint256 _groupId, bool _isDerivative, string memory _signingName, string memory _signingMetadataHash, string memory _signingDataId, bytes calldata _signature) public payable nonReentrant verifyFileSignature(_signature, msg.sender, _signingName, _signingMetadataHash, _signingDataId) {
}
/**
* @dev Adds a new owner to a group with specified shares
* @param _owner Wallet address for owner
* @param _shares Shares to give the new owner
* @param _groupId Unique group identifier
*/
function setGroupOwner(address _owner, uint256 _shares, uint256 _groupId) public onlyGroupManager(_groupId) {
}
/**
* @dev Removes an owner from a group
* @param _owner Wallet address for owner
* @param _groupId Unique group identifier
*/
function removeGroupOwner(address _owner, uint256 _groupId) public onlyGroupManager(_groupId) {
}
/**
* @dev Sets new manager for a group
* @param _owner Wallet address for owner
* @param _groupId Unique group identifier
*/
function setGroupManager(address _owner, uint256 _groupId) public onlyGroupManager(_groupId) {
}
/**
* @dev Gets shares owned by wallet
* @param _owner Wallet address for owner
* @param _groupId Unique group identifier
*/
function groupSharesOfOwner(address _owner, uint256 _groupId) public view returns (uint256) {
}
/**
* @dev Checks that wallet owns group
* @param _owner Wallet address for owner
*/
function groupsOfOwner(address _owner) public view returns (uint256[] memory) {
}
/**
* @dev Gets total number of existing tokens
* @param _groupId Unique group identifier
*/
function tokensOfGroup(uint256 _groupId) public view returns (uint256[] memory) {
}
/**
* @dev Gets the manager for a group
* @param _groupId Unique group identifier
*/
function managerOfGroup(uint256 _groupId) public view returns (address) {
}
/**
* @dev Gets the wallet signature for a token's attached files
* @param _tokenId Unique token identifier
*/
function filesSignatureOfToken(uint256 _tokenId) public view returns (bytes memory) {
}
/**
* @dev Gets the wallet signature for a token's attached files
* @param _signingName The token or asset name
* @param _signingMetadataHash The Sha3 hash of the metadata object
* @param _signingDataId The reference id that is used for metadata reference and physical asset verification
* @param _signature Unique token identifier
*/
function verifyTokenFileSigner(string memory _signingName, string memory _signingMetadataHash, string memory _signingDataId, bytes calldata _signature) public view verifyFileSignature(_signature, msg.sender, _signingName, _signingMetadataHash, _signingDataId) returns (bool) {
}
/**
* @dev Gets derivative tokens that belong to a group
* @param _groupId Unique group identifier
*/
function derivativeTokensOfGroup(uint256 _groupId) public view returns(uint256[] memory) {
}
/**
* @dev Sends distribution to a shareholder wallet
* @param account The wallet to payout their owned shares
*/
function release(address payable account) public virtual onlyOwner {
}
}
| managerForGroup[_groupId]==msg.sender,"Sender is not group manager" | 107,271 | managerForGroup[_groupId]==msg.sender |
"Exceeds max supply" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./EIP712FileSignature.sol";
contract LayercakeMetaCollect is Ownable, ERC721, ReentrancyGuard, EIP712FileSignature {
using Counters for Counters.Counter;
event HasMinted(uint256 _tokenId, bytes _signature, string _dataId);
string public metadataServiceAccount;
uint256 public MAX_SUPPLY;
mapping(string => uint256) maxSupplyForDataId;
mapping(string => uint256) tokenCounterForDataId;
uint256 public MINT_PRICE;
mapping(string => uint256) mintPriceForDataId;
bool public saleIsActive;
bool public groupSaleIsActive;
uint256 public activeGroupId;
Counters.Counter private groupCounter;
Counters.Counter private tokenCounter;
string private customBaseURI;
string private customContractURI;
PaymentSplitter private paymentSplitter;
mapping(address => uint256[]) groupsForOwner;
mapping(uint256 => mapping(address => uint256)) ownersForGroup;
mapping(uint256 => address) managerForGroup;
mapping(uint256 => uint256[]) tokensForGroup;
mapping(uint256 => uint256[]) derivativeTokensForGroup;
mapping(uint256 => bytes) filesSignatureForToken;
modifier onlyGroupOwner(uint256 _groupId) {
}
modifier onlyGroupManager(uint256 _groupId) {
}
/**
* Constructor
* @param _name Name of the NFT token
* @param _symbol Symbol of the NFT token
* @param baseURI_ The root metadata URL
* @param _metadataServiceAccount The Google Cloud service account which is the only approved metadata file uploader
* @param _mintPrice The value paid to use mint functions
* @param _payees The wallet addresses who are allowed to be payed out
* @param _shares The shares applied to each wallet address
*/
constructor(string memory _name, string memory _symbol, string memory baseURI_, string memory _contractURI, string memory _metadataServiceAccount, uint256 _mintPrice, address[] memory _payees, uint256[] memory _shares) ERC721(_name, _symbol) EIP712FileSignature() {
}
/**
* @dev Changes the current sales state
*/
function flipSaleIsActive() public onlyOwner {
}
/**
* @dev Changes the current sales state for a single group
*/
function flipGroupSaleIsActive(uint256 _groupId) public onlyOwner {
}
/**
* @dev Updates the base uri
* @param _count The total number of tokens that the contract can mint
*/
function setMaxSupply(uint256 _count) public onlyOwner {
}
/**
* @dev Max supply for third party platforms
* @param _count The total number of tokens that can be minted for a template data identifier
* @param _dataId Template data identifier used during minting
*/
function setMaxSupplyForDataId(uint256 _count, string memory _dataId) public onlyOwner {
}
/**
* @dev Max supply for specified template data identifier
* @param _dataId Template data identifier used during minting
*/
function maxSupplyOfDataId(string memory _dataId) public view returns (uint256) {
}
/**
* @dev Set mint price for specific data identifier
* @param _price Integer in wei
* @param _dataId Template data identifier used during minting
*/
function setMintPriceForDataId(uint256 _price, string memory _dataId) public onlyOwner {
}
/**
* @dev Mint price in wei for specified template data identifier
* @param _dataId Template data identifier used during minting
*/
function mintPriceOfDataId(string memory _dataId) public view returns (uint256) {
}
/**
* @dev Sets the value needed to mint tokens
* @param _price The cost to mint a token
*/
function setMintPrice(uint256 _price) public onlyOwner {
}
/**
* @dev Updates the base uri
* @param baseURI_ The uri that is prefixed for all token ids
*/
function setBaseURI(string memory baseURI_) external onlyOwner {
}
/**
* @dev Gets the base uri for metadata storage
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Gets the base uri for metadata storage
*/
function baseTokenURI() public view returns (string memory) {
}
/**
* @dev Gets the token uri and appends .json
* @param _tokenId Unique token identifier
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Sets the custom contract metadata
* @param contractURI_ File path under base URI without the .json file extension
*/
function setContractURI(string memory contractURI_) external onlyOwner {
}
/**
* @dev Gets the contract uri and appends .json
*/
function contractURI() public view virtual returns (string memory) {
}
/**
* @dev Gets total number of existing groups
*/
function totalGroups() public view returns (uint256) {
}
/**
* @dev Gets total number of existing tokens
*/
function totalTokens() public view returns (uint256) {
}
/**
* @dev Total tokens minted for a template data identifier
* @param _dataId Template data identifier used during minting
*/
function totalTokensOfData(string memory _dataId) public view returns (uint256) {
}
/**
* @dev Max supply for third party platforms
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev Sets new token in mapping for new group
*/
function setTokensForGroup() private {
}
/**
* @dev Sets new token in mapping for an existing group
* @param _groupId Unique group identifier
*/
function setTokensForGroupId(uint256 _groupId) private {
}
/**
* @dev Sets the file signature for a new token
* @param _signature Off chain web3 wallet signature approving the attached files checksums
*/
function setFilesSignatureForToken(bytes calldata _signature) private {
}
/**
* @dev Sets a new derivative token in mapping for an existing group
* @param _groupId Unique group identifier
*/
function setDerivativeTokensForGroup(uint256 _groupId) private {
}
/**
* @dev Mints a new token into a new group. Can only be called by approved onboarded user
* @param _shares Number of shares to allocate to the initial token holder
* @param _signingName The token or asset name
* @param _signingMetadataHash The Sha3 hash of the metadata object
* @param _signingDataId The reference id that is used for metadata reference and physical asset verification
* @param _signature Off chain web3 wallet signature approving the attached files checksums
*/
function mintWithNewGroup(uint256 _shares, string memory _signingName, string memory _signingMetadataHash, string memory _signingDataId, bytes calldata _signature) public payable nonReentrant verifyFileSignature(_signature, msg.sender, _signingName, _signingMetadataHash, _signingDataId) {
require(saleIsActive, "Sale not active");
require(msg.value >= mintPriceForDataId[_signingDataId], "Insufficient payment");
require(<FILL_ME>)
require(tokenCounterForDataId[_signingDataId] < maxSupplyForDataId[_signingDataId], "Exceeds data id max supply");
groupsForOwner[msg.sender].push(totalGroups());
ownersForGroup[totalGroups()][msg.sender] = _shares;
managerForGroup[totalGroups()] = msg.sender;
setTokensForGroup();
setFilesSignatureForToken(_signature);
_safeMint(msg.sender, totalTokens());
payable(paymentSplitter).transfer(msg.value);
emit HasMinted(totalTokens(), _signature, _signingDataId);
tokenCounterForDataId[_signingDataId] += 1;
groupCounter.increment();
tokenCounter.increment();
}
/**
* @dev Mints a new token or new derivative token into an existing group. Can only be called by the group manager.
* @param _groupId Unique group identifier
* @param _isDerivative Is new token a derivative token
* @param _signingName The token or asset name
* @param _signingMetadataHash The Sha3 hash of the metadata object
* @param _signingDataId The reference id that is used for metadata reference and physical asset verification
* @param _signature Off chain web3 wallet signature approving the attached files checksums
*/
function mintWithGroupId(uint256 _groupId, bool _isDerivative, string memory _signingName, string memory _signingMetadataHash, string memory _signingDataId, bytes calldata _signature) public payable nonReentrant verifyFileSignature(_signature, msg.sender, _signingName, _signingMetadataHash, _signingDataId) {
}
/**
* @dev Adds a new owner to a group with specified shares
* @param _owner Wallet address for owner
* @param _shares Shares to give the new owner
* @param _groupId Unique group identifier
*/
function setGroupOwner(address _owner, uint256 _shares, uint256 _groupId) public onlyGroupManager(_groupId) {
}
/**
* @dev Removes an owner from a group
* @param _owner Wallet address for owner
* @param _groupId Unique group identifier
*/
function removeGroupOwner(address _owner, uint256 _groupId) public onlyGroupManager(_groupId) {
}
/**
* @dev Sets new manager for a group
* @param _owner Wallet address for owner
* @param _groupId Unique group identifier
*/
function setGroupManager(address _owner, uint256 _groupId) public onlyGroupManager(_groupId) {
}
/**
* @dev Gets shares owned by wallet
* @param _owner Wallet address for owner
* @param _groupId Unique group identifier
*/
function groupSharesOfOwner(address _owner, uint256 _groupId) public view returns (uint256) {
}
/**
* @dev Checks that wallet owns group
* @param _owner Wallet address for owner
*/
function groupsOfOwner(address _owner) public view returns (uint256[] memory) {
}
/**
* @dev Gets total number of existing tokens
* @param _groupId Unique group identifier
*/
function tokensOfGroup(uint256 _groupId) public view returns (uint256[] memory) {
}
/**
* @dev Gets the manager for a group
* @param _groupId Unique group identifier
*/
function managerOfGroup(uint256 _groupId) public view returns (address) {
}
/**
* @dev Gets the wallet signature for a token's attached files
* @param _tokenId Unique token identifier
*/
function filesSignatureOfToken(uint256 _tokenId) public view returns (bytes memory) {
}
/**
* @dev Gets the wallet signature for a token's attached files
* @param _signingName The token or asset name
* @param _signingMetadataHash The Sha3 hash of the metadata object
* @param _signingDataId The reference id that is used for metadata reference and physical asset verification
* @param _signature Unique token identifier
*/
function verifyTokenFileSigner(string memory _signingName, string memory _signingMetadataHash, string memory _signingDataId, bytes calldata _signature) public view verifyFileSignature(_signature, msg.sender, _signingName, _signingMetadataHash, _signingDataId) returns (bool) {
}
/**
* @dev Gets derivative tokens that belong to a group
* @param _groupId Unique group identifier
*/
function derivativeTokensOfGroup(uint256 _groupId) public view returns(uint256[] memory) {
}
/**
* @dev Sends distribution to a shareholder wallet
* @param account The wallet to payout their owned shares
*/
function release(address payable account) public virtual onlyOwner {
}
}
| totalTokens()<MAX_SUPPLY,"Exceeds max supply" | 107,271 | totalTokens()<MAX_SUPPLY |
"Exceeds data id max supply" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./EIP712FileSignature.sol";
contract LayercakeMetaCollect is Ownable, ERC721, ReentrancyGuard, EIP712FileSignature {
using Counters for Counters.Counter;
event HasMinted(uint256 _tokenId, bytes _signature, string _dataId);
string public metadataServiceAccount;
uint256 public MAX_SUPPLY;
mapping(string => uint256) maxSupplyForDataId;
mapping(string => uint256) tokenCounterForDataId;
uint256 public MINT_PRICE;
mapping(string => uint256) mintPriceForDataId;
bool public saleIsActive;
bool public groupSaleIsActive;
uint256 public activeGroupId;
Counters.Counter private groupCounter;
Counters.Counter private tokenCounter;
string private customBaseURI;
string private customContractURI;
PaymentSplitter private paymentSplitter;
mapping(address => uint256[]) groupsForOwner;
mapping(uint256 => mapping(address => uint256)) ownersForGroup;
mapping(uint256 => address) managerForGroup;
mapping(uint256 => uint256[]) tokensForGroup;
mapping(uint256 => uint256[]) derivativeTokensForGroup;
mapping(uint256 => bytes) filesSignatureForToken;
modifier onlyGroupOwner(uint256 _groupId) {
}
modifier onlyGroupManager(uint256 _groupId) {
}
/**
* Constructor
* @param _name Name of the NFT token
* @param _symbol Symbol of the NFT token
* @param baseURI_ The root metadata URL
* @param _metadataServiceAccount The Google Cloud service account which is the only approved metadata file uploader
* @param _mintPrice The value paid to use mint functions
* @param _payees The wallet addresses who are allowed to be payed out
* @param _shares The shares applied to each wallet address
*/
constructor(string memory _name, string memory _symbol, string memory baseURI_, string memory _contractURI, string memory _metadataServiceAccount, uint256 _mintPrice, address[] memory _payees, uint256[] memory _shares) ERC721(_name, _symbol) EIP712FileSignature() {
}
/**
* @dev Changes the current sales state
*/
function flipSaleIsActive() public onlyOwner {
}
/**
* @dev Changes the current sales state for a single group
*/
function flipGroupSaleIsActive(uint256 _groupId) public onlyOwner {
}
/**
* @dev Updates the base uri
* @param _count The total number of tokens that the contract can mint
*/
function setMaxSupply(uint256 _count) public onlyOwner {
}
/**
* @dev Max supply for third party platforms
* @param _count The total number of tokens that can be minted for a template data identifier
* @param _dataId Template data identifier used during minting
*/
function setMaxSupplyForDataId(uint256 _count, string memory _dataId) public onlyOwner {
}
/**
* @dev Max supply for specified template data identifier
* @param _dataId Template data identifier used during minting
*/
function maxSupplyOfDataId(string memory _dataId) public view returns (uint256) {
}
/**
* @dev Set mint price for specific data identifier
* @param _price Integer in wei
* @param _dataId Template data identifier used during minting
*/
function setMintPriceForDataId(uint256 _price, string memory _dataId) public onlyOwner {
}
/**
* @dev Mint price in wei for specified template data identifier
* @param _dataId Template data identifier used during minting
*/
function mintPriceOfDataId(string memory _dataId) public view returns (uint256) {
}
/**
* @dev Sets the value needed to mint tokens
* @param _price The cost to mint a token
*/
function setMintPrice(uint256 _price) public onlyOwner {
}
/**
* @dev Updates the base uri
* @param baseURI_ The uri that is prefixed for all token ids
*/
function setBaseURI(string memory baseURI_) external onlyOwner {
}
/**
* @dev Gets the base uri for metadata storage
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Gets the base uri for metadata storage
*/
function baseTokenURI() public view returns (string memory) {
}
/**
* @dev Gets the token uri and appends .json
* @param _tokenId Unique token identifier
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Sets the custom contract metadata
* @param contractURI_ File path under base URI without the .json file extension
*/
function setContractURI(string memory contractURI_) external onlyOwner {
}
/**
* @dev Gets the contract uri and appends .json
*/
function contractURI() public view virtual returns (string memory) {
}
/**
* @dev Gets total number of existing groups
*/
function totalGroups() public view returns (uint256) {
}
/**
* @dev Gets total number of existing tokens
*/
function totalTokens() public view returns (uint256) {
}
/**
* @dev Total tokens minted for a template data identifier
* @param _dataId Template data identifier used during minting
*/
function totalTokensOfData(string memory _dataId) public view returns (uint256) {
}
/**
* @dev Max supply for third party platforms
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev Sets new token in mapping for new group
*/
function setTokensForGroup() private {
}
/**
* @dev Sets new token in mapping for an existing group
* @param _groupId Unique group identifier
*/
function setTokensForGroupId(uint256 _groupId) private {
}
/**
* @dev Sets the file signature for a new token
* @param _signature Off chain web3 wallet signature approving the attached files checksums
*/
function setFilesSignatureForToken(bytes calldata _signature) private {
}
/**
* @dev Sets a new derivative token in mapping for an existing group
* @param _groupId Unique group identifier
*/
function setDerivativeTokensForGroup(uint256 _groupId) private {
}
/**
* @dev Mints a new token into a new group. Can only be called by approved onboarded user
* @param _shares Number of shares to allocate to the initial token holder
* @param _signingName The token or asset name
* @param _signingMetadataHash The Sha3 hash of the metadata object
* @param _signingDataId The reference id that is used for metadata reference and physical asset verification
* @param _signature Off chain web3 wallet signature approving the attached files checksums
*/
function mintWithNewGroup(uint256 _shares, string memory _signingName, string memory _signingMetadataHash, string memory _signingDataId, bytes calldata _signature) public payable nonReentrant verifyFileSignature(_signature, msg.sender, _signingName, _signingMetadataHash, _signingDataId) {
require(saleIsActive, "Sale not active");
require(msg.value >= mintPriceForDataId[_signingDataId], "Insufficient payment");
require(totalTokens() < MAX_SUPPLY, "Exceeds max supply");
require(<FILL_ME>)
groupsForOwner[msg.sender].push(totalGroups());
ownersForGroup[totalGroups()][msg.sender] = _shares;
managerForGroup[totalGroups()] = msg.sender;
setTokensForGroup();
setFilesSignatureForToken(_signature);
_safeMint(msg.sender, totalTokens());
payable(paymentSplitter).transfer(msg.value);
emit HasMinted(totalTokens(), _signature, _signingDataId);
tokenCounterForDataId[_signingDataId] += 1;
groupCounter.increment();
tokenCounter.increment();
}
/**
* @dev Mints a new token or new derivative token into an existing group. Can only be called by the group manager.
* @param _groupId Unique group identifier
* @param _isDerivative Is new token a derivative token
* @param _signingName The token or asset name
* @param _signingMetadataHash The Sha3 hash of the metadata object
* @param _signingDataId The reference id that is used for metadata reference and physical asset verification
* @param _signature Off chain web3 wallet signature approving the attached files checksums
*/
function mintWithGroupId(uint256 _groupId, bool _isDerivative, string memory _signingName, string memory _signingMetadataHash, string memory _signingDataId, bytes calldata _signature) public payable nonReentrant verifyFileSignature(_signature, msg.sender, _signingName, _signingMetadataHash, _signingDataId) {
}
/**
* @dev Adds a new owner to a group with specified shares
* @param _owner Wallet address for owner
* @param _shares Shares to give the new owner
* @param _groupId Unique group identifier
*/
function setGroupOwner(address _owner, uint256 _shares, uint256 _groupId) public onlyGroupManager(_groupId) {
}
/**
* @dev Removes an owner from a group
* @param _owner Wallet address for owner
* @param _groupId Unique group identifier
*/
function removeGroupOwner(address _owner, uint256 _groupId) public onlyGroupManager(_groupId) {
}
/**
* @dev Sets new manager for a group
* @param _owner Wallet address for owner
* @param _groupId Unique group identifier
*/
function setGroupManager(address _owner, uint256 _groupId) public onlyGroupManager(_groupId) {
}
/**
* @dev Gets shares owned by wallet
* @param _owner Wallet address for owner
* @param _groupId Unique group identifier
*/
function groupSharesOfOwner(address _owner, uint256 _groupId) public view returns (uint256) {
}
/**
* @dev Checks that wallet owns group
* @param _owner Wallet address for owner
*/
function groupsOfOwner(address _owner) public view returns (uint256[] memory) {
}
/**
* @dev Gets total number of existing tokens
* @param _groupId Unique group identifier
*/
function tokensOfGroup(uint256 _groupId) public view returns (uint256[] memory) {
}
/**
* @dev Gets the manager for a group
* @param _groupId Unique group identifier
*/
function managerOfGroup(uint256 _groupId) public view returns (address) {
}
/**
* @dev Gets the wallet signature for a token's attached files
* @param _tokenId Unique token identifier
*/
function filesSignatureOfToken(uint256 _tokenId) public view returns (bytes memory) {
}
/**
* @dev Gets the wallet signature for a token's attached files
* @param _signingName The token or asset name
* @param _signingMetadataHash The Sha3 hash of the metadata object
* @param _signingDataId The reference id that is used for metadata reference and physical asset verification
* @param _signature Unique token identifier
*/
function verifyTokenFileSigner(string memory _signingName, string memory _signingMetadataHash, string memory _signingDataId, bytes calldata _signature) public view verifyFileSignature(_signature, msg.sender, _signingName, _signingMetadataHash, _signingDataId) returns (bool) {
}
/**
* @dev Gets derivative tokens that belong to a group
* @param _groupId Unique group identifier
*/
function derivativeTokensOfGroup(uint256 _groupId) public view returns(uint256[] memory) {
}
/**
* @dev Sends distribution to a shareholder wallet
* @param account The wallet to payout their owned shares
*/
function release(address payable account) public virtual onlyOwner {
}
}
| tokenCounterForDataId[_signingDataId]<maxSupplyForDataId[_signingDataId],"Exceeds data id max supply" | 107,271 | tokenCounterForDataId[_signingDataId]<maxSupplyForDataId[_signingDataId] |
"over" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "./ERC1155Token.sol";
contract NormalERC1155 is ERC1155Token, ERC2981 {
uint256 public maxId;
string public name;
string public symbol;
string public suffix;
mapping(address => mapping(uint256 => uint256)) public mintCount;
struct MintLimitInfo {
uint128 price;
uint64 amount;
uint64 maxAmount;
uint256 totalSupply;
}
struct MintLimit {
address operator;
uint128 price;
uint64 amount;
uint64 maxAmount;
}
MintLimit private _defaultMintLimit;
mapping(uint256 => MintLimit) public mintLimitList;
constructor(uint256 maxId_, string memory name_, string memory symbol_, string memory uri_) ERC1155Token(uri_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155, ERC2981) returns (bool) {
}
function uri(uint256 id_) public view virtual override returns (string memory)
{
}
function _mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal override {
}
function mintAll(uint256 id) external payable {
}
function mint(
uint256 id,
uint256 amount
) public payable {
MintLimitInfo memory limit = getMintLimit(id);
require(limit.amount >= amount + mintCount[_msgSender()][id], "over limit");
require(<FILL_ME>)
require(msg.value >= limit.price * amount, 'insufficient');
_mint(_msgSender(), id, amount, "");
}
function setMaxId(uint256 id) external onlyOwner {
}
function setURI2(string calldata _uri, string calldata _suffix) external onlyOwner {
}
function getMintLimit(uint256 id) public view returns (MintLimitInfo memory) {
}
function setDefaultMintLimit(uint128 price, uint64 amount, uint64 maxAmount) external onlyOwner {
}
function deleteDefaultMintLimit() external onlyOwner {
}
function setMintLimit(uint256 id, uint128 price, uint64 amount, uint64 maxAmount) external onlyOwner {
}
function resetMintLimit(uint256 id) external onlyOwner {
}
/**
* @dev Sets the royalty information that all ids in this contract will default to.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setDefaultRoyalty(address receiver, uint96 feeNumerator) external onlyOwner {
}
/**
* @dev Removes default royalty information.
*/
function deleteDefaultRoyalty() external onlyOwner {
}
/**
* @dev Sets the royalty information for a specific token id, overriding the global default.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setTokenRoyalty(
uint256 tokenId,
address receiver,
uint96 feeNumerator
) external onlyOwner {
}
/**
* @dev Resets royalty information for the token id back to the global default.
*/
function resetTokenRoyalty(uint256 tokenId) external onlyOwner {
}
}
| amount+limit.totalSupply<=limit.maxAmount,"over" | 107,295 | amount+limit.totalSupply<=limit.maxAmount |
"Roundtrip too high" | /*
Happy HARAMADAN!
Celebrating HARAMADAN because everyone should free their mind from obsolete medieval beliefs and worthless rules and practices.
This is the one month when you should do everything that some would forbid you from enjoying.
Have a drink.
Eat some pork.
Gamble on crypto or anything else.
Fuck around.
Jerk off.
Do whatever makes you happy LIKE NOBODY IS WATCHING.
Because nobody is.
Tax 1/1 to make everyone happy.
LP locked until April 21. Community can vote to relock or burn LP after.
And finally enjoy a drawing of Prophet Mohammed (PBUH) giving you his blessing to live your life free of all the mythical nonsense.
::------==------+*----:..:--------:.
.:--===----:. :=: .-+---:
.::--::. :+: -=. ::-:
:-=-: =- :=. :=.
:==: :----=-+*. :=: --
:+- .---=--:. =- :=: :=
== :-=+--. -*: =- +.
+- :-=+--. .+= .+. -+
-* .-=+--. -#=------::. -= :+*
+= :=*=. :-+*+=+--:::...:::-++=:. +: =-:+
++-+=-. .-=+=-. .--=#*-: .+: ==
*%. :=+=. -=+=- :=. *
# =*=. :+= .=: -+
# -##*::.:..-. :#: .=- *
*- =*:@@@@%%@%+@*#::--.- :: -. -.*=+=::=-*:.-%= :% .=- *:
# =* .-:--:%%*@%@@%%%##%.##*+#:*+%@@@@#%@@%@@#%+ *@-+-. +=
+= :% - .::.-:.:-.-: -= ===+=-=*===:.. #@# :*
.# #= .#@@= = :=++. #%# .#.
#: *@%: +@@@- : ++. +@@@% .+%%% #:
.# -%=*@+ =+. +- :=+- :+=. *@-%@ :#:
+= .%. =%- :*: %: #* :#- :#.
#.%##* .%# .=+- +@*=: -#. .*# .=+.
+=%++**+%# .=+=-. .@ .==- %% **%+*.
#= +=+*# -% .@=+:%+@-
** =%- +# %% +#-=#
*=--%@+ #* =#%*= :%.
::%@== +*==*+ %: =-##%@+ % =%.
:%%@-:: ** : :% .. %#@@% =%@ *+#=
.%@*+*%=*= %-:**++ .*+***: .=*%+%%-:%.=@@
*@ #%-#%*.:-.:: ==#:@%-+#. *%*-#@@.
.@% #**-*%+=@*#=+=: + :%*#%%%#=--#= -#= % %@@=
.@- %%-**- :=#*.@@*@* +@%==---#+%:=#. .%.%@%*
+@= %+#.=#+*+=- .=. ..-=**= -@% #=-@@@*
#@*.**=@%. .@==+**+****===** -+*:=#-*= =@@%#
*@%%:%%:-+*=%= % :*%*+=. =*: =#*@++
+@@@+*%. ##*+===--%=+**==-%. .=#- :@@+#
+%#%#:#=.+* .:---%: =%.=*+:-%=%%@@@@
%@##%. :=#==-:. % :=+%#:=-+*%*@*@%@%
=#@*%#=%=-:=-+==+**#***+==-- : @@@%##@@@@#*
.%%*%#%*%*@%%@#+- = .*@#+#@#%%#%@%%#-
+#*%%@@%@+@%@%@#%#%:=%+++#@%% #%*%#@%%+%
%=@@@@#+@%#%@#%@##*@%=@@@%@ #%+%%@@=*-
:.*+*-*-@#*@@@@@%@@@*#@@%@#=*#*+*#%+*
**. +*+.#@**@@@%@@+@%%%@*** =- *%+=-
.#+*-#+*+%:@-%%%*@*#*+=# * *%:*+
: +%+=* *:#+%-%-%=#-# # :+*#-
=+* **.=+ %:#=# * :.
.+. +* +:+ -+*
-*- +*
*/
//SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address __owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() external pure returns (address);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
abstract contract Auth {
address internal _owner;
constructor(address creatorOwner) {
}
modifier onlyOwner() {
}
function owner() public view returns (address) {
}
function transferOwnership(address payable newOwner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
event OwnershipTransferred(address _owner);
}
contract HARAMADAN is IERC20, Auth {
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1_000_000_000 * (10**_decimals);
string private constant _name = "Haramadan";
string private constant _symbol = "HARAM";
uint8 private antiSnipeTax1 = 15;
uint8 private antiSnipeTax2 = 10;
uint8 private antiSnipeBlocks1 = 3;
uint8 private antiSnipeBlocks2 = 3;
uint8 private _buyTaxRate = 1;
uint8 private _sellTaxRate = 1;
uint16 private _taxSharesMarketing = 2;
uint16 private _taxSharesDevelopment = 1;
uint16 private _taxSharesLP = 0;
uint16 private _totalTaxShares = _taxSharesMarketing + _taxSharesDevelopment + _taxSharesLP;
address payable private _walletMarketing = payable(0x4C0D3EB44ce6f4cADd638Ba56Bc045eea00179E3);
address payable private _walletDevelopment = payable(0x07789C28Ee91BC7C3BE77919772FC653d59342b4);
uint256 private _launchBlock;
uint256 private _maxTxAmount = _totalSupply;
uint256 private _maxWalletAmount = _totalSupply;
uint256 private _taxSwapMin = _totalSupply * 10 / 100000;
uint256 private _taxSwapMax = _totalSupply * 150 / 100000;
uint256 private _swapLimit = _taxSwapMin * 40 * 100;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _noFees;
mapping (address => bool) private _noLimits;
address private _lpOwner;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IUniswapV2Router02 private _primarySwapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping (address => bool) private _isLP;
bool private _tradingOpen;
bool private _inTaxSwap = false;
modifier lockTaxSwap {
}
event TokensAirdropped(uint256 totalWallets, uint256 totalTokens);
event TokensBurned(address indexed burnedByWallet, uint256 tokenAmount);
constructor() Auth(msg.sender) {
}
receive() external payable {}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function addLiquidity() external payable onlyOwner lockTaxSwap {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei, bool autoburn) internal {
}
function _openTrading() internal {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _checkLimits(address sender, address recipient, uint256 transferAmount) internal view returns (bool) {
}
function _checkTradingOpen(address sender) private view returns (bool){
}
function _calculateTax(address sender, address recipient, uint256 amount) internal view returns (uint256) {
}
function exemptFromFees(address wallet) external view returns (bool) {
}
function exemptFromLimits(address wallet) external view returns (bool) {
}
function setExempt(address wallet, bool noFees, bool noLimits) external onlyOwner {
}
function buyFee() external view returns(uint8) {
}
function sellFee() external view returns(uint8) {
}
function feeSplit() external view returns (uint16 marketing, uint16 development, uint16 LP ) {
}
function setFees(uint8 buy, uint8 sell) external onlyOwner {
require(<FILL_ME>)
_buyTaxRate = buy;
_sellTaxRate = sell;
}
function setFeeSplit(uint16 sharesAutoLP, uint16 sharesMarketing, uint16 sharesDevelopment) external onlyOwner {
}
function marketingWallet() external view returns (address) {
}
function developmentWallet() external view returns (address) {
}
function updateWallets(address marketing, address development, address LPtokens) external onlyOwner {
}
function maxWallet() external view returns (uint256) {
}
function maxTransaction() external view returns (uint256) {
}
function swapAtMin() external view returns (uint256) {
}
function swapAtMax() external view returns (uint256) {
}
function setLimits(uint16 maxTransactionPermille, uint16 maxWalletPermille) external onlyOwner {
}
function setTaxSwap(uint32 minValue, uint32 minDivider, uint32 maxValue, uint32 maxDivider) external onlyOwner {
}
function _burnTokens(address fromWallet, uint256 amount) private {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 tokenAmount) private {
}
function _distributeTaxEth(uint256 amount) private {
}
function manualTaxSwapAndSend(uint8 swapTokenPercent, bool sendEth) external onlyOwner lockTaxSwap {
}
function airdrop(address[] calldata addresses, uint256[] calldata tokenAmounts) external onlyOwner {
}
function burn(uint256 amount) external {
}
}
| buy+sell<=99,"Roundtrip too high" | 107,315 | buy+sell<=99 |
"Invalid token" | pragma solidity 0.6.12;
contract MEGAsale is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public MEGA;
// Payment tokens
IERC20 public USDT;
IERC20 public USDC;
IERC20 public DAI;
address payable public paymentReceiver; // Payment receiver
uint256 public quantity = 40e18; // 40 MEGA for 1 USDT/USDC/DAI
uint256 public totalSellToken;
uint256 public referralFee = 5; // ReferralFee %
uint256 public buyerFee = 5; // BuyerFee %
bool public pause;
mapping(address => mapping(address => uint256)) public depositAmount;
event BUY(address user, address token, uint256 amount, address referral);
modifier ifNotPaused(){
}
constructor(address payable _paymentReceiver, IERC20 _mega, IERC20 _USDT, IERC20 _USDC, IERC20 _dai) public {
}
function buy(uint256 _amount, address _token, address _referral)
ifNotPaused
public
returns (uint256)
{
require(<FILL_ME>)
require(_referral != msg.sender, "Referral and Buyer are identical address");
require(isContract(_referral) == false, "Invalid address");
// Check decimals
uint256 tokenstobePaid = calculateReturns(_amount, _token);
if(_referral != address(0x00) && (buyerFee > 0)){
tokenstobePaid = tokenstobePaid + (tokenstobePaid*buyerFee/100);
}
require(tokenstobePaid > 0 && tokenstobePaid <= MEGA.balanceOf(address(this)), "Insufficient amount");
address user = msg.sender;
depositAmount[user][_token] = depositAmount[user][_token].add(_amount);
if(_referral != address(0x00) && (referralFee > 0)){
uint256 refFee = _amount*referralFee/100;
_amount = _amount - refFee;
IERC20(_token).safeTransferFrom(user, paymentReceiver, _amount);
IERC20(_token).safeTransferFrom(user, _referral, refFee);
}else {
IERC20(_token).safeTransferFrom(user, paymentReceiver, _amount);
}
MEGA.transfer(user, tokenstobePaid);
totalSellToken = totalSellToken.add(tokenstobePaid);
emit BUY( user, _token, _amount, _referral);
return tokenstobePaid;
}
function calculateReturns(uint256 _value, address _token) public ifNotPaused view returns(uint){
}
function isContract(address addr) public view returns (bool) {
}
function withdrawUnsoldTokens() external onlyOwner {
}
function withdrawstuckTokens(address _token) external onlyOwner {
}
function pauseContract() external onlyOwner {
}
function unPauseContract() external onlyOwner {
}
function referralFeesPcent(uint _referralFee, uint _buyerFee) external onlyOwner {
}
}
| IERC20(_token)==USDT||IERC20(_token)==USDC||IERC20(_token)==DAI,"Invalid token" | 107,337 | IERC20(_token)==USDT||IERC20(_token)==USDC||IERC20(_token)==DAI |
"Invalid address" | pragma solidity 0.6.12;
contract MEGAsale is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public MEGA;
// Payment tokens
IERC20 public USDT;
IERC20 public USDC;
IERC20 public DAI;
address payable public paymentReceiver; // Payment receiver
uint256 public quantity = 40e18; // 40 MEGA for 1 USDT/USDC/DAI
uint256 public totalSellToken;
uint256 public referralFee = 5; // ReferralFee %
uint256 public buyerFee = 5; // BuyerFee %
bool public pause;
mapping(address => mapping(address => uint256)) public depositAmount;
event BUY(address user, address token, uint256 amount, address referral);
modifier ifNotPaused(){
}
constructor(address payable _paymentReceiver, IERC20 _mega, IERC20 _USDT, IERC20 _USDC, IERC20 _dai) public {
}
function buy(uint256 _amount, address _token, address _referral)
ifNotPaused
public
returns (uint256)
{
require(
IERC20(_token) == USDT || IERC20(_token) == USDC || IERC20(_token) == DAI,
"Invalid token"
);
require(_referral != msg.sender, "Referral and Buyer are identical address");
require(<FILL_ME>)
// Check decimals
uint256 tokenstobePaid = calculateReturns(_amount, _token);
if(_referral != address(0x00) && (buyerFee > 0)){
tokenstobePaid = tokenstobePaid + (tokenstobePaid*buyerFee/100);
}
require(tokenstobePaid > 0 && tokenstobePaid <= MEGA.balanceOf(address(this)), "Insufficient amount");
address user = msg.sender;
depositAmount[user][_token] = depositAmount[user][_token].add(_amount);
if(_referral != address(0x00) && (referralFee > 0)){
uint256 refFee = _amount*referralFee/100;
_amount = _amount - refFee;
IERC20(_token).safeTransferFrom(user, paymentReceiver, _amount);
IERC20(_token).safeTransferFrom(user, _referral, refFee);
}else {
IERC20(_token).safeTransferFrom(user, paymentReceiver, _amount);
}
MEGA.transfer(user, tokenstobePaid);
totalSellToken = totalSellToken.add(tokenstobePaid);
emit BUY( user, _token, _amount, _referral);
return tokenstobePaid;
}
function calculateReturns(uint256 _value, address _token) public ifNotPaused view returns(uint){
}
function isContract(address addr) public view returns (bool) {
}
function withdrawUnsoldTokens() external onlyOwner {
}
function withdrawstuckTokens(address _token) external onlyOwner {
}
function pauseContract() external onlyOwner {
}
function unPauseContract() external onlyOwner {
}
function referralFeesPcent(uint _referralFee, uint _buyerFee) external onlyOwner {
}
}
| isContract(_referral)==false,"Invalid address" | 107,337 | isContract(_referral)==false |
"Less than min payment" | pragma solidity 0.6.12;
contract MEGAsale is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public MEGA;
// Payment tokens
IERC20 public USDT;
IERC20 public USDC;
IERC20 public DAI;
address payable public paymentReceiver; // Payment receiver
uint256 public quantity = 40e18; // 40 MEGA for 1 USDT/USDC/DAI
uint256 public totalSellToken;
uint256 public referralFee = 5; // ReferralFee %
uint256 public buyerFee = 5; // BuyerFee %
bool public pause;
mapping(address => mapping(address => uint256)) public depositAmount;
event BUY(address user, address token, uint256 amount, address referral);
modifier ifNotPaused(){
}
constructor(address payable _paymentReceiver, IERC20 _mega, IERC20 _USDT, IERC20 _USDC, IERC20 _dai) public {
}
function buy(uint256 _amount, address _token, address _referral)
ifNotPaused
public
returns (uint256)
{
}
function calculateReturns(uint256 _value, address _token) public ifNotPaused view returns(uint){
require(<FILL_ME>)
uint256 payment = (_value.mul(quantity)).div((10 ** (uint256(IERC20(_token).decimals()))));
return payment;
}
function isContract(address addr) public view returns (bool) {
}
function withdrawUnsoldTokens() external onlyOwner {
}
function withdrawstuckTokens(address _token) external onlyOwner {
}
function pauseContract() external onlyOwner {
}
function unPauseContract() external onlyOwner {
}
function referralFeesPcent(uint _referralFee, uint _buyerFee) external onlyOwner {
}
}
| _value.div((uint256(IERC20(_token).decimals())))>0,"Less than min payment" | 107,337 | _value.div((uint256(IERC20(_token).decimals())))>0 |
"ChiefToads: Invalid Signature!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "./ERC721A.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/// @title ChiefToads Mint Contract
contract ChiefToads is ERC721A, VRFConsumerBaseV2, Ownable {
using Strings for uint256;
using ECDSA for bytes32;
// -- Chainlink
VRFCoordinatorV2Interface COORDINATOR;
uint64 s_subscriptionId;
// see https://docs.chain.link/docs/vrf-contracts/#configurations
address vrfCoordinator;
// see https://docs.chain.link/docs/vrf-contracts/#configurations
bytes32 keyHash;
uint32 callbackGasLimit = 100000;
uint16 requestConfirmations = 3;
uint32 numWords = 1;
uint256[] public s_randomWords;
uint256 public s_requestId;
address s_owner;
// Chainlink --
string public baseURI;
bool private _revealed;
string private _unrevealedBaseURI;
// Stages
// 0: Before all minting commence
// 1: Community List Sale
// 2: End of community list sale, before Whitelist Sale
// 3: Whitelist Sale
// 4: Rizard Sale
// 5: End of whitelist + rizard, before public sale
// 6: Public sale
// 7: End of minting
uint256 public stage;
// General Mint Settings
uint256 public constant totalMaxSupply = 10000;
// Community Mint Settings
uint256 public communityMintMaxSupply = 5000;
uint256 public communityMintMaxPerWallet = 2; // Private Sale Address Mint Cap
uint256 public communityMintPrice = 0.1 ether; // Private Sale Mint Price
mapping(address => uint256) public communityMintCount;
address private communitySignerAddress;
// Whitelist Mint Settings
uint256 public whitelistMintMaxPerWallet = 2; // Private Sale Address Mint Cap
uint256 public whitelistMintPrice = 0.08 ether; // Private Sale Mint Price
mapping(address => uint256) public whitelistMintCount;
address private whitelistSignerAddress;
// Chief Rizard Mint Settings
uint256 public rizardMintMaxPerWallet = 10;
uint256 public rizardMintPrice = 0.08 ether;
mapping(address => uint256) public rizardMintCount;
address private rizardSignerAddress;
// Public Sale Mint Settings
uint256 public publicMintPrice = 0.1 ether;
uint256 public publicMintMaxPerWallet = 2;
mapping(address => uint256) public publicMintCount;
// Dev Mint Settings
// This counter will help to offset the minting of the dev tokens such that their count will not be counted towards the communityMintMaxSupply
uint256 public devMintCount;
// Treasury
address public treasury;
// Events
event PrivateMint(address indexed to, uint256 amount);
event PublicMint(address indexed to, uint256 amount);
event DevMint(uint256 count);
event WithdrawETH(uint256 amountWithdrawn);
event Revealed(uint256 timestamp);
event PrivateSaleOpened(bool status, uint256 timestamp);
event PublicSaleOpened(bool status, uint256 timestamp);
// Modifiers
/**
* @dev Prevent Smart Contracts from calling the functions with this modifier
*/
modifier onlyEOA() {
}
constructor(
uint64 subscriptionId,
address _vrfCoordinator,
bytes32 _keyHash,
address _owner,
address _communitySignerAddress,
address _whitelistSignerAddress,
address _rizardSignerAddress,
string memory _unrevealed
) ERC721A("ChiefToad", "CT") VRFConsumerBaseV2(_vrfCoordinator) {
}
// -- Chainlink
function shuffle() external onlyOwner {
}
function fulfillRandomWords(
uint256, /* requestId */
uint256[] memory randomWords
) internal override {
}
/**
* @dev Basically get the first Word of the random value.
*/
function getRandom() public view returns (uint256) {
}
// Chainlink --
// -------------------- MINT FUNCTIONS --------------------------
/**
* @notice Community List Mint
* @dev 5th July 21:00 to 6th July 03:00
* 1. 5000 QTY (FCFS)
* 2. Price = 0.1 ETH
* 3. Max Mint per wallet = 2
* @param _mintAmount Amount that is minted
*/
function communityMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
// Check if communityMint is open
require(stage == 1, "ChiefToads: Community Mint is not open");
// Check if user is whitelisted
require(<FILL_ME>)
// Check if enough ETH is sent
require(
msg.value == _mintAmount * communityMintPrice,
"ChiefToads: Insufficient ETH!"
);
// Check if mints does not exceed communityMintMaxSupply
require(
totalSupply() + _mintAmount <=
communityMintMaxSupply + devMintCount,
"ChiefToads: Max Supply for Community Mint Reached!"
);
// Check if mints does not exceed max wallet allowance for public sale
require(
communityMintCount[msg.sender] + _mintAmount <=
communityMintMaxPerWallet,
"ChiefToads: Wallet has already minted Max Amount for Community Mint!"
);
communityMintCount[msg.sender] += _mintAmount;
_safeMint(msg.sender, _mintAmount);
emit PrivateMint(msg.sender, _mintAmount);
}
/**
* @notice Whitelist Mint
* @dev 6th July 21:00 to 7th July 09:00
* 1. 888 WL ~ 1776 QTY
* 2. Price = 0.08 ETH
* 3. Max Mint per wallet = 2
* @param _mintAmount Amount that is minted
*/
function whitelistMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Chief Rizard Mint
* @dev 6th July 23:00 to 7th 09:00
* 1. 2336 QTY
* 2. Price = 0.08 ETH
* 3. Max Mint per wallet = 10
* @param _mintAmount Amount that is minted
*/
function rizardMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Public Mint
* @param _mintAmount Amount that is minted
*/
function publicMint(uint256 _mintAmount) external payable onlyEOA {
}
/**
* @notice Dev Mint
* @param _mintAmount Amount that is minted
*/
function devMint(uint256 _mintAmount) external onlyOwner {
}
/**
* @notice Airdrop
* @param _addresses List of addresses
*/
function airdrop(address[] memory _addresses) external onlyOwner {
}
// -------------------- WHITELIST FUNCTION ----------------------
/**
* @dev Checks if the the signature is signed by a valid signer for whitelist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function whitelistSigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
/**
* @dev Checks if the the signature is signed by a valid signer for communitylist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function communitySigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
/**
* @dev Checks if the the signature is signed by a valid signer for rizardlist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function rizardSigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
// ---------------------- VIEW FUNCTIONS ------------------------
/**
* @dev See {IERC721Metadata-tokenURI}.
* @dev gets baseURI from contract state variable
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// ------------------------- OWNER FUNCTIONS ----------------------------
/**
* @dev Set stage of minting
*/
function setStage(uint256 _newStage) public onlyOwner {
}
/**
* @dev Set signer address for community mint
*/
function setCommunitySignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set signer address for whitelist mint
*/
function setWhitelistSignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set signer address for Rizard Mint
*/
function setRizardSignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set Community Sale maximum amount of mints
*/
function setCommunityMaxSupply(uint256 amount) public onlyOwner {
}
function setCommunityMaxMintPerWallet(uint256 amount) public onlyOwner {
}
function setWhitelistMaxMintPerWallet(uint256 amount) public onlyOwner {
}
function setRizardMaxMintPerWallet(uint256 amount) public onlyOwner {
}
/**
* @dev Set the unrevealed URI
* @param newUnrevealedURI unrevealed URI for metadata
*/
function setNotRevealedURI(string memory newUnrevealedURI)
public
onlyOwner
{
}
/**
* @dev Set Revealed Metadata URI
*/
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
/**
* @notice Set Revealed state of NFT metadata
*/
function reveal(bool revealed) public onlyOwner {
}
/**
* @notice Withdraw all ETH from this account to the owner
*/
function withdrawFund() external onlyOwner {
}
/**
* @notice Sets the treasury address
*/
function setTreasury(address _treasury) public onlyOwner {
}
function setUnrevealedBasedURI(string memory __unrevealedBaseURI)
public
onlyOwner
{
}
}
| communitySigned(msg.sender,nonce,signature),"ChiefToads: Invalid Signature!" | 107,385 | communitySigned(msg.sender,nonce,signature) |
"ChiefToads: Max Supply for Community Mint Reached!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "./ERC721A.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/// @title ChiefToads Mint Contract
contract ChiefToads is ERC721A, VRFConsumerBaseV2, Ownable {
using Strings for uint256;
using ECDSA for bytes32;
// -- Chainlink
VRFCoordinatorV2Interface COORDINATOR;
uint64 s_subscriptionId;
// see https://docs.chain.link/docs/vrf-contracts/#configurations
address vrfCoordinator;
// see https://docs.chain.link/docs/vrf-contracts/#configurations
bytes32 keyHash;
uint32 callbackGasLimit = 100000;
uint16 requestConfirmations = 3;
uint32 numWords = 1;
uint256[] public s_randomWords;
uint256 public s_requestId;
address s_owner;
// Chainlink --
string public baseURI;
bool private _revealed;
string private _unrevealedBaseURI;
// Stages
// 0: Before all minting commence
// 1: Community List Sale
// 2: End of community list sale, before Whitelist Sale
// 3: Whitelist Sale
// 4: Rizard Sale
// 5: End of whitelist + rizard, before public sale
// 6: Public sale
// 7: End of minting
uint256 public stage;
// General Mint Settings
uint256 public constant totalMaxSupply = 10000;
// Community Mint Settings
uint256 public communityMintMaxSupply = 5000;
uint256 public communityMintMaxPerWallet = 2; // Private Sale Address Mint Cap
uint256 public communityMintPrice = 0.1 ether; // Private Sale Mint Price
mapping(address => uint256) public communityMintCount;
address private communitySignerAddress;
// Whitelist Mint Settings
uint256 public whitelistMintMaxPerWallet = 2; // Private Sale Address Mint Cap
uint256 public whitelistMintPrice = 0.08 ether; // Private Sale Mint Price
mapping(address => uint256) public whitelistMintCount;
address private whitelistSignerAddress;
// Chief Rizard Mint Settings
uint256 public rizardMintMaxPerWallet = 10;
uint256 public rizardMintPrice = 0.08 ether;
mapping(address => uint256) public rizardMintCount;
address private rizardSignerAddress;
// Public Sale Mint Settings
uint256 public publicMintPrice = 0.1 ether;
uint256 public publicMintMaxPerWallet = 2;
mapping(address => uint256) public publicMintCount;
// Dev Mint Settings
// This counter will help to offset the minting of the dev tokens such that their count will not be counted towards the communityMintMaxSupply
uint256 public devMintCount;
// Treasury
address public treasury;
// Events
event PrivateMint(address indexed to, uint256 amount);
event PublicMint(address indexed to, uint256 amount);
event DevMint(uint256 count);
event WithdrawETH(uint256 amountWithdrawn);
event Revealed(uint256 timestamp);
event PrivateSaleOpened(bool status, uint256 timestamp);
event PublicSaleOpened(bool status, uint256 timestamp);
// Modifiers
/**
* @dev Prevent Smart Contracts from calling the functions with this modifier
*/
modifier onlyEOA() {
}
constructor(
uint64 subscriptionId,
address _vrfCoordinator,
bytes32 _keyHash,
address _owner,
address _communitySignerAddress,
address _whitelistSignerAddress,
address _rizardSignerAddress,
string memory _unrevealed
) ERC721A("ChiefToad", "CT") VRFConsumerBaseV2(_vrfCoordinator) {
}
// -- Chainlink
function shuffle() external onlyOwner {
}
function fulfillRandomWords(
uint256, /* requestId */
uint256[] memory randomWords
) internal override {
}
/**
* @dev Basically get the first Word of the random value.
*/
function getRandom() public view returns (uint256) {
}
// Chainlink --
// -------------------- MINT FUNCTIONS --------------------------
/**
* @notice Community List Mint
* @dev 5th July 21:00 to 6th July 03:00
* 1. 5000 QTY (FCFS)
* 2. Price = 0.1 ETH
* 3. Max Mint per wallet = 2
* @param _mintAmount Amount that is minted
*/
function communityMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
// Check if communityMint is open
require(stage == 1, "ChiefToads: Community Mint is not open");
// Check if user is whitelisted
require(
communitySigned(msg.sender, nonce, signature),
"ChiefToads: Invalid Signature!"
);
// Check if enough ETH is sent
require(
msg.value == _mintAmount * communityMintPrice,
"ChiefToads: Insufficient ETH!"
);
// Check if mints does not exceed communityMintMaxSupply
require(<FILL_ME>)
// Check if mints does not exceed max wallet allowance for public sale
require(
communityMintCount[msg.sender] + _mintAmount <=
communityMintMaxPerWallet,
"ChiefToads: Wallet has already minted Max Amount for Community Mint!"
);
communityMintCount[msg.sender] += _mintAmount;
_safeMint(msg.sender, _mintAmount);
emit PrivateMint(msg.sender, _mintAmount);
}
/**
* @notice Whitelist Mint
* @dev 6th July 21:00 to 7th July 09:00
* 1. 888 WL ~ 1776 QTY
* 2. Price = 0.08 ETH
* 3. Max Mint per wallet = 2
* @param _mintAmount Amount that is minted
*/
function whitelistMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Chief Rizard Mint
* @dev 6th July 23:00 to 7th 09:00
* 1. 2336 QTY
* 2. Price = 0.08 ETH
* 3. Max Mint per wallet = 10
* @param _mintAmount Amount that is minted
*/
function rizardMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Public Mint
* @param _mintAmount Amount that is minted
*/
function publicMint(uint256 _mintAmount) external payable onlyEOA {
}
/**
* @notice Dev Mint
* @param _mintAmount Amount that is minted
*/
function devMint(uint256 _mintAmount) external onlyOwner {
}
/**
* @notice Airdrop
* @param _addresses List of addresses
*/
function airdrop(address[] memory _addresses) external onlyOwner {
}
// -------------------- WHITELIST FUNCTION ----------------------
/**
* @dev Checks if the the signature is signed by a valid signer for whitelist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function whitelistSigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
/**
* @dev Checks if the the signature is signed by a valid signer for communitylist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function communitySigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
/**
* @dev Checks if the the signature is signed by a valid signer for rizardlist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function rizardSigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
// ---------------------- VIEW FUNCTIONS ------------------------
/**
* @dev See {IERC721Metadata-tokenURI}.
* @dev gets baseURI from contract state variable
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// ------------------------- OWNER FUNCTIONS ----------------------------
/**
* @dev Set stage of minting
*/
function setStage(uint256 _newStage) public onlyOwner {
}
/**
* @dev Set signer address for community mint
*/
function setCommunitySignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set signer address for whitelist mint
*/
function setWhitelistSignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set signer address for Rizard Mint
*/
function setRizardSignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set Community Sale maximum amount of mints
*/
function setCommunityMaxSupply(uint256 amount) public onlyOwner {
}
function setCommunityMaxMintPerWallet(uint256 amount) public onlyOwner {
}
function setWhitelistMaxMintPerWallet(uint256 amount) public onlyOwner {
}
function setRizardMaxMintPerWallet(uint256 amount) public onlyOwner {
}
/**
* @dev Set the unrevealed URI
* @param newUnrevealedURI unrevealed URI for metadata
*/
function setNotRevealedURI(string memory newUnrevealedURI)
public
onlyOwner
{
}
/**
* @dev Set Revealed Metadata URI
*/
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
/**
* @notice Set Revealed state of NFT metadata
*/
function reveal(bool revealed) public onlyOwner {
}
/**
* @notice Withdraw all ETH from this account to the owner
*/
function withdrawFund() external onlyOwner {
}
/**
* @notice Sets the treasury address
*/
function setTreasury(address _treasury) public onlyOwner {
}
function setUnrevealedBasedURI(string memory __unrevealedBaseURI)
public
onlyOwner
{
}
}
| totalSupply()+_mintAmount<=communityMintMaxSupply+devMintCount,"ChiefToads: Max Supply for Community Mint Reached!" | 107,385 | totalSupply()+_mintAmount<=communityMintMaxSupply+devMintCount |
"ChiefToads: Wallet has already minted Max Amount for Community Mint!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "./ERC721A.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/// @title ChiefToads Mint Contract
contract ChiefToads is ERC721A, VRFConsumerBaseV2, Ownable {
using Strings for uint256;
using ECDSA for bytes32;
// -- Chainlink
VRFCoordinatorV2Interface COORDINATOR;
uint64 s_subscriptionId;
// see https://docs.chain.link/docs/vrf-contracts/#configurations
address vrfCoordinator;
// see https://docs.chain.link/docs/vrf-contracts/#configurations
bytes32 keyHash;
uint32 callbackGasLimit = 100000;
uint16 requestConfirmations = 3;
uint32 numWords = 1;
uint256[] public s_randomWords;
uint256 public s_requestId;
address s_owner;
// Chainlink --
string public baseURI;
bool private _revealed;
string private _unrevealedBaseURI;
// Stages
// 0: Before all minting commence
// 1: Community List Sale
// 2: End of community list sale, before Whitelist Sale
// 3: Whitelist Sale
// 4: Rizard Sale
// 5: End of whitelist + rizard, before public sale
// 6: Public sale
// 7: End of minting
uint256 public stage;
// General Mint Settings
uint256 public constant totalMaxSupply = 10000;
// Community Mint Settings
uint256 public communityMintMaxSupply = 5000;
uint256 public communityMintMaxPerWallet = 2; // Private Sale Address Mint Cap
uint256 public communityMintPrice = 0.1 ether; // Private Sale Mint Price
mapping(address => uint256) public communityMintCount;
address private communitySignerAddress;
// Whitelist Mint Settings
uint256 public whitelistMintMaxPerWallet = 2; // Private Sale Address Mint Cap
uint256 public whitelistMintPrice = 0.08 ether; // Private Sale Mint Price
mapping(address => uint256) public whitelistMintCount;
address private whitelistSignerAddress;
// Chief Rizard Mint Settings
uint256 public rizardMintMaxPerWallet = 10;
uint256 public rizardMintPrice = 0.08 ether;
mapping(address => uint256) public rizardMintCount;
address private rizardSignerAddress;
// Public Sale Mint Settings
uint256 public publicMintPrice = 0.1 ether;
uint256 public publicMintMaxPerWallet = 2;
mapping(address => uint256) public publicMintCount;
// Dev Mint Settings
// This counter will help to offset the minting of the dev tokens such that their count will not be counted towards the communityMintMaxSupply
uint256 public devMintCount;
// Treasury
address public treasury;
// Events
event PrivateMint(address indexed to, uint256 amount);
event PublicMint(address indexed to, uint256 amount);
event DevMint(uint256 count);
event WithdrawETH(uint256 amountWithdrawn);
event Revealed(uint256 timestamp);
event PrivateSaleOpened(bool status, uint256 timestamp);
event PublicSaleOpened(bool status, uint256 timestamp);
// Modifiers
/**
* @dev Prevent Smart Contracts from calling the functions with this modifier
*/
modifier onlyEOA() {
}
constructor(
uint64 subscriptionId,
address _vrfCoordinator,
bytes32 _keyHash,
address _owner,
address _communitySignerAddress,
address _whitelistSignerAddress,
address _rizardSignerAddress,
string memory _unrevealed
) ERC721A("ChiefToad", "CT") VRFConsumerBaseV2(_vrfCoordinator) {
}
// -- Chainlink
function shuffle() external onlyOwner {
}
function fulfillRandomWords(
uint256, /* requestId */
uint256[] memory randomWords
) internal override {
}
/**
* @dev Basically get the first Word of the random value.
*/
function getRandom() public view returns (uint256) {
}
// Chainlink --
// -------------------- MINT FUNCTIONS --------------------------
/**
* @notice Community List Mint
* @dev 5th July 21:00 to 6th July 03:00
* 1. 5000 QTY (FCFS)
* 2. Price = 0.1 ETH
* 3. Max Mint per wallet = 2
* @param _mintAmount Amount that is minted
*/
function communityMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
// Check if communityMint is open
require(stage == 1, "ChiefToads: Community Mint is not open");
// Check if user is whitelisted
require(
communitySigned(msg.sender, nonce, signature),
"ChiefToads: Invalid Signature!"
);
// Check if enough ETH is sent
require(
msg.value == _mintAmount * communityMintPrice,
"ChiefToads: Insufficient ETH!"
);
// Check if mints does not exceed communityMintMaxSupply
require(
totalSupply() + _mintAmount <=
communityMintMaxSupply + devMintCount,
"ChiefToads: Max Supply for Community Mint Reached!"
);
// Check if mints does not exceed max wallet allowance for public sale
require(<FILL_ME>)
communityMintCount[msg.sender] += _mintAmount;
_safeMint(msg.sender, _mintAmount);
emit PrivateMint(msg.sender, _mintAmount);
}
/**
* @notice Whitelist Mint
* @dev 6th July 21:00 to 7th July 09:00
* 1. 888 WL ~ 1776 QTY
* 2. Price = 0.08 ETH
* 3. Max Mint per wallet = 2
* @param _mintAmount Amount that is minted
*/
function whitelistMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Chief Rizard Mint
* @dev 6th July 23:00 to 7th 09:00
* 1. 2336 QTY
* 2. Price = 0.08 ETH
* 3. Max Mint per wallet = 10
* @param _mintAmount Amount that is minted
*/
function rizardMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Public Mint
* @param _mintAmount Amount that is minted
*/
function publicMint(uint256 _mintAmount) external payable onlyEOA {
}
/**
* @notice Dev Mint
* @param _mintAmount Amount that is minted
*/
function devMint(uint256 _mintAmount) external onlyOwner {
}
/**
* @notice Airdrop
* @param _addresses List of addresses
*/
function airdrop(address[] memory _addresses) external onlyOwner {
}
// -------------------- WHITELIST FUNCTION ----------------------
/**
* @dev Checks if the the signature is signed by a valid signer for whitelist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function whitelistSigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
/**
* @dev Checks if the the signature is signed by a valid signer for communitylist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function communitySigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
/**
* @dev Checks if the the signature is signed by a valid signer for rizardlist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function rizardSigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
// ---------------------- VIEW FUNCTIONS ------------------------
/**
* @dev See {IERC721Metadata-tokenURI}.
* @dev gets baseURI from contract state variable
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// ------------------------- OWNER FUNCTIONS ----------------------------
/**
* @dev Set stage of minting
*/
function setStage(uint256 _newStage) public onlyOwner {
}
/**
* @dev Set signer address for community mint
*/
function setCommunitySignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set signer address for whitelist mint
*/
function setWhitelistSignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set signer address for Rizard Mint
*/
function setRizardSignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set Community Sale maximum amount of mints
*/
function setCommunityMaxSupply(uint256 amount) public onlyOwner {
}
function setCommunityMaxMintPerWallet(uint256 amount) public onlyOwner {
}
function setWhitelistMaxMintPerWallet(uint256 amount) public onlyOwner {
}
function setRizardMaxMintPerWallet(uint256 amount) public onlyOwner {
}
/**
* @dev Set the unrevealed URI
* @param newUnrevealedURI unrevealed URI for metadata
*/
function setNotRevealedURI(string memory newUnrevealedURI)
public
onlyOwner
{
}
/**
* @dev Set Revealed Metadata URI
*/
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
/**
* @notice Set Revealed state of NFT metadata
*/
function reveal(bool revealed) public onlyOwner {
}
/**
* @notice Withdraw all ETH from this account to the owner
*/
function withdrawFund() external onlyOwner {
}
/**
* @notice Sets the treasury address
*/
function setTreasury(address _treasury) public onlyOwner {
}
function setUnrevealedBasedURI(string memory __unrevealedBaseURI)
public
onlyOwner
{
}
}
| communityMintCount[msg.sender]+_mintAmount<=communityMintMaxPerWallet,"ChiefToads: Wallet has already minted Max Amount for Community Mint!" | 107,385 | communityMintCount[msg.sender]+_mintAmount<=communityMintMaxPerWallet |
"ChiefToads: Invalid Signature!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "./ERC721A.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/// @title ChiefToads Mint Contract
contract ChiefToads is ERC721A, VRFConsumerBaseV2, Ownable {
using Strings for uint256;
using ECDSA for bytes32;
// -- Chainlink
VRFCoordinatorV2Interface COORDINATOR;
uint64 s_subscriptionId;
// see https://docs.chain.link/docs/vrf-contracts/#configurations
address vrfCoordinator;
// see https://docs.chain.link/docs/vrf-contracts/#configurations
bytes32 keyHash;
uint32 callbackGasLimit = 100000;
uint16 requestConfirmations = 3;
uint32 numWords = 1;
uint256[] public s_randomWords;
uint256 public s_requestId;
address s_owner;
// Chainlink --
string public baseURI;
bool private _revealed;
string private _unrevealedBaseURI;
// Stages
// 0: Before all minting commence
// 1: Community List Sale
// 2: End of community list sale, before Whitelist Sale
// 3: Whitelist Sale
// 4: Rizard Sale
// 5: End of whitelist + rizard, before public sale
// 6: Public sale
// 7: End of minting
uint256 public stage;
// General Mint Settings
uint256 public constant totalMaxSupply = 10000;
// Community Mint Settings
uint256 public communityMintMaxSupply = 5000;
uint256 public communityMintMaxPerWallet = 2; // Private Sale Address Mint Cap
uint256 public communityMintPrice = 0.1 ether; // Private Sale Mint Price
mapping(address => uint256) public communityMintCount;
address private communitySignerAddress;
// Whitelist Mint Settings
uint256 public whitelistMintMaxPerWallet = 2; // Private Sale Address Mint Cap
uint256 public whitelistMintPrice = 0.08 ether; // Private Sale Mint Price
mapping(address => uint256) public whitelistMintCount;
address private whitelistSignerAddress;
// Chief Rizard Mint Settings
uint256 public rizardMintMaxPerWallet = 10;
uint256 public rizardMintPrice = 0.08 ether;
mapping(address => uint256) public rizardMintCount;
address private rizardSignerAddress;
// Public Sale Mint Settings
uint256 public publicMintPrice = 0.1 ether;
uint256 public publicMintMaxPerWallet = 2;
mapping(address => uint256) public publicMintCount;
// Dev Mint Settings
// This counter will help to offset the minting of the dev tokens such that their count will not be counted towards the communityMintMaxSupply
uint256 public devMintCount;
// Treasury
address public treasury;
// Events
event PrivateMint(address indexed to, uint256 amount);
event PublicMint(address indexed to, uint256 amount);
event DevMint(uint256 count);
event WithdrawETH(uint256 amountWithdrawn);
event Revealed(uint256 timestamp);
event PrivateSaleOpened(bool status, uint256 timestamp);
event PublicSaleOpened(bool status, uint256 timestamp);
// Modifiers
/**
* @dev Prevent Smart Contracts from calling the functions with this modifier
*/
modifier onlyEOA() {
}
constructor(
uint64 subscriptionId,
address _vrfCoordinator,
bytes32 _keyHash,
address _owner,
address _communitySignerAddress,
address _whitelistSignerAddress,
address _rizardSignerAddress,
string memory _unrevealed
) ERC721A("ChiefToad", "CT") VRFConsumerBaseV2(_vrfCoordinator) {
}
// -- Chainlink
function shuffle() external onlyOwner {
}
function fulfillRandomWords(
uint256, /* requestId */
uint256[] memory randomWords
) internal override {
}
/**
* @dev Basically get the first Word of the random value.
*/
function getRandom() public view returns (uint256) {
}
// Chainlink --
// -------------------- MINT FUNCTIONS --------------------------
/**
* @notice Community List Mint
* @dev 5th July 21:00 to 6th July 03:00
* 1. 5000 QTY (FCFS)
* 2. Price = 0.1 ETH
* 3. Max Mint per wallet = 2
* @param _mintAmount Amount that is minted
*/
function communityMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Whitelist Mint
* @dev 6th July 21:00 to 7th July 09:00
* 1. 888 WL ~ 1776 QTY
* 2. Price = 0.08 ETH
* 3. Max Mint per wallet = 2
* @param _mintAmount Amount that is minted
*/
function whitelistMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
// Check if user is whitelisted
require(<FILL_ME>)
// Check if whitelist sale is open
require(
stage == 3 || stage == 4,
"ChiefToads: Whitelist Mint is not open"
);
// Check if enough ETH is sent
require(
msg.value == _mintAmount * whitelistMintPrice,
"ChiefToads: Insufficient ETH!"
);
// Check if mints does not exceed MAX_SUPPLY
require(
totalSupply() + _mintAmount <= totalMaxSupply,
"ChiefToads: Exceeded Max Supply for Chief Toads!"
);
// Check if mints does not exceed max wallet allowance for public sale
require(
whitelistMintCount[msg.sender] + _mintAmount <=
whitelistMintMaxPerWallet,
"ChiefToads: Wallet has already minted Max Amount for Whitelist Mint 2!"
);
whitelistMintCount[msg.sender] += _mintAmount;
_safeMint(msg.sender, _mintAmount);
emit PrivateMint(msg.sender, _mintAmount);
}
/**
* @notice Chief Rizard Mint
* @dev 6th July 23:00 to 7th 09:00
* 1. 2336 QTY
* 2. Price = 0.08 ETH
* 3. Max Mint per wallet = 10
* @param _mintAmount Amount that is minted
*/
function rizardMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Public Mint
* @param _mintAmount Amount that is minted
*/
function publicMint(uint256 _mintAmount) external payable onlyEOA {
}
/**
* @notice Dev Mint
* @param _mintAmount Amount that is minted
*/
function devMint(uint256 _mintAmount) external onlyOwner {
}
/**
* @notice Airdrop
* @param _addresses List of addresses
*/
function airdrop(address[] memory _addresses) external onlyOwner {
}
// -------------------- WHITELIST FUNCTION ----------------------
/**
* @dev Checks if the the signature is signed by a valid signer for whitelist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function whitelistSigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
/**
* @dev Checks if the the signature is signed by a valid signer for communitylist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function communitySigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
/**
* @dev Checks if the the signature is signed by a valid signer for rizardlist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function rizardSigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
// ---------------------- VIEW FUNCTIONS ------------------------
/**
* @dev See {IERC721Metadata-tokenURI}.
* @dev gets baseURI from contract state variable
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// ------------------------- OWNER FUNCTIONS ----------------------------
/**
* @dev Set stage of minting
*/
function setStage(uint256 _newStage) public onlyOwner {
}
/**
* @dev Set signer address for community mint
*/
function setCommunitySignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set signer address for whitelist mint
*/
function setWhitelistSignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set signer address for Rizard Mint
*/
function setRizardSignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set Community Sale maximum amount of mints
*/
function setCommunityMaxSupply(uint256 amount) public onlyOwner {
}
function setCommunityMaxMintPerWallet(uint256 amount) public onlyOwner {
}
function setWhitelistMaxMintPerWallet(uint256 amount) public onlyOwner {
}
function setRizardMaxMintPerWallet(uint256 amount) public onlyOwner {
}
/**
* @dev Set the unrevealed URI
* @param newUnrevealedURI unrevealed URI for metadata
*/
function setNotRevealedURI(string memory newUnrevealedURI)
public
onlyOwner
{
}
/**
* @dev Set Revealed Metadata URI
*/
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
/**
* @notice Set Revealed state of NFT metadata
*/
function reveal(bool revealed) public onlyOwner {
}
/**
* @notice Withdraw all ETH from this account to the owner
*/
function withdrawFund() external onlyOwner {
}
/**
* @notice Sets the treasury address
*/
function setTreasury(address _treasury) public onlyOwner {
}
function setUnrevealedBasedURI(string memory __unrevealedBaseURI)
public
onlyOwner
{
}
}
| whitelistSigned(msg.sender,nonce,signature),"ChiefToads: Invalid Signature!" | 107,385 | whitelistSigned(msg.sender,nonce,signature) |
"ChiefToads: Exceeded Max Supply for Chief Toads!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "./ERC721A.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/// @title ChiefToads Mint Contract
contract ChiefToads is ERC721A, VRFConsumerBaseV2, Ownable {
using Strings for uint256;
using ECDSA for bytes32;
// -- Chainlink
VRFCoordinatorV2Interface COORDINATOR;
uint64 s_subscriptionId;
// see https://docs.chain.link/docs/vrf-contracts/#configurations
address vrfCoordinator;
// see https://docs.chain.link/docs/vrf-contracts/#configurations
bytes32 keyHash;
uint32 callbackGasLimit = 100000;
uint16 requestConfirmations = 3;
uint32 numWords = 1;
uint256[] public s_randomWords;
uint256 public s_requestId;
address s_owner;
// Chainlink --
string public baseURI;
bool private _revealed;
string private _unrevealedBaseURI;
// Stages
// 0: Before all minting commence
// 1: Community List Sale
// 2: End of community list sale, before Whitelist Sale
// 3: Whitelist Sale
// 4: Rizard Sale
// 5: End of whitelist + rizard, before public sale
// 6: Public sale
// 7: End of minting
uint256 public stage;
// General Mint Settings
uint256 public constant totalMaxSupply = 10000;
// Community Mint Settings
uint256 public communityMintMaxSupply = 5000;
uint256 public communityMintMaxPerWallet = 2; // Private Sale Address Mint Cap
uint256 public communityMintPrice = 0.1 ether; // Private Sale Mint Price
mapping(address => uint256) public communityMintCount;
address private communitySignerAddress;
// Whitelist Mint Settings
uint256 public whitelistMintMaxPerWallet = 2; // Private Sale Address Mint Cap
uint256 public whitelistMintPrice = 0.08 ether; // Private Sale Mint Price
mapping(address => uint256) public whitelistMintCount;
address private whitelistSignerAddress;
// Chief Rizard Mint Settings
uint256 public rizardMintMaxPerWallet = 10;
uint256 public rizardMintPrice = 0.08 ether;
mapping(address => uint256) public rizardMintCount;
address private rizardSignerAddress;
// Public Sale Mint Settings
uint256 public publicMintPrice = 0.1 ether;
uint256 public publicMintMaxPerWallet = 2;
mapping(address => uint256) public publicMintCount;
// Dev Mint Settings
// This counter will help to offset the minting of the dev tokens such that their count will not be counted towards the communityMintMaxSupply
uint256 public devMintCount;
// Treasury
address public treasury;
// Events
event PrivateMint(address indexed to, uint256 amount);
event PublicMint(address indexed to, uint256 amount);
event DevMint(uint256 count);
event WithdrawETH(uint256 amountWithdrawn);
event Revealed(uint256 timestamp);
event PrivateSaleOpened(bool status, uint256 timestamp);
event PublicSaleOpened(bool status, uint256 timestamp);
// Modifiers
/**
* @dev Prevent Smart Contracts from calling the functions with this modifier
*/
modifier onlyEOA() {
}
constructor(
uint64 subscriptionId,
address _vrfCoordinator,
bytes32 _keyHash,
address _owner,
address _communitySignerAddress,
address _whitelistSignerAddress,
address _rizardSignerAddress,
string memory _unrevealed
) ERC721A("ChiefToad", "CT") VRFConsumerBaseV2(_vrfCoordinator) {
}
// -- Chainlink
function shuffle() external onlyOwner {
}
function fulfillRandomWords(
uint256, /* requestId */
uint256[] memory randomWords
) internal override {
}
/**
* @dev Basically get the first Word of the random value.
*/
function getRandom() public view returns (uint256) {
}
// Chainlink --
// -------------------- MINT FUNCTIONS --------------------------
/**
* @notice Community List Mint
* @dev 5th July 21:00 to 6th July 03:00
* 1. 5000 QTY (FCFS)
* 2. Price = 0.1 ETH
* 3. Max Mint per wallet = 2
* @param _mintAmount Amount that is minted
*/
function communityMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Whitelist Mint
* @dev 6th July 21:00 to 7th July 09:00
* 1. 888 WL ~ 1776 QTY
* 2. Price = 0.08 ETH
* 3. Max Mint per wallet = 2
* @param _mintAmount Amount that is minted
*/
function whitelistMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
// Check if user is whitelisted
require(
whitelistSigned(msg.sender, nonce, signature),
"ChiefToads: Invalid Signature!"
);
// Check if whitelist sale is open
require(
stage == 3 || stage == 4,
"ChiefToads: Whitelist Mint is not open"
);
// Check if enough ETH is sent
require(
msg.value == _mintAmount * whitelistMintPrice,
"ChiefToads: Insufficient ETH!"
);
// Check if mints does not exceed MAX_SUPPLY
require(<FILL_ME>)
// Check if mints does not exceed max wallet allowance for public sale
require(
whitelistMintCount[msg.sender] + _mintAmount <=
whitelistMintMaxPerWallet,
"ChiefToads: Wallet has already minted Max Amount for Whitelist Mint 2!"
);
whitelistMintCount[msg.sender] += _mintAmount;
_safeMint(msg.sender, _mintAmount);
emit PrivateMint(msg.sender, _mintAmount);
}
/**
* @notice Chief Rizard Mint
* @dev 6th July 23:00 to 7th 09:00
* 1. 2336 QTY
* 2. Price = 0.08 ETH
* 3. Max Mint per wallet = 10
* @param _mintAmount Amount that is minted
*/
function rizardMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Public Mint
* @param _mintAmount Amount that is minted
*/
function publicMint(uint256 _mintAmount) external payable onlyEOA {
}
/**
* @notice Dev Mint
* @param _mintAmount Amount that is minted
*/
function devMint(uint256 _mintAmount) external onlyOwner {
}
/**
* @notice Airdrop
* @param _addresses List of addresses
*/
function airdrop(address[] memory _addresses) external onlyOwner {
}
// -------------------- WHITELIST FUNCTION ----------------------
/**
* @dev Checks if the the signature is signed by a valid signer for whitelist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function whitelistSigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
/**
* @dev Checks if the the signature is signed by a valid signer for communitylist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function communitySigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
/**
* @dev Checks if the the signature is signed by a valid signer for rizardlist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function rizardSigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
// ---------------------- VIEW FUNCTIONS ------------------------
/**
* @dev See {IERC721Metadata-tokenURI}.
* @dev gets baseURI from contract state variable
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// ------------------------- OWNER FUNCTIONS ----------------------------
/**
* @dev Set stage of minting
*/
function setStage(uint256 _newStage) public onlyOwner {
}
/**
* @dev Set signer address for community mint
*/
function setCommunitySignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set signer address for whitelist mint
*/
function setWhitelistSignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set signer address for Rizard Mint
*/
function setRizardSignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set Community Sale maximum amount of mints
*/
function setCommunityMaxSupply(uint256 amount) public onlyOwner {
}
function setCommunityMaxMintPerWallet(uint256 amount) public onlyOwner {
}
function setWhitelistMaxMintPerWallet(uint256 amount) public onlyOwner {
}
function setRizardMaxMintPerWallet(uint256 amount) public onlyOwner {
}
/**
* @dev Set the unrevealed URI
* @param newUnrevealedURI unrevealed URI for metadata
*/
function setNotRevealedURI(string memory newUnrevealedURI)
public
onlyOwner
{
}
/**
* @dev Set Revealed Metadata URI
*/
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
/**
* @notice Set Revealed state of NFT metadata
*/
function reveal(bool revealed) public onlyOwner {
}
/**
* @notice Withdraw all ETH from this account to the owner
*/
function withdrawFund() external onlyOwner {
}
/**
* @notice Sets the treasury address
*/
function setTreasury(address _treasury) public onlyOwner {
}
function setUnrevealedBasedURI(string memory __unrevealedBaseURI)
public
onlyOwner
{
}
}
| totalSupply()+_mintAmount<=totalMaxSupply,"ChiefToads: Exceeded Max Supply for Chief Toads!" | 107,385 | totalSupply()+_mintAmount<=totalMaxSupply |
"ChiefToads: Wallet has already minted Max Amount for Whitelist Mint 2!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "./ERC721A.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/// @title ChiefToads Mint Contract
contract ChiefToads is ERC721A, VRFConsumerBaseV2, Ownable {
using Strings for uint256;
using ECDSA for bytes32;
// -- Chainlink
VRFCoordinatorV2Interface COORDINATOR;
uint64 s_subscriptionId;
// see https://docs.chain.link/docs/vrf-contracts/#configurations
address vrfCoordinator;
// see https://docs.chain.link/docs/vrf-contracts/#configurations
bytes32 keyHash;
uint32 callbackGasLimit = 100000;
uint16 requestConfirmations = 3;
uint32 numWords = 1;
uint256[] public s_randomWords;
uint256 public s_requestId;
address s_owner;
// Chainlink --
string public baseURI;
bool private _revealed;
string private _unrevealedBaseURI;
// Stages
// 0: Before all minting commence
// 1: Community List Sale
// 2: End of community list sale, before Whitelist Sale
// 3: Whitelist Sale
// 4: Rizard Sale
// 5: End of whitelist + rizard, before public sale
// 6: Public sale
// 7: End of minting
uint256 public stage;
// General Mint Settings
uint256 public constant totalMaxSupply = 10000;
// Community Mint Settings
uint256 public communityMintMaxSupply = 5000;
uint256 public communityMintMaxPerWallet = 2; // Private Sale Address Mint Cap
uint256 public communityMintPrice = 0.1 ether; // Private Sale Mint Price
mapping(address => uint256) public communityMintCount;
address private communitySignerAddress;
// Whitelist Mint Settings
uint256 public whitelistMintMaxPerWallet = 2; // Private Sale Address Mint Cap
uint256 public whitelistMintPrice = 0.08 ether; // Private Sale Mint Price
mapping(address => uint256) public whitelistMintCount;
address private whitelistSignerAddress;
// Chief Rizard Mint Settings
uint256 public rizardMintMaxPerWallet = 10;
uint256 public rizardMintPrice = 0.08 ether;
mapping(address => uint256) public rizardMintCount;
address private rizardSignerAddress;
// Public Sale Mint Settings
uint256 public publicMintPrice = 0.1 ether;
uint256 public publicMintMaxPerWallet = 2;
mapping(address => uint256) public publicMintCount;
// Dev Mint Settings
// This counter will help to offset the minting of the dev tokens such that their count will not be counted towards the communityMintMaxSupply
uint256 public devMintCount;
// Treasury
address public treasury;
// Events
event PrivateMint(address indexed to, uint256 amount);
event PublicMint(address indexed to, uint256 amount);
event DevMint(uint256 count);
event WithdrawETH(uint256 amountWithdrawn);
event Revealed(uint256 timestamp);
event PrivateSaleOpened(bool status, uint256 timestamp);
event PublicSaleOpened(bool status, uint256 timestamp);
// Modifiers
/**
* @dev Prevent Smart Contracts from calling the functions with this modifier
*/
modifier onlyEOA() {
}
constructor(
uint64 subscriptionId,
address _vrfCoordinator,
bytes32 _keyHash,
address _owner,
address _communitySignerAddress,
address _whitelistSignerAddress,
address _rizardSignerAddress,
string memory _unrevealed
) ERC721A("ChiefToad", "CT") VRFConsumerBaseV2(_vrfCoordinator) {
}
// -- Chainlink
function shuffle() external onlyOwner {
}
function fulfillRandomWords(
uint256, /* requestId */
uint256[] memory randomWords
) internal override {
}
/**
* @dev Basically get the first Word of the random value.
*/
function getRandom() public view returns (uint256) {
}
// Chainlink --
// -------------------- MINT FUNCTIONS --------------------------
/**
* @notice Community List Mint
* @dev 5th July 21:00 to 6th July 03:00
* 1. 5000 QTY (FCFS)
* 2. Price = 0.1 ETH
* 3. Max Mint per wallet = 2
* @param _mintAmount Amount that is minted
*/
function communityMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Whitelist Mint
* @dev 6th July 21:00 to 7th July 09:00
* 1. 888 WL ~ 1776 QTY
* 2. Price = 0.08 ETH
* 3. Max Mint per wallet = 2
* @param _mintAmount Amount that is minted
*/
function whitelistMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
// Check if user is whitelisted
require(
whitelistSigned(msg.sender, nonce, signature),
"ChiefToads: Invalid Signature!"
);
// Check if whitelist sale is open
require(
stage == 3 || stage == 4,
"ChiefToads: Whitelist Mint is not open"
);
// Check if enough ETH is sent
require(
msg.value == _mintAmount * whitelistMintPrice,
"ChiefToads: Insufficient ETH!"
);
// Check if mints does not exceed MAX_SUPPLY
require(
totalSupply() + _mintAmount <= totalMaxSupply,
"ChiefToads: Exceeded Max Supply for Chief Toads!"
);
// Check if mints does not exceed max wallet allowance for public sale
require(<FILL_ME>)
whitelistMintCount[msg.sender] += _mintAmount;
_safeMint(msg.sender, _mintAmount);
emit PrivateMint(msg.sender, _mintAmount);
}
/**
* @notice Chief Rizard Mint
* @dev 6th July 23:00 to 7th 09:00
* 1. 2336 QTY
* 2. Price = 0.08 ETH
* 3. Max Mint per wallet = 10
* @param _mintAmount Amount that is minted
*/
function rizardMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Public Mint
* @param _mintAmount Amount that is minted
*/
function publicMint(uint256 _mintAmount) external payable onlyEOA {
}
/**
* @notice Dev Mint
* @param _mintAmount Amount that is minted
*/
function devMint(uint256 _mintAmount) external onlyOwner {
}
/**
* @notice Airdrop
* @param _addresses List of addresses
*/
function airdrop(address[] memory _addresses) external onlyOwner {
}
// -------------------- WHITELIST FUNCTION ----------------------
/**
* @dev Checks if the the signature is signed by a valid signer for whitelist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function whitelistSigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
/**
* @dev Checks if the the signature is signed by a valid signer for communitylist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function communitySigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
/**
* @dev Checks if the the signature is signed by a valid signer for rizardlist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function rizardSigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
// ---------------------- VIEW FUNCTIONS ------------------------
/**
* @dev See {IERC721Metadata-tokenURI}.
* @dev gets baseURI from contract state variable
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// ------------------------- OWNER FUNCTIONS ----------------------------
/**
* @dev Set stage of minting
*/
function setStage(uint256 _newStage) public onlyOwner {
}
/**
* @dev Set signer address for community mint
*/
function setCommunitySignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set signer address for whitelist mint
*/
function setWhitelistSignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set signer address for Rizard Mint
*/
function setRizardSignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set Community Sale maximum amount of mints
*/
function setCommunityMaxSupply(uint256 amount) public onlyOwner {
}
function setCommunityMaxMintPerWallet(uint256 amount) public onlyOwner {
}
function setWhitelistMaxMintPerWallet(uint256 amount) public onlyOwner {
}
function setRizardMaxMintPerWallet(uint256 amount) public onlyOwner {
}
/**
* @dev Set the unrevealed URI
* @param newUnrevealedURI unrevealed URI for metadata
*/
function setNotRevealedURI(string memory newUnrevealedURI)
public
onlyOwner
{
}
/**
* @dev Set Revealed Metadata URI
*/
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
/**
* @notice Set Revealed state of NFT metadata
*/
function reveal(bool revealed) public onlyOwner {
}
/**
* @notice Withdraw all ETH from this account to the owner
*/
function withdrawFund() external onlyOwner {
}
/**
* @notice Sets the treasury address
*/
function setTreasury(address _treasury) public onlyOwner {
}
function setUnrevealedBasedURI(string memory __unrevealedBaseURI)
public
onlyOwner
{
}
}
| whitelistMintCount[msg.sender]+_mintAmount<=whitelistMintMaxPerWallet,"ChiefToads: Wallet has already minted Max Amount for Whitelist Mint 2!" | 107,385 | whitelistMintCount[msg.sender]+_mintAmount<=whitelistMintMaxPerWallet |
"ChiefToads: Invalid Signature!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "./ERC721A.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/// @title ChiefToads Mint Contract
contract ChiefToads is ERC721A, VRFConsumerBaseV2, Ownable {
using Strings for uint256;
using ECDSA for bytes32;
// -- Chainlink
VRFCoordinatorV2Interface COORDINATOR;
uint64 s_subscriptionId;
// see https://docs.chain.link/docs/vrf-contracts/#configurations
address vrfCoordinator;
// see https://docs.chain.link/docs/vrf-contracts/#configurations
bytes32 keyHash;
uint32 callbackGasLimit = 100000;
uint16 requestConfirmations = 3;
uint32 numWords = 1;
uint256[] public s_randomWords;
uint256 public s_requestId;
address s_owner;
// Chainlink --
string public baseURI;
bool private _revealed;
string private _unrevealedBaseURI;
// Stages
// 0: Before all minting commence
// 1: Community List Sale
// 2: End of community list sale, before Whitelist Sale
// 3: Whitelist Sale
// 4: Rizard Sale
// 5: End of whitelist + rizard, before public sale
// 6: Public sale
// 7: End of minting
uint256 public stage;
// General Mint Settings
uint256 public constant totalMaxSupply = 10000;
// Community Mint Settings
uint256 public communityMintMaxSupply = 5000;
uint256 public communityMintMaxPerWallet = 2; // Private Sale Address Mint Cap
uint256 public communityMintPrice = 0.1 ether; // Private Sale Mint Price
mapping(address => uint256) public communityMintCount;
address private communitySignerAddress;
// Whitelist Mint Settings
uint256 public whitelistMintMaxPerWallet = 2; // Private Sale Address Mint Cap
uint256 public whitelistMintPrice = 0.08 ether; // Private Sale Mint Price
mapping(address => uint256) public whitelistMintCount;
address private whitelistSignerAddress;
// Chief Rizard Mint Settings
uint256 public rizardMintMaxPerWallet = 10;
uint256 public rizardMintPrice = 0.08 ether;
mapping(address => uint256) public rizardMintCount;
address private rizardSignerAddress;
// Public Sale Mint Settings
uint256 public publicMintPrice = 0.1 ether;
uint256 public publicMintMaxPerWallet = 2;
mapping(address => uint256) public publicMintCount;
// Dev Mint Settings
// This counter will help to offset the minting of the dev tokens such that their count will not be counted towards the communityMintMaxSupply
uint256 public devMintCount;
// Treasury
address public treasury;
// Events
event PrivateMint(address indexed to, uint256 amount);
event PublicMint(address indexed to, uint256 amount);
event DevMint(uint256 count);
event WithdrawETH(uint256 amountWithdrawn);
event Revealed(uint256 timestamp);
event PrivateSaleOpened(bool status, uint256 timestamp);
event PublicSaleOpened(bool status, uint256 timestamp);
// Modifiers
/**
* @dev Prevent Smart Contracts from calling the functions with this modifier
*/
modifier onlyEOA() {
}
constructor(
uint64 subscriptionId,
address _vrfCoordinator,
bytes32 _keyHash,
address _owner,
address _communitySignerAddress,
address _whitelistSignerAddress,
address _rizardSignerAddress,
string memory _unrevealed
) ERC721A("ChiefToad", "CT") VRFConsumerBaseV2(_vrfCoordinator) {
}
// -- Chainlink
function shuffle() external onlyOwner {
}
function fulfillRandomWords(
uint256, /* requestId */
uint256[] memory randomWords
) internal override {
}
/**
* @dev Basically get the first Word of the random value.
*/
function getRandom() public view returns (uint256) {
}
// Chainlink --
// -------------------- MINT FUNCTIONS --------------------------
/**
* @notice Community List Mint
* @dev 5th July 21:00 to 6th July 03:00
* 1. 5000 QTY (FCFS)
* 2. Price = 0.1 ETH
* 3. Max Mint per wallet = 2
* @param _mintAmount Amount that is minted
*/
function communityMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Whitelist Mint
* @dev 6th July 21:00 to 7th July 09:00
* 1. 888 WL ~ 1776 QTY
* 2. Price = 0.08 ETH
* 3. Max Mint per wallet = 2
* @param _mintAmount Amount that is minted
*/
function whitelistMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Chief Rizard Mint
* @dev 6th July 23:00 to 7th 09:00
* 1. 2336 QTY
* 2. Price = 0.08 ETH
* 3. Max Mint per wallet = 10
* @param _mintAmount Amount that is minted
*/
function rizardMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
// Check if user is whitelisted
require(<FILL_ME>)
// Check if rizard sale is open
require(stage == 4, "ChiefToads: Rizard Mint is not open");
// Check if enough ETH is sent
require(
msg.value == _mintAmount * rizardMintPrice,
"ChiefToads: Insufficient ETH!"
);
// Check if mints does not exceed MAX_SUPPLY
require(
totalSupply() + _mintAmount <= totalMaxSupply,
"ChiefToads: Exceeded Max Supply for Chief Toads!"
);
// Check if mints does not exceed max wallet allowance for public sale
require(
rizardMintCount[msg.sender] + _mintAmount <= rizardMintMaxPerWallet,
"ChiefToads: Wallet has already minted Max Amount for Rizard Mint!"
);
rizardMintCount[msg.sender] += _mintAmount;
_safeMint(msg.sender, _mintAmount);
emit PrivateMint(msg.sender, _mintAmount);
}
/**
* @notice Public Mint
* @param _mintAmount Amount that is minted
*/
function publicMint(uint256 _mintAmount) external payable onlyEOA {
}
/**
* @notice Dev Mint
* @param _mintAmount Amount that is minted
*/
function devMint(uint256 _mintAmount) external onlyOwner {
}
/**
* @notice Airdrop
* @param _addresses List of addresses
*/
function airdrop(address[] memory _addresses) external onlyOwner {
}
// -------------------- WHITELIST FUNCTION ----------------------
/**
* @dev Checks if the the signature is signed by a valid signer for whitelist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function whitelistSigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
/**
* @dev Checks if the the signature is signed by a valid signer for communitylist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function communitySigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
/**
* @dev Checks if the the signature is signed by a valid signer for rizardlist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function rizardSigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
// ---------------------- VIEW FUNCTIONS ------------------------
/**
* @dev See {IERC721Metadata-tokenURI}.
* @dev gets baseURI from contract state variable
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// ------------------------- OWNER FUNCTIONS ----------------------------
/**
* @dev Set stage of minting
*/
function setStage(uint256 _newStage) public onlyOwner {
}
/**
* @dev Set signer address for community mint
*/
function setCommunitySignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set signer address for whitelist mint
*/
function setWhitelistSignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set signer address for Rizard Mint
*/
function setRizardSignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set Community Sale maximum amount of mints
*/
function setCommunityMaxSupply(uint256 amount) public onlyOwner {
}
function setCommunityMaxMintPerWallet(uint256 amount) public onlyOwner {
}
function setWhitelistMaxMintPerWallet(uint256 amount) public onlyOwner {
}
function setRizardMaxMintPerWallet(uint256 amount) public onlyOwner {
}
/**
* @dev Set the unrevealed URI
* @param newUnrevealedURI unrevealed URI for metadata
*/
function setNotRevealedURI(string memory newUnrevealedURI)
public
onlyOwner
{
}
/**
* @dev Set Revealed Metadata URI
*/
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
/**
* @notice Set Revealed state of NFT metadata
*/
function reveal(bool revealed) public onlyOwner {
}
/**
* @notice Withdraw all ETH from this account to the owner
*/
function withdrawFund() external onlyOwner {
}
/**
* @notice Sets the treasury address
*/
function setTreasury(address _treasury) public onlyOwner {
}
function setUnrevealedBasedURI(string memory __unrevealedBaseURI)
public
onlyOwner
{
}
}
| rizardSigned(msg.sender,nonce,signature),"ChiefToads: Invalid Signature!" | 107,385 | rizardSigned(msg.sender,nonce,signature) |
"ChiefToads: Wallet has already minted Max Amount for Rizard Mint!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "./ERC721A.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/// @title ChiefToads Mint Contract
contract ChiefToads is ERC721A, VRFConsumerBaseV2, Ownable {
using Strings for uint256;
using ECDSA for bytes32;
// -- Chainlink
VRFCoordinatorV2Interface COORDINATOR;
uint64 s_subscriptionId;
// see https://docs.chain.link/docs/vrf-contracts/#configurations
address vrfCoordinator;
// see https://docs.chain.link/docs/vrf-contracts/#configurations
bytes32 keyHash;
uint32 callbackGasLimit = 100000;
uint16 requestConfirmations = 3;
uint32 numWords = 1;
uint256[] public s_randomWords;
uint256 public s_requestId;
address s_owner;
// Chainlink --
string public baseURI;
bool private _revealed;
string private _unrevealedBaseURI;
// Stages
// 0: Before all minting commence
// 1: Community List Sale
// 2: End of community list sale, before Whitelist Sale
// 3: Whitelist Sale
// 4: Rizard Sale
// 5: End of whitelist + rizard, before public sale
// 6: Public sale
// 7: End of minting
uint256 public stage;
// General Mint Settings
uint256 public constant totalMaxSupply = 10000;
// Community Mint Settings
uint256 public communityMintMaxSupply = 5000;
uint256 public communityMintMaxPerWallet = 2; // Private Sale Address Mint Cap
uint256 public communityMintPrice = 0.1 ether; // Private Sale Mint Price
mapping(address => uint256) public communityMintCount;
address private communitySignerAddress;
// Whitelist Mint Settings
uint256 public whitelistMintMaxPerWallet = 2; // Private Sale Address Mint Cap
uint256 public whitelistMintPrice = 0.08 ether; // Private Sale Mint Price
mapping(address => uint256) public whitelistMintCount;
address private whitelistSignerAddress;
// Chief Rizard Mint Settings
uint256 public rizardMintMaxPerWallet = 10;
uint256 public rizardMintPrice = 0.08 ether;
mapping(address => uint256) public rizardMintCount;
address private rizardSignerAddress;
// Public Sale Mint Settings
uint256 public publicMintPrice = 0.1 ether;
uint256 public publicMintMaxPerWallet = 2;
mapping(address => uint256) public publicMintCount;
// Dev Mint Settings
// This counter will help to offset the minting of the dev tokens such that their count will not be counted towards the communityMintMaxSupply
uint256 public devMintCount;
// Treasury
address public treasury;
// Events
event PrivateMint(address indexed to, uint256 amount);
event PublicMint(address indexed to, uint256 amount);
event DevMint(uint256 count);
event WithdrawETH(uint256 amountWithdrawn);
event Revealed(uint256 timestamp);
event PrivateSaleOpened(bool status, uint256 timestamp);
event PublicSaleOpened(bool status, uint256 timestamp);
// Modifiers
/**
* @dev Prevent Smart Contracts from calling the functions with this modifier
*/
modifier onlyEOA() {
}
constructor(
uint64 subscriptionId,
address _vrfCoordinator,
bytes32 _keyHash,
address _owner,
address _communitySignerAddress,
address _whitelistSignerAddress,
address _rizardSignerAddress,
string memory _unrevealed
) ERC721A("ChiefToad", "CT") VRFConsumerBaseV2(_vrfCoordinator) {
}
// -- Chainlink
function shuffle() external onlyOwner {
}
function fulfillRandomWords(
uint256, /* requestId */
uint256[] memory randomWords
) internal override {
}
/**
* @dev Basically get the first Word of the random value.
*/
function getRandom() public view returns (uint256) {
}
// Chainlink --
// -------------------- MINT FUNCTIONS --------------------------
/**
* @notice Community List Mint
* @dev 5th July 21:00 to 6th July 03:00
* 1. 5000 QTY (FCFS)
* 2. Price = 0.1 ETH
* 3. Max Mint per wallet = 2
* @param _mintAmount Amount that is minted
*/
function communityMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Whitelist Mint
* @dev 6th July 21:00 to 7th July 09:00
* 1. 888 WL ~ 1776 QTY
* 2. Price = 0.08 ETH
* 3. Max Mint per wallet = 2
* @param _mintAmount Amount that is minted
*/
function whitelistMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Chief Rizard Mint
* @dev 6th July 23:00 to 7th 09:00
* 1. 2336 QTY
* 2. Price = 0.08 ETH
* 3. Max Mint per wallet = 10
* @param _mintAmount Amount that is minted
*/
function rizardMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
// Check if user is whitelisted
require(
rizardSigned(msg.sender, nonce, signature),
"ChiefToads: Invalid Signature!"
);
// Check if rizard sale is open
require(stage == 4, "ChiefToads: Rizard Mint is not open");
// Check if enough ETH is sent
require(
msg.value == _mintAmount * rizardMintPrice,
"ChiefToads: Insufficient ETH!"
);
// Check if mints does not exceed MAX_SUPPLY
require(
totalSupply() + _mintAmount <= totalMaxSupply,
"ChiefToads: Exceeded Max Supply for Chief Toads!"
);
// Check if mints does not exceed max wallet allowance for public sale
require(<FILL_ME>)
rizardMintCount[msg.sender] += _mintAmount;
_safeMint(msg.sender, _mintAmount);
emit PrivateMint(msg.sender, _mintAmount);
}
/**
* @notice Public Mint
* @param _mintAmount Amount that is minted
*/
function publicMint(uint256 _mintAmount) external payable onlyEOA {
}
/**
* @notice Dev Mint
* @param _mintAmount Amount that is minted
*/
function devMint(uint256 _mintAmount) external onlyOwner {
}
/**
* @notice Airdrop
* @param _addresses List of addresses
*/
function airdrop(address[] memory _addresses) external onlyOwner {
}
// -------------------- WHITELIST FUNCTION ----------------------
/**
* @dev Checks if the the signature is signed by a valid signer for whitelist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function whitelistSigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
/**
* @dev Checks if the the signature is signed by a valid signer for communitylist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function communitySigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
/**
* @dev Checks if the the signature is signed by a valid signer for rizardlist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function rizardSigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
// ---------------------- VIEW FUNCTIONS ------------------------
/**
* @dev See {IERC721Metadata-tokenURI}.
* @dev gets baseURI from contract state variable
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// ------------------------- OWNER FUNCTIONS ----------------------------
/**
* @dev Set stage of minting
*/
function setStage(uint256 _newStage) public onlyOwner {
}
/**
* @dev Set signer address for community mint
*/
function setCommunitySignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set signer address for whitelist mint
*/
function setWhitelistSignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set signer address for Rizard Mint
*/
function setRizardSignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set Community Sale maximum amount of mints
*/
function setCommunityMaxSupply(uint256 amount) public onlyOwner {
}
function setCommunityMaxMintPerWallet(uint256 amount) public onlyOwner {
}
function setWhitelistMaxMintPerWallet(uint256 amount) public onlyOwner {
}
function setRizardMaxMintPerWallet(uint256 amount) public onlyOwner {
}
/**
* @dev Set the unrevealed URI
* @param newUnrevealedURI unrevealed URI for metadata
*/
function setNotRevealedURI(string memory newUnrevealedURI)
public
onlyOwner
{
}
/**
* @dev Set Revealed Metadata URI
*/
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
/**
* @notice Set Revealed state of NFT metadata
*/
function reveal(bool revealed) public onlyOwner {
}
/**
* @notice Withdraw all ETH from this account to the owner
*/
function withdrawFund() external onlyOwner {
}
/**
* @notice Sets the treasury address
*/
function setTreasury(address _treasury) public onlyOwner {
}
function setUnrevealedBasedURI(string memory __unrevealedBaseURI)
public
onlyOwner
{
}
}
| rizardMintCount[msg.sender]+_mintAmount<=rizardMintMaxPerWallet,"ChiefToads: Wallet has already minted Max Amount for Rizard Mint!" | 107,385 | rizardMintCount[msg.sender]+_mintAmount<=rizardMintMaxPerWallet |
"ChiefToads: Wallet has already minted Max Amount for Public Mint!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "./ERC721A.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/// @title ChiefToads Mint Contract
contract ChiefToads is ERC721A, VRFConsumerBaseV2, Ownable {
using Strings for uint256;
using ECDSA for bytes32;
// -- Chainlink
VRFCoordinatorV2Interface COORDINATOR;
uint64 s_subscriptionId;
// see https://docs.chain.link/docs/vrf-contracts/#configurations
address vrfCoordinator;
// see https://docs.chain.link/docs/vrf-contracts/#configurations
bytes32 keyHash;
uint32 callbackGasLimit = 100000;
uint16 requestConfirmations = 3;
uint32 numWords = 1;
uint256[] public s_randomWords;
uint256 public s_requestId;
address s_owner;
// Chainlink --
string public baseURI;
bool private _revealed;
string private _unrevealedBaseURI;
// Stages
// 0: Before all minting commence
// 1: Community List Sale
// 2: End of community list sale, before Whitelist Sale
// 3: Whitelist Sale
// 4: Rizard Sale
// 5: End of whitelist + rizard, before public sale
// 6: Public sale
// 7: End of minting
uint256 public stage;
// General Mint Settings
uint256 public constant totalMaxSupply = 10000;
// Community Mint Settings
uint256 public communityMintMaxSupply = 5000;
uint256 public communityMintMaxPerWallet = 2; // Private Sale Address Mint Cap
uint256 public communityMintPrice = 0.1 ether; // Private Sale Mint Price
mapping(address => uint256) public communityMintCount;
address private communitySignerAddress;
// Whitelist Mint Settings
uint256 public whitelistMintMaxPerWallet = 2; // Private Sale Address Mint Cap
uint256 public whitelistMintPrice = 0.08 ether; // Private Sale Mint Price
mapping(address => uint256) public whitelistMintCount;
address private whitelistSignerAddress;
// Chief Rizard Mint Settings
uint256 public rizardMintMaxPerWallet = 10;
uint256 public rizardMintPrice = 0.08 ether;
mapping(address => uint256) public rizardMintCount;
address private rizardSignerAddress;
// Public Sale Mint Settings
uint256 public publicMintPrice = 0.1 ether;
uint256 public publicMintMaxPerWallet = 2;
mapping(address => uint256) public publicMintCount;
// Dev Mint Settings
// This counter will help to offset the minting of the dev tokens such that their count will not be counted towards the communityMintMaxSupply
uint256 public devMintCount;
// Treasury
address public treasury;
// Events
event PrivateMint(address indexed to, uint256 amount);
event PublicMint(address indexed to, uint256 amount);
event DevMint(uint256 count);
event WithdrawETH(uint256 amountWithdrawn);
event Revealed(uint256 timestamp);
event PrivateSaleOpened(bool status, uint256 timestamp);
event PublicSaleOpened(bool status, uint256 timestamp);
// Modifiers
/**
* @dev Prevent Smart Contracts from calling the functions with this modifier
*/
modifier onlyEOA() {
}
constructor(
uint64 subscriptionId,
address _vrfCoordinator,
bytes32 _keyHash,
address _owner,
address _communitySignerAddress,
address _whitelistSignerAddress,
address _rizardSignerAddress,
string memory _unrevealed
) ERC721A("ChiefToad", "CT") VRFConsumerBaseV2(_vrfCoordinator) {
}
// -- Chainlink
function shuffle() external onlyOwner {
}
function fulfillRandomWords(
uint256, /* requestId */
uint256[] memory randomWords
) internal override {
}
/**
* @dev Basically get the first Word of the random value.
*/
function getRandom() public view returns (uint256) {
}
// Chainlink --
// -------------------- MINT FUNCTIONS --------------------------
/**
* @notice Community List Mint
* @dev 5th July 21:00 to 6th July 03:00
* 1. 5000 QTY (FCFS)
* 2. Price = 0.1 ETH
* 3. Max Mint per wallet = 2
* @param _mintAmount Amount that is minted
*/
function communityMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Whitelist Mint
* @dev 6th July 21:00 to 7th July 09:00
* 1. 888 WL ~ 1776 QTY
* 2. Price = 0.08 ETH
* 3. Max Mint per wallet = 2
* @param _mintAmount Amount that is minted
*/
function whitelistMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Chief Rizard Mint
* @dev 6th July 23:00 to 7th 09:00
* 1. 2336 QTY
* 2. Price = 0.08 ETH
* 3. Max Mint per wallet = 10
* @param _mintAmount Amount that is minted
*/
function rizardMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Public Mint
* @param _mintAmount Amount that is minted
*/
function publicMint(uint256 _mintAmount) external payable onlyEOA {
// Check if public sale is open
require(stage == 6, "ChiefToads: Public Sale Closed!");
// Check if enough ETH is sent
require(
msg.value == _mintAmount * publicMintPrice,
"ChiefToads: Insufficient ETH!"
);
// Check if mints does not exceed total max supply
require(
totalSupply() + _mintAmount <= totalMaxSupply,
"ChiefToads: Max Supply for Public Mint Reached!"
);
require(<FILL_ME>)
publicMintCount[msg.sender] += _mintAmount;
_safeMint(msg.sender, _mintAmount);
emit PublicMint(msg.sender, _mintAmount);
}
/**
* @notice Dev Mint
* @param _mintAmount Amount that is minted
*/
function devMint(uint256 _mintAmount) external onlyOwner {
}
/**
* @notice Airdrop
* @param _addresses List of addresses
*/
function airdrop(address[] memory _addresses) external onlyOwner {
}
// -------------------- WHITELIST FUNCTION ----------------------
/**
* @dev Checks if the the signature is signed by a valid signer for whitelist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function whitelistSigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
/**
* @dev Checks if the the signature is signed by a valid signer for communitylist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function communitySigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
/**
* @dev Checks if the the signature is signed by a valid signer for rizardlist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function rizardSigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
// ---------------------- VIEW FUNCTIONS ------------------------
/**
* @dev See {IERC721Metadata-tokenURI}.
* @dev gets baseURI from contract state variable
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// ------------------------- OWNER FUNCTIONS ----------------------------
/**
* @dev Set stage of minting
*/
function setStage(uint256 _newStage) public onlyOwner {
}
/**
* @dev Set signer address for community mint
*/
function setCommunitySignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set signer address for whitelist mint
*/
function setWhitelistSignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set signer address for Rizard Mint
*/
function setRizardSignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set Community Sale maximum amount of mints
*/
function setCommunityMaxSupply(uint256 amount) public onlyOwner {
}
function setCommunityMaxMintPerWallet(uint256 amount) public onlyOwner {
}
function setWhitelistMaxMintPerWallet(uint256 amount) public onlyOwner {
}
function setRizardMaxMintPerWallet(uint256 amount) public onlyOwner {
}
/**
* @dev Set the unrevealed URI
* @param newUnrevealedURI unrevealed URI for metadata
*/
function setNotRevealedURI(string memory newUnrevealedURI)
public
onlyOwner
{
}
/**
* @dev Set Revealed Metadata URI
*/
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
/**
* @notice Set Revealed state of NFT metadata
*/
function reveal(bool revealed) public onlyOwner {
}
/**
* @notice Withdraw all ETH from this account to the owner
*/
function withdrawFund() external onlyOwner {
}
/**
* @notice Sets the treasury address
*/
function setTreasury(address _treasury) public onlyOwner {
}
function setUnrevealedBasedURI(string memory __unrevealedBaseURI)
public
onlyOwner
{
}
}
| publicMintCount[msg.sender]+_mintAmount<=publicMintMaxPerWallet,"ChiefToads: Wallet has already minted Max Amount for Public Mint!" | 107,385 | publicMintCount[msg.sender]+_mintAmount<=publicMintMaxPerWallet |
"ChiefToads: Max Supply Reached!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "./ERC721A.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/// @title ChiefToads Mint Contract
contract ChiefToads is ERC721A, VRFConsumerBaseV2, Ownable {
using Strings for uint256;
using ECDSA for bytes32;
// -- Chainlink
VRFCoordinatorV2Interface COORDINATOR;
uint64 s_subscriptionId;
// see https://docs.chain.link/docs/vrf-contracts/#configurations
address vrfCoordinator;
// see https://docs.chain.link/docs/vrf-contracts/#configurations
bytes32 keyHash;
uint32 callbackGasLimit = 100000;
uint16 requestConfirmations = 3;
uint32 numWords = 1;
uint256[] public s_randomWords;
uint256 public s_requestId;
address s_owner;
// Chainlink --
string public baseURI;
bool private _revealed;
string private _unrevealedBaseURI;
// Stages
// 0: Before all minting commence
// 1: Community List Sale
// 2: End of community list sale, before Whitelist Sale
// 3: Whitelist Sale
// 4: Rizard Sale
// 5: End of whitelist + rizard, before public sale
// 6: Public sale
// 7: End of minting
uint256 public stage;
// General Mint Settings
uint256 public constant totalMaxSupply = 10000;
// Community Mint Settings
uint256 public communityMintMaxSupply = 5000;
uint256 public communityMintMaxPerWallet = 2; // Private Sale Address Mint Cap
uint256 public communityMintPrice = 0.1 ether; // Private Sale Mint Price
mapping(address => uint256) public communityMintCount;
address private communitySignerAddress;
// Whitelist Mint Settings
uint256 public whitelistMintMaxPerWallet = 2; // Private Sale Address Mint Cap
uint256 public whitelistMintPrice = 0.08 ether; // Private Sale Mint Price
mapping(address => uint256) public whitelistMintCount;
address private whitelistSignerAddress;
// Chief Rizard Mint Settings
uint256 public rizardMintMaxPerWallet = 10;
uint256 public rizardMintPrice = 0.08 ether;
mapping(address => uint256) public rizardMintCount;
address private rizardSignerAddress;
// Public Sale Mint Settings
uint256 public publicMintPrice = 0.1 ether;
uint256 public publicMintMaxPerWallet = 2;
mapping(address => uint256) public publicMintCount;
// Dev Mint Settings
// This counter will help to offset the minting of the dev tokens such that their count will not be counted towards the communityMintMaxSupply
uint256 public devMintCount;
// Treasury
address public treasury;
// Events
event PrivateMint(address indexed to, uint256 amount);
event PublicMint(address indexed to, uint256 amount);
event DevMint(uint256 count);
event WithdrawETH(uint256 amountWithdrawn);
event Revealed(uint256 timestamp);
event PrivateSaleOpened(bool status, uint256 timestamp);
event PublicSaleOpened(bool status, uint256 timestamp);
// Modifiers
/**
* @dev Prevent Smart Contracts from calling the functions with this modifier
*/
modifier onlyEOA() {
}
constructor(
uint64 subscriptionId,
address _vrfCoordinator,
bytes32 _keyHash,
address _owner,
address _communitySignerAddress,
address _whitelistSignerAddress,
address _rizardSignerAddress,
string memory _unrevealed
) ERC721A("ChiefToad", "CT") VRFConsumerBaseV2(_vrfCoordinator) {
}
// -- Chainlink
function shuffle() external onlyOwner {
}
function fulfillRandomWords(
uint256, /* requestId */
uint256[] memory randomWords
) internal override {
}
/**
* @dev Basically get the first Word of the random value.
*/
function getRandom() public view returns (uint256) {
}
// Chainlink --
// -------------------- MINT FUNCTIONS --------------------------
/**
* @notice Community List Mint
* @dev 5th July 21:00 to 6th July 03:00
* 1. 5000 QTY (FCFS)
* 2. Price = 0.1 ETH
* 3. Max Mint per wallet = 2
* @param _mintAmount Amount that is minted
*/
function communityMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Whitelist Mint
* @dev 6th July 21:00 to 7th July 09:00
* 1. 888 WL ~ 1776 QTY
* 2. Price = 0.08 ETH
* 3. Max Mint per wallet = 2
* @param _mintAmount Amount that is minted
*/
function whitelistMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Chief Rizard Mint
* @dev 6th July 23:00 to 7th 09:00
* 1. 2336 QTY
* 2. Price = 0.08 ETH
* 3. Max Mint per wallet = 10
* @param _mintAmount Amount that is minted
*/
function rizardMint(
uint256 _mintAmount,
bytes memory nonce,
bytes memory signature
) external payable onlyEOA {
}
/**
* @notice Public Mint
* @param _mintAmount Amount that is minted
*/
function publicMint(uint256 _mintAmount) external payable onlyEOA {
}
/**
* @notice Dev Mint
* @param _mintAmount Amount that is minted
*/
function devMint(uint256 _mintAmount) external onlyOwner {
}
/**
* @notice Airdrop
* @param _addresses List of addresses
*/
function airdrop(address[] memory _addresses) external onlyOwner {
require(<FILL_ME>)
for (uint256 i; i < _addresses.length; i++) {
_safeMint(_addresses[i], 1);
}
}
// -------------------- WHITELIST FUNCTION ----------------------
/**
* @dev Checks if the the signature is signed by a valid signer for whitelist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function whitelistSigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
/**
* @dev Checks if the the signature is signed by a valid signer for communitylist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function communitySigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
/**
* @dev Checks if the the signature is signed by a valid signer for rizardlist
* @param sender Address of minter
* @param nonce Random bytes32 nonce
* @param signature Signature generated off-chain
*/
function rizardSigned(
address sender,
bytes memory nonce,
bytes memory signature
) private view returns (bool) {
}
// ---------------------- VIEW FUNCTIONS ------------------------
/**
* @dev See {IERC721Metadata-tokenURI}.
* @dev gets baseURI from contract state variable
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// ------------------------- OWNER FUNCTIONS ----------------------------
/**
* @dev Set stage of minting
*/
function setStage(uint256 _newStage) public onlyOwner {
}
/**
* @dev Set signer address for community mint
*/
function setCommunitySignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set signer address for whitelist mint
*/
function setWhitelistSignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set signer address for Rizard Mint
*/
function setRizardSignerAddress(address signer) public onlyOwner {
}
/**
* @dev Set Community Sale maximum amount of mints
*/
function setCommunityMaxSupply(uint256 amount) public onlyOwner {
}
function setCommunityMaxMintPerWallet(uint256 amount) public onlyOwner {
}
function setWhitelistMaxMintPerWallet(uint256 amount) public onlyOwner {
}
function setRizardMaxMintPerWallet(uint256 amount) public onlyOwner {
}
/**
* @dev Set the unrevealed URI
* @param newUnrevealedURI unrevealed URI for metadata
*/
function setNotRevealedURI(string memory newUnrevealedURI)
public
onlyOwner
{
}
/**
* @dev Set Revealed Metadata URI
*/
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
/**
* @notice Set Revealed state of NFT metadata
*/
function reveal(bool revealed) public onlyOwner {
}
/**
* @notice Withdraw all ETH from this account to the owner
*/
function withdrawFund() external onlyOwner {
}
/**
* @notice Sets the treasury address
*/
function setTreasury(address _treasury) public onlyOwner {
}
function setUnrevealedBasedURI(string memory __unrevealedBaseURI)
public
onlyOwner
{
}
}
| totalSupply()+_addresses.length<=totalMaxSupply,"ChiefToads: Max Supply Reached!" | 107,385 | totalSupply()+_addresses.length<=totalMaxSupply |
"setStartTime: Sender must be admin" | pragma solidity 0.8.6;
import "IJellyContract.sol";
import "IJellyAccessControls.sol";
// import "IERC20.sol";
import "IJellyPool.sol";
import "SafeERC20.sol";
interface IERC721 {
function ownerOf(uint256 tokenId) external view returns (address);
}
interface IVeToken {
function create_lock_for(uint _value, uint _lock_duration, address _to) external returns (uint);
}
struct UserInfo {
uint128 totalAmount;
uint128 rewardsReleased;
}
interface IJellyDropWrapper {
function userRewards( address _user) external view returns (UserInfo memory);
function claim(bytes32 _merkleRoot, uint256 _index, address _user, uint256 _amount, bytes32[] calldata _data ) external;
}
contract DropVeBonus is IJellyContract {
using SafeERC20 for OZIERC20;
/// @notice Jelly template type and id for the factory.
uint256 public constant override TEMPLATE_TYPE = 9;
bytes32 public constant override TEMPLATE_ID = keccak256("DROP_VE_BONUS");
uint256 private constant PERCENTAGE_PRECISION = 10000;
uint256 private constant SECONDS_PER_DAY = 24 * 60 * 60;
uint256 private constant MAX_INT =
0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
uint256 public constant pointMultiplier = 10e12;
/// @notice Address that manages approvals.
IJellyAccessControls public accessControls;
/// @notice Reward token address.
address public poolToken;
address public dropAddress;
/// @notice ve contract for locking tokens.
address public veToken;
/// @notice JellyVault is where fees are sent.
address private jellyVault;
/// @notice The fee percentage out of 10000 (100.00%)
uint256 private feePercentage;
/// @notice Current total rewards paid.
uint256 public rewardsPaid;
/// @notice Total tokens to be distributed.
uint256 public totalTokens;
/// @notice Mapping of User -> amount of tokens locked.
mapping(address => uint256) public rewardsLocked;
uint256 public lockDuration;
uint256 public bonusPercentage;
/// @notice Whether contract has been initialised or not.
bool private initialised;
/**
* @notice Event emitted when reward tokens have been added to the pool.
* @param amount Number of tokens added.
* @param fees Amount of fees.
*/
event RewardsAdded(uint256 amount, uint256 fees);
/**
* @notice Event emitted for Jelly admin updates.
* @param vault Address of the new vault address.
* @param fee New fee percentage.
*/
event JellyUpdated(address vault, uint256 fee);
/**
* @notice Event emitted for when tokens are recovered.
* @param token ERC20 token address.
* @param amount Token amount in wei.
*/
event Recovered(address token, uint256 amount);
//--------------------------------------------------------
// Setters
//--------------------------------------------------------
/// @dev Setter functions for setting lock duration
function setLockDuration(uint256 _lockDuration) external {
require(<FILL_ME>)
lockDuration = _lockDuration;
}
//--------------------------------------------------------
// Rewards
//--------------------------------------------------------
/// @dev Setter functions for contract config
function setBonusPercentage(uint256 _bonusPercentage) external {
}
/**
* @notice Add more tokens to the JellyDrop contract.
* @param _rewardAmount Amount of tokens to add, in wei. (18 decimal place format)
*/
function addRewards(uint256 _rewardAmount) public {
}
/**
* @notice Jelly vault can update new vault and fee.
* @param _vault New vault address.
* @param _fee Fee percentage of tokens distributed.
*/
function updateJelly(address _vault, uint256 _fee) external {
}
//--------------------------------------------------------
// Bonus
//--------------------------------------------------------
/**
* @notice Claims rewards from airdrop and locked in ve with bonus rewards.
*/
function claimAndLock(bytes32 _merkleRoot, uint256 _index, address _user, uint256 _amount, bytes32[] calldata _data ) external returns (uint) {
}
function lockAmount(uint256 _amount) public returns (uint) {
}
function _lockAmount(address _user, uint256 _amount) internal returns (uint) {
}
function getTokenRewardsClaimed( address _user) public view returns(uint256 rewardsClaimed) {
}
//--------------------------------------------------------
// Admin Reclaim
//--------------------------------------------------------
/**
* @notice Admin can end token distribution and reclaim tokens.
* @notice Also allows for the recovery of incorrect ERC20 tokens sent to contract
* @param _vault Address where the reclaimed tokens will be sent.
*/
function adminReclaimTokens(
address _tokenAddress,
address _vault,
uint256 _tokenAmount
)
external
{
}
//--------------------------------------------------------
// Factory Init
//--------------------------------------------------------
/**
* @notice Initializes main contract variables.
* @dev Init function.
* @param _accessControls Access controls interface.
* @param _dropAddress Address of the airdrop contract.
* @param _veToken Address of the ve contract.
* @param _jellyVault The Jelly vault address.
* @param _jellyFee Fee percentage for added tokens. To 2dp (10000 = 100.00%)
*/
function initVeBonus(
address _accessControls,
address _dropAddress,
address _veToken,
address _jellyVault,
uint256 _jellyFee
) public
{
}
/**
* @dev Used by the Jelly Factory.
*/
function init(bytes calldata _data) external override payable {}
function initContract(
bytes calldata _data
) external override {
}
}
| accessControls.hasAdminRole(msg.sender),"setStartTime: Sender must be admin" | 107,440 | accessControls.hasAdminRole(msg.sender) |
"addRewards: Sender must be admin/operator" | pragma solidity 0.8.6;
import "IJellyContract.sol";
import "IJellyAccessControls.sol";
// import "IERC20.sol";
import "IJellyPool.sol";
import "SafeERC20.sol";
interface IERC721 {
function ownerOf(uint256 tokenId) external view returns (address);
}
interface IVeToken {
function create_lock_for(uint _value, uint _lock_duration, address _to) external returns (uint);
}
struct UserInfo {
uint128 totalAmount;
uint128 rewardsReleased;
}
interface IJellyDropWrapper {
function userRewards( address _user) external view returns (UserInfo memory);
function claim(bytes32 _merkleRoot, uint256 _index, address _user, uint256 _amount, bytes32[] calldata _data ) external;
}
contract DropVeBonus is IJellyContract {
using SafeERC20 for OZIERC20;
/// @notice Jelly template type and id for the factory.
uint256 public constant override TEMPLATE_TYPE = 9;
bytes32 public constant override TEMPLATE_ID = keccak256("DROP_VE_BONUS");
uint256 private constant PERCENTAGE_PRECISION = 10000;
uint256 private constant SECONDS_PER_DAY = 24 * 60 * 60;
uint256 private constant MAX_INT =
0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
uint256 public constant pointMultiplier = 10e12;
/// @notice Address that manages approvals.
IJellyAccessControls public accessControls;
/// @notice Reward token address.
address public poolToken;
address public dropAddress;
/// @notice ve contract for locking tokens.
address public veToken;
/// @notice JellyVault is where fees are sent.
address private jellyVault;
/// @notice The fee percentage out of 10000 (100.00%)
uint256 private feePercentage;
/// @notice Current total rewards paid.
uint256 public rewardsPaid;
/// @notice Total tokens to be distributed.
uint256 public totalTokens;
/// @notice Mapping of User -> amount of tokens locked.
mapping(address => uint256) public rewardsLocked;
uint256 public lockDuration;
uint256 public bonusPercentage;
/// @notice Whether contract has been initialised or not.
bool private initialised;
/**
* @notice Event emitted when reward tokens have been added to the pool.
* @param amount Number of tokens added.
* @param fees Amount of fees.
*/
event RewardsAdded(uint256 amount, uint256 fees);
/**
* @notice Event emitted for Jelly admin updates.
* @param vault Address of the new vault address.
* @param fee New fee percentage.
*/
event JellyUpdated(address vault, uint256 fee);
/**
* @notice Event emitted for when tokens are recovered.
* @param token ERC20 token address.
* @param amount Token amount in wei.
*/
event Recovered(address token, uint256 amount);
//--------------------------------------------------------
// Setters
//--------------------------------------------------------
/// @dev Setter functions for setting lock duration
function setLockDuration(uint256 _lockDuration) external {
}
//--------------------------------------------------------
// Rewards
//--------------------------------------------------------
/// @dev Setter functions for contract config
function setBonusPercentage(uint256 _bonusPercentage) external {
}
/**
* @notice Add more tokens to the JellyDrop contract.
* @param _rewardAmount Amount of tokens to add, in wei. (18 decimal place format)
*/
function addRewards(uint256 _rewardAmount) public {
require(<FILL_ME>)
OZIERC20(poolToken).safeTransferFrom(msg.sender, address(this), _rewardAmount);
uint256 tokensAdded = _rewardAmount * PERCENTAGE_PRECISION / (feePercentage + PERCENTAGE_PRECISION);
uint256 jellyFee = _rewardAmount * feePercentage / (feePercentage + PERCENTAGE_PRECISION);
totalTokens += tokensAdded ;
OZIERC20(poolToken).safeTransfer(jellyVault, jellyFee);
emit RewardsAdded(_rewardAmount, jellyFee);
}
/**
* @notice Jelly vault can update new vault and fee.
* @param _vault New vault address.
* @param _fee Fee percentage of tokens distributed.
*/
function updateJelly(address _vault, uint256 _fee) external {
}
//--------------------------------------------------------
// Bonus
//--------------------------------------------------------
/**
* @notice Claims rewards from airdrop and locked in ve with bonus rewards.
*/
function claimAndLock(bytes32 _merkleRoot, uint256 _index, address _user, uint256 _amount, bytes32[] calldata _data ) external returns (uint) {
}
function lockAmount(uint256 _amount) public returns (uint) {
}
function _lockAmount(address _user, uint256 _amount) internal returns (uint) {
}
function getTokenRewardsClaimed( address _user) public view returns(uint256 rewardsClaimed) {
}
//--------------------------------------------------------
// Admin Reclaim
//--------------------------------------------------------
/**
* @notice Admin can end token distribution and reclaim tokens.
* @notice Also allows for the recovery of incorrect ERC20 tokens sent to contract
* @param _vault Address where the reclaimed tokens will be sent.
*/
function adminReclaimTokens(
address _tokenAddress,
address _vault,
uint256 _tokenAmount
)
external
{
}
//--------------------------------------------------------
// Factory Init
//--------------------------------------------------------
/**
* @notice Initializes main contract variables.
* @dev Init function.
* @param _accessControls Access controls interface.
* @param _dropAddress Address of the airdrop contract.
* @param _veToken Address of the ve contract.
* @param _jellyVault The Jelly vault address.
* @param _jellyFee Fee percentage for added tokens. To 2dp (10000 = 100.00%)
*/
function initVeBonus(
address _accessControls,
address _dropAddress,
address _veToken,
address _jellyVault,
uint256 _jellyFee
) public
{
}
/**
* @dev Used by the Jelly Factory.
*/
function init(bytes calldata _data) external override payable {}
function initContract(
bytes calldata _data
) external override {
}
}
| accessControls.hasAdminRole(msg.sender)||accessControls.hasOperatorRole(msg.sender),"addRewards: Sender must be admin/operator" | 107,440 | accessControls.hasAdminRole(msg.sender)||accessControls.hasOperatorRole(msg.sender) |
"Locking more tokens than has been earnt." | pragma solidity 0.8.6;
import "IJellyContract.sol";
import "IJellyAccessControls.sol";
// import "IERC20.sol";
import "IJellyPool.sol";
import "SafeERC20.sol";
interface IERC721 {
function ownerOf(uint256 tokenId) external view returns (address);
}
interface IVeToken {
function create_lock_for(uint _value, uint _lock_duration, address _to) external returns (uint);
}
struct UserInfo {
uint128 totalAmount;
uint128 rewardsReleased;
}
interface IJellyDropWrapper {
function userRewards( address _user) external view returns (UserInfo memory);
function claim(bytes32 _merkleRoot, uint256 _index, address _user, uint256 _amount, bytes32[] calldata _data ) external;
}
contract DropVeBonus is IJellyContract {
using SafeERC20 for OZIERC20;
/// @notice Jelly template type and id for the factory.
uint256 public constant override TEMPLATE_TYPE = 9;
bytes32 public constant override TEMPLATE_ID = keccak256("DROP_VE_BONUS");
uint256 private constant PERCENTAGE_PRECISION = 10000;
uint256 private constant SECONDS_PER_DAY = 24 * 60 * 60;
uint256 private constant MAX_INT =
0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
uint256 public constant pointMultiplier = 10e12;
/// @notice Address that manages approvals.
IJellyAccessControls public accessControls;
/// @notice Reward token address.
address public poolToken;
address public dropAddress;
/// @notice ve contract for locking tokens.
address public veToken;
/// @notice JellyVault is where fees are sent.
address private jellyVault;
/// @notice The fee percentage out of 10000 (100.00%)
uint256 private feePercentage;
/// @notice Current total rewards paid.
uint256 public rewardsPaid;
/// @notice Total tokens to be distributed.
uint256 public totalTokens;
/// @notice Mapping of User -> amount of tokens locked.
mapping(address => uint256) public rewardsLocked;
uint256 public lockDuration;
uint256 public bonusPercentage;
/// @notice Whether contract has been initialised or not.
bool private initialised;
/**
* @notice Event emitted when reward tokens have been added to the pool.
* @param amount Number of tokens added.
* @param fees Amount of fees.
*/
event RewardsAdded(uint256 amount, uint256 fees);
/**
* @notice Event emitted for Jelly admin updates.
* @param vault Address of the new vault address.
* @param fee New fee percentage.
*/
event JellyUpdated(address vault, uint256 fee);
/**
* @notice Event emitted for when tokens are recovered.
* @param token ERC20 token address.
* @param amount Token amount in wei.
*/
event Recovered(address token, uint256 amount);
//--------------------------------------------------------
// Setters
//--------------------------------------------------------
/// @dev Setter functions for setting lock duration
function setLockDuration(uint256 _lockDuration) external {
}
//--------------------------------------------------------
// Rewards
//--------------------------------------------------------
/// @dev Setter functions for contract config
function setBonusPercentage(uint256 _bonusPercentage) external {
}
/**
* @notice Add more tokens to the JellyDrop contract.
* @param _rewardAmount Amount of tokens to add, in wei. (18 decimal place format)
*/
function addRewards(uint256 _rewardAmount) public {
}
/**
* @notice Jelly vault can update new vault and fee.
* @param _vault New vault address.
* @param _fee Fee percentage of tokens distributed.
*/
function updateJelly(address _vault, uint256 _fee) external {
}
//--------------------------------------------------------
// Bonus
//--------------------------------------------------------
/**
* @notice Claims rewards from airdrop and locked in ve with bonus rewards.
*/
function claimAndLock(bytes32 _merkleRoot, uint256 _index, address _user, uint256 _amount, bytes32[] calldata _data ) external returns (uint) {
require(_user == msg.sender);
uint256 amountBefore = getTokenRewardsClaimed(msg.sender);
IJellyDropWrapper(dropAddress).claim(_merkleRoot, _index, _user, _amount, _data);
uint256 amountAfter = getTokenRewardsClaimed(msg.sender);
uint256 amountClaimed = amountAfter - amountBefore;
rewardsLocked[msg.sender] += amountClaimed;
require(<FILL_ME>)
return _lockAmount(msg.sender, amountClaimed);
}
function lockAmount(uint256 _amount) public returns (uint) {
}
function _lockAmount(address _user, uint256 _amount) internal returns (uint) {
}
function getTokenRewardsClaimed( address _user) public view returns(uint256 rewardsClaimed) {
}
//--------------------------------------------------------
// Admin Reclaim
//--------------------------------------------------------
/**
* @notice Admin can end token distribution and reclaim tokens.
* @notice Also allows for the recovery of incorrect ERC20 tokens sent to contract
* @param _vault Address where the reclaimed tokens will be sent.
*/
function adminReclaimTokens(
address _tokenAddress,
address _vault,
uint256 _tokenAmount
)
external
{
}
//--------------------------------------------------------
// Factory Init
//--------------------------------------------------------
/**
* @notice Initializes main contract variables.
* @dev Init function.
* @param _accessControls Access controls interface.
* @param _dropAddress Address of the airdrop contract.
* @param _veToken Address of the ve contract.
* @param _jellyVault The Jelly vault address.
* @param _jellyFee Fee percentage for added tokens. To 2dp (10000 = 100.00%)
*/
function initVeBonus(
address _accessControls,
address _dropAddress,
address _veToken,
address _jellyVault,
uint256 _jellyFee
) public
{
}
/**
* @dev Used by the Jelly Factory.
*/
function init(bytes calldata _data) external override payable {}
function initContract(
bytes calldata _data
) external override {
}
}
| rewardsLocked[msg.sender]<=amountAfter,"Locking more tokens than has been earnt." | 107,440 | rewardsLocked[msg.sender]<=amountAfter |
"Locking more tokens than has been earnt." | pragma solidity 0.8.6;
import "IJellyContract.sol";
import "IJellyAccessControls.sol";
// import "IERC20.sol";
import "IJellyPool.sol";
import "SafeERC20.sol";
interface IERC721 {
function ownerOf(uint256 tokenId) external view returns (address);
}
interface IVeToken {
function create_lock_for(uint _value, uint _lock_duration, address _to) external returns (uint);
}
struct UserInfo {
uint128 totalAmount;
uint128 rewardsReleased;
}
interface IJellyDropWrapper {
function userRewards( address _user) external view returns (UserInfo memory);
function claim(bytes32 _merkleRoot, uint256 _index, address _user, uint256 _amount, bytes32[] calldata _data ) external;
}
contract DropVeBonus is IJellyContract {
using SafeERC20 for OZIERC20;
/// @notice Jelly template type and id for the factory.
uint256 public constant override TEMPLATE_TYPE = 9;
bytes32 public constant override TEMPLATE_ID = keccak256("DROP_VE_BONUS");
uint256 private constant PERCENTAGE_PRECISION = 10000;
uint256 private constant SECONDS_PER_DAY = 24 * 60 * 60;
uint256 private constant MAX_INT =
0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
uint256 public constant pointMultiplier = 10e12;
/// @notice Address that manages approvals.
IJellyAccessControls public accessControls;
/// @notice Reward token address.
address public poolToken;
address public dropAddress;
/// @notice ve contract for locking tokens.
address public veToken;
/// @notice JellyVault is where fees are sent.
address private jellyVault;
/// @notice The fee percentage out of 10000 (100.00%)
uint256 private feePercentage;
/// @notice Current total rewards paid.
uint256 public rewardsPaid;
/// @notice Total tokens to be distributed.
uint256 public totalTokens;
/// @notice Mapping of User -> amount of tokens locked.
mapping(address => uint256) public rewardsLocked;
uint256 public lockDuration;
uint256 public bonusPercentage;
/// @notice Whether contract has been initialised or not.
bool private initialised;
/**
* @notice Event emitted when reward tokens have been added to the pool.
* @param amount Number of tokens added.
* @param fees Amount of fees.
*/
event RewardsAdded(uint256 amount, uint256 fees);
/**
* @notice Event emitted for Jelly admin updates.
* @param vault Address of the new vault address.
* @param fee New fee percentage.
*/
event JellyUpdated(address vault, uint256 fee);
/**
* @notice Event emitted for when tokens are recovered.
* @param token ERC20 token address.
* @param amount Token amount in wei.
*/
event Recovered(address token, uint256 amount);
//--------------------------------------------------------
// Setters
//--------------------------------------------------------
/// @dev Setter functions for setting lock duration
function setLockDuration(uint256 _lockDuration) external {
}
//--------------------------------------------------------
// Rewards
//--------------------------------------------------------
/// @dev Setter functions for contract config
function setBonusPercentage(uint256 _bonusPercentage) external {
}
/**
* @notice Add more tokens to the JellyDrop contract.
* @param _rewardAmount Amount of tokens to add, in wei. (18 decimal place format)
*/
function addRewards(uint256 _rewardAmount) public {
}
/**
* @notice Jelly vault can update new vault and fee.
* @param _vault New vault address.
* @param _fee Fee percentage of tokens distributed.
*/
function updateJelly(address _vault, uint256 _fee) external {
}
//--------------------------------------------------------
// Bonus
//--------------------------------------------------------
/**
* @notice Claims rewards from airdrop and locked in ve with bonus rewards.
*/
function claimAndLock(bytes32 _merkleRoot, uint256 _index, address _user, uint256 _amount, bytes32[] calldata _data ) external returns (uint) {
}
function lockAmount(uint256 _amount) public returns (uint) {
require(_amount > 0);
uint256 rewardsClaimed = getTokenRewardsClaimed(msg.sender);
rewardsLocked[msg.sender] += _amount;
require(<FILL_ME>)
return _lockAmount(msg.sender, _amount);
}
function _lockAmount(address _user, uint256 _amount) internal returns (uint) {
}
function getTokenRewardsClaimed( address _user) public view returns(uint256 rewardsClaimed) {
}
//--------------------------------------------------------
// Admin Reclaim
//--------------------------------------------------------
/**
* @notice Admin can end token distribution and reclaim tokens.
* @notice Also allows for the recovery of incorrect ERC20 tokens sent to contract
* @param _vault Address where the reclaimed tokens will be sent.
*/
function adminReclaimTokens(
address _tokenAddress,
address _vault,
uint256 _tokenAmount
)
external
{
}
//--------------------------------------------------------
// Factory Init
//--------------------------------------------------------
/**
* @notice Initializes main contract variables.
* @dev Init function.
* @param _accessControls Access controls interface.
* @param _dropAddress Address of the airdrop contract.
* @param _veToken Address of the ve contract.
* @param _jellyVault The Jelly vault address.
* @param _jellyFee Fee percentage for added tokens. To 2dp (10000 = 100.00%)
*/
function initVeBonus(
address _accessControls,
address _dropAddress,
address _veToken,
address _jellyVault,
uint256 _jellyFee
) public
{
}
/**
* @dev Used by the Jelly Factory.
*/
function init(bytes calldata _data) external override payable {}
function initContract(
bytes calldata _data
) external override {
}
}
| rewardsLocked[msg.sender]<=rewardsClaimed,"Locking more tokens than has been earnt." | 107,440 | rewardsLocked[msg.sender]<=rewardsClaimed |
"Already initialised" | pragma solidity 0.8.6;
import "IJellyContract.sol";
import "IJellyAccessControls.sol";
// import "IERC20.sol";
import "IJellyPool.sol";
import "SafeERC20.sol";
interface IERC721 {
function ownerOf(uint256 tokenId) external view returns (address);
}
interface IVeToken {
function create_lock_for(uint _value, uint _lock_duration, address _to) external returns (uint);
}
struct UserInfo {
uint128 totalAmount;
uint128 rewardsReleased;
}
interface IJellyDropWrapper {
function userRewards( address _user) external view returns (UserInfo memory);
function claim(bytes32 _merkleRoot, uint256 _index, address _user, uint256 _amount, bytes32[] calldata _data ) external;
}
contract DropVeBonus is IJellyContract {
using SafeERC20 for OZIERC20;
/// @notice Jelly template type and id for the factory.
uint256 public constant override TEMPLATE_TYPE = 9;
bytes32 public constant override TEMPLATE_ID = keccak256("DROP_VE_BONUS");
uint256 private constant PERCENTAGE_PRECISION = 10000;
uint256 private constant SECONDS_PER_DAY = 24 * 60 * 60;
uint256 private constant MAX_INT =
0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
uint256 public constant pointMultiplier = 10e12;
/// @notice Address that manages approvals.
IJellyAccessControls public accessControls;
/// @notice Reward token address.
address public poolToken;
address public dropAddress;
/// @notice ve contract for locking tokens.
address public veToken;
/// @notice JellyVault is where fees are sent.
address private jellyVault;
/// @notice The fee percentage out of 10000 (100.00%)
uint256 private feePercentage;
/// @notice Current total rewards paid.
uint256 public rewardsPaid;
/// @notice Total tokens to be distributed.
uint256 public totalTokens;
/// @notice Mapping of User -> amount of tokens locked.
mapping(address => uint256) public rewardsLocked;
uint256 public lockDuration;
uint256 public bonusPercentage;
/// @notice Whether contract has been initialised or not.
bool private initialised;
/**
* @notice Event emitted when reward tokens have been added to the pool.
* @param amount Number of tokens added.
* @param fees Amount of fees.
*/
event RewardsAdded(uint256 amount, uint256 fees);
/**
* @notice Event emitted for Jelly admin updates.
* @param vault Address of the new vault address.
* @param fee New fee percentage.
*/
event JellyUpdated(address vault, uint256 fee);
/**
* @notice Event emitted for when tokens are recovered.
* @param token ERC20 token address.
* @param amount Token amount in wei.
*/
event Recovered(address token, uint256 amount);
//--------------------------------------------------------
// Setters
//--------------------------------------------------------
/// @dev Setter functions for setting lock duration
function setLockDuration(uint256 _lockDuration) external {
}
//--------------------------------------------------------
// Rewards
//--------------------------------------------------------
/// @dev Setter functions for contract config
function setBonusPercentage(uint256 _bonusPercentage) external {
}
/**
* @notice Add more tokens to the JellyDrop contract.
* @param _rewardAmount Amount of tokens to add, in wei. (18 decimal place format)
*/
function addRewards(uint256 _rewardAmount) public {
}
/**
* @notice Jelly vault can update new vault and fee.
* @param _vault New vault address.
* @param _fee Fee percentage of tokens distributed.
*/
function updateJelly(address _vault, uint256 _fee) external {
}
//--------------------------------------------------------
// Bonus
//--------------------------------------------------------
/**
* @notice Claims rewards from airdrop and locked in ve with bonus rewards.
*/
function claimAndLock(bytes32 _merkleRoot, uint256 _index, address _user, uint256 _amount, bytes32[] calldata _data ) external returns (uint) {
}
function lockAmount(uint256 _amount) public returns (uint) {
}
function _lockAmount(address _user, uint256 _amount) internal returns (uint) {
}
function getTokenRewardsClaimed( address _user) public view returns(uint256 rewardsClaimed) {
}
//--------------------------------------------------------
// Admin Reclaim
//--------------------------------------------------------
/**
* @notice Admin can end token distribution and reclaim tokens.
* @notice Also allows for the recovery of incorrect ERC20 tokens sent to contract
* @param _vault Address where the reclaimed tokens will be sent.
*/
function adminReclaimTokens(
address _tokenAddress,
address _vault,
uint256 _tokenAmount
)
external
{
}
//--------------------------------------------------------
// Factory Init
//--------------------------------------------------------
/**
* @notice Initializes main contract variables.
* @dev Init function.
* @param _accessControls Access controls interface.
* @param _dropAddress Address of the airdrop contract.
* @param _veToken Address of the ve contract.
* @param _jellyVault The Jelly vault address.
* @param _jellyFee Fee percentage for added tokens. To 2dp (10000 = 100.00%)
*/
function initVeBonus(
address _accessControls,
address _dropAddress,
address _veToken,
address _jellyVault,
uint256 _jellyFee
) public
{
require(<FILL_ME>)
require(_accessControls != address(0), "Access controls not set");
require(_dropAddress != address(0), "Drop address not set");
require(_jellyVault != address(0), "jellyVault not set");
require(_veToken != address(0), "veToken not set");
require(_jellyFee < PERCENTAGE_PRECISION , "feePercentage greater than 10000 (100.00%)");
dropAddress = _dropAddress;
veToken = _veToken;
poolToken = IJellyPool(_veToken).poolToken();
require(poolToken != address(0), "poolToken not set in JellyPool");
// PW: Check that the reward token is what is staked in veToken
// Or not, maybe the reward tokens can be different
OZIERC20(poolToken).safeApprove(_veToken, 0);
OZIERC20(poolToken).safeApprove(_veToken, MAX_INT);
accessControls = IJellyAccessControls(_accessControls);
jellyVault = _jellyVault;
feePercentage = _jellyFee;
lockDuration = 60*60*24*365;
initialised = true;
}
/**
* @dev Used by the Jelly Factory.
*/
function init(bytes calldata _data) external override payable {}
function initContract(
bytes calldata _data
) external override {
}
}
| !initialised,"Already initialised" | 107,440 | !initialised |
"Lock up not over yet" | pragma solidity ^0.5.0;
contract LPTokenWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public comp = IERC20(0x27FDD68095711c6889A42dC32c305eC927192657);
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function stake(uint256 amount) public {
}
function withdraw(uint256 amount) public {
}
}
contract YFarmLandRewards is LPTokenWrapper, IRewardDistributionRecipient {
IERC20 public yfarmer = IERC20(0x7B0F66fA5cf5cc28280c1e7051af881E06579362); //change this
uint256 public constant DURATION = 7 days;
uint256 public constant lockup = 14 days;
uint256 public constant lockupRewards = 24 hours;
uint256 public initreward = 1800*1e18;
uint256 public starttime = 1600135200; //9th of september 2020 9am est
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
mapping(address => uint256) public lasttimestaked;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier updateReward(address account) {
}
function checkWithdrawal(address account) view public returns (bool) {
}
function checkClaimRewards() view public returns (bool) {
}
function lastTimeRewardApplicable() public view returns (uint256) {
}
function rewardPerToken() public view returns (uint256) {
}
function earned(address account) public view returns (uint256) {
}
function stake(uint256 amount) public updateReward(msg.sender) checkhalve checkStart{
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkhalve checkStart{
require(amount > 0, "Cannot withdraw 0");
require(<FILL_ME>)
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
}
function getReward() public updateReward(msg.sender) checkhalve checkStart{
}
modifier checkhalve(){
}
modifier checkStart(){
}
function notifyRewardAmount(uint256 reward)
external
onlyRewardDistribution
updateReward(address(0))
{
}
}
| checkWithdrawal(msg.sender),"Lock up not over yet" | 107,471 | checkWithdrawal(msg.sender) |
"Lock up not over yet" | pragma solidity ^0.5.0;
contract LPTokenWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public comp = IERC20(0x27FDD68095711c6889A42dC32c305eC927192657);
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function stake(uint256 amount) public {
}
function withdraw(uint256 amount) public {
}
}
contract YFarmLandRewards is LPTokenWrapper, IRewardDistributionRecipient {
IERC20 public yfarmer = IERC20(0x7B0F66fA5cf5cc28280c1e7051af881E06579362); //change this
uint256 public constant DURATION = 7 days;
uint256 public constant lockup = 14 days;
uint256 public constant lockupRewards = 24 hours;
uint256 public initreward = 1800*1e18;
uint256 public starttime = 1600135200; //9th of september 2020 9am est
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
mapping(address => uint256) public lasttimestaked;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier updateReward(address account) {
}
function checkWithdrawal(address account) view public returns (bool) {
}
function checkClaimRewards() view public returns (bool) {
}
function lastTimeRewardApplicable() public view returns (uint256) {
}
function rewardPerToken() public view returns (uint256) {
}
function earned(address account) public view returns (uint256) {
}
function stake(uint256 amount) public updateReward(msg.sender) checkhalve checkStart{
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkhalve checkStart{
}
function exit() external {
}
function getReward() public updateReward(msg.sender) checkhalve checkStart{
require(<FILL_ME>)
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
yfarmer.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
modifier checkhalve(){
}
modifier checkStart(){
}
function notifyRewardAmount(uint256 reward)
external
onlyRewardDistribution
updateReward(address(0))
{
}
}
| checkClaimRewards(),"Lock up not over yet" | 107,471 | checkClaimRewards() |
"Not authorized" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
abstract contract MintPass {
function balanceOf(address owner, uint256 id)
public
view
virtual
returns (uint256 balance);
function burnForAddress(
uint256 _id,
uint256 _quantity,
address _address
) public virtual;
}
contract PandaCubz is ERC721A, Ownable, PaymentSplitter, ReentrancyGuard {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint16 maxPerWallet;
uint16 maxPerTransaction;
uint72 preSalePrice;
uint72 pubSalePrice;
bool preSaleIsActive;
bool saleIsActive;
bool claimIsActive;
bool supplyLock;
uint8 salePhase;
}
mapping(address => bool) public fiatAllowlist;
mapping(address => uint16) public hasMinted;
mapping(address => uint16) public hasClaimed;
bytes32 public saleMerkleRoot;
bytes32 public claimMerkleRoot;
Token public token;
string private baseURI;
uint16 public mintpassId;
address public mintpassAddress;
MintPass mintpass;
modifier onlyFiatMinter() {
require(<FILL_ME>)
_;
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner,
Token memory _token
) ERC721A(_name, _symbol)
PaymentSplitter(_payees, _shares) {
}
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
function getClaimIneligibilityReason(address _address, uint256 _quantity) public view returns (string memory) {
}
function unclaimedSupply() public view returns (uint256) {
}
function price() public view returns (uint256) {
}
function addFiatMinter(address _address) public onlyOwner {
}
function removeFiatMinter(address _address) public onlyOwner {
}
function setMintPass(uint16 _id, address _address) external onlyOwner {
}
function setSaleRoot(bytes32 _root) public onlyOwner {
}
function setClaimRoot(bytes32 _root) public onlyOwner {
}
function lockSupply() public onlyOwner {
}
function updateConfig(
uint16 _maxSupply,
uint16 _maxPerWallet,
uint16 _maxPerTransaction,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function setBaseTokenURI(string memory _uri) public onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _saleIsActive,
bool _claimIsActive,
uint8 _salePhase
) public onlyOwner {
}
function mint(uint16 _quantity, bytes32[] memory _proof) public payable nonReentrant {
}
function claimTo(address _address, uint256 _quantity) public payable nonReentrant onlyFiatMinter {
}
function claimFree(uint16 _maxMint, uint16 _quantity, bytes32[] memory _proof) public {
}
function reserve(address _address, uint16 _quantity) public nonReentrant onlyOwner {
}
}
| fiatAllowlist[msg.sender],"Not authorized" | 107,493 | fiatAllowlist[msg.sender] |
"Root undefined" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
abstract contract MintPass {
function balanceOf(address owner, uint256 id)
public
view
virtual
returns (uint256 balance);
function burnForAddress(
uint256 _id,
uint256 _quantity,
address _address
) public virtual;
}
contract PandaCubz is ERC721A, Ownable, PaymentSplitter, ReentrancyGuard {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint16 maxPerWallet;
uint16 maxPerTransaction;
uint72 preSalePrice;
uint72 pubSalePrice;
bool preSaleIsActive;
bool saleIsActive;
bool claimIsActive;
bool supplyLock;
uint8 salePhase;
}
mapping(address => bool) public fiatAllowlist;
mapping(address => uint16) public hasMinted;
mapping(address => uint16) public hasClaimed;
bytes32 public saleMerkleRoot;
bytes32 public claimMerkleRoot;
Token public token;
string private baseURI;
uint16 public mintpassId;
address public mintpassAddress;
MintPass mintpass;
modifier onlyFiatMinter() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner,
Token memory _token
) ERC721A(_name, _symbol)
PaymentSplitter(_payees, _shares) {
}
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
function getClaimIneligibilityReason(address _address, uint256 _quantity) public view returns (string memory) {
}
function unclaimedSupply() public view returns (uint256) {
}
function price() public view returns (uint256) {
}
function addFiatMinter(address _address) public onlyOwner {
}
function removeFiatMinter(address _address) public onlyOwner {
}
function setMintPass(uint16 _id, address _address) external onlyOwner {
}
function setSaleRoot(bytes32 _root) public onlyOwner {
}
function setClaimRoot(bytes32 _root) public onlyOwner {
}
function lockSupply() public onlyOwner {
}
function updateConfig(
uint16 _maxSupply,
uint16 _maxPerWallet,
uint16 _maxPerTransaction,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function setBaseTokenURI(string memory _uri) public onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _saleIsActive,
bool _claimIsActive,
uint8 _salePhase
) public onlyOwner {
// public = 0, mintpass = 1, whitelist = 2
require(_salePhase == 0 || _salePhase == 1 || _salePhase == 2, "Invalid phase.");
if (_preSaleIsActive && _salePhase == 1) require(mintpassAddress != address(0), "MintPass undefined.");
if (_preSaleIsActive && _salePhase == 2) require(<FILL_ME>)
if (_claimIsActive) require(claimMerkleRoot != "", "Root undefined");
token.preSaleIsActive = _preSaleIsActive;
token.saleIsActive = _saleIsActive;
token.claimIsActive = _claimIsActive;
token.salePhase = _salePhase;
}
function mint(uint16 _quantity, bytes32[] memory _proof) public payable nonReentrant {
}
function claimTo(address _address, uint256 _quantity) public payable nonReentrant onlyFiatMinter {
}
function claimFree(uint16 _maxMint, uint16 _quantity, bytes32[] memory _proof) public {
}
function reserve(address _address, uint16 _quantity) public nonReentrant onlyOwner {
}
}
| saleMerkleRoot!="","Root undefined" | 107,493 | saleMerkleRoot!="" |
"Insufficient supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
abstract contract MintPass {
function balanceOf(address owner, uint256 id)
public
view
virtual
returns (uint256 balance);
function burnForAddress(
uint256 _id,
uint256 _quantity,
address _address
) public virtual;
}
contract PandaCubz is ERC721A, Ownable, PaymentSplitter, ReentrancyGuard {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint16 maxPerWallet;
uint16 maxPerTransaction;
uint72 preSalePrice;
uint72 pubSalePrice;
bool preSaleIsActive;
bool saleIsActive;
bool claimIsActive;
bool supplyLock;
uint8 salePhase;
}
mapping(address => bool) public fiatAllowlist;
mapping(address => uint16) public hasMinted;
mapping(address => uint16) public hasClaimed;
bytes32 public saleMerkleRoot;
bytes32 public claimMerkleRoot;
Token public token;
string private baseURI;
uint16 public mintpassId;
address public mintpassAddress;
MintPass mintpass;
modifier onlyFiatMinter() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner,
Token memory _token
) ERC721A(_name, _symbol)
PaymentSplitter(_payees, _shares) {
}
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
function getClaimIneligibilityReason(address _address, uint256 _quantity) public view returns (string memory) {
}
function unclaimedSupply() public view returns (uint256) {
}
function price() public view returns (uint256) {
}
function addFiatMinter(address _address) public onlyOwner {
}
function removeFiatMinter(address _address) public onlyOwner {
}
function setMintPass(uint16 _id, address _address) external onlyOwner {
}
function setSaleRoot(bytes32 _root) public onlyOwner {
}
function setClaimRoot(bytes32 _root) public onlyOwner {
}
function lockSupply() public onlyOwner {
}
function updateConfig(
uint16 _maxSupply,
uint16 _maxPerWallet,
uint16 _maxPerTransaction,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function setBaseTokenURI(string memory _uri) public onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _saleIsActive,
bool _claimIsActive,
uint8 _salePhase
) public onlyOwner {
}
function mint(uint16 _quantity, bytes32[] memory _proof) public payable nonReentrant {
uint16 _maxSupply = token.maxSupply;
uint16 _maxPerWallet = token.maxPerWallet;
uint16 _maxPerTransaction = token.maxPerTransaction;
bool _saleIsActive = token.saleIsActive;
bool _preSaleIsActive = token.preSaleIsActive;
require(<FILL_ME>)
require(_saleIsActive, "Sale inactive");
if(_preSaleIsActive) {
require(token.preSalePrice * _quantity <= msg.value, "ETH incorrect");
if (token.salePhase == 1) {
require(mintpass.balanceOf(msg.sender, mintpassId) >= _quantity, "Invalid quantity");
mintpass.burnForAddress(mintpassId, _quantity, msg.sender);
}
if (token.salePhase == 2) {
uint16 mintedAmount = hasMinted[msg.sender] + _quantity;
require(mintedAmount <= _maxPerWallet, "Invalid quantity");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_proof, saleMerkleRoot, leaf), "Not whitelisted");
hasMinted[msg.sender] = mintedAmount;
}
} else {
require(price() * _quantity <= msg.value, "ETH incorrect");
require(_quantity <= _maxPerTransaction, "Invalid quantity");
}
_safeMint(msg.sender, _quantity);
}
function claimTo(address _address, uint256 _quantity) public payable nonReentrant onlyFiatMinter {
}
function claimFree(uint16 _maxMint, uint16 _quantity, bytes32[] memory _proof) public {
}
function reserve(address _address, uint16 _quantity) public nonReentrant onlyOwner {
}
}
| uint16(totalSupply())+_quantity<=_maxSupply,"Insufficient supply" | 107,493 | uint16(totalSupply())+_quantity<=_maxSupply |
"ETH incorrect" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
abstract contract MintPass {
function balanceOf(address owner, uint256 id)
public
view
virtual
returns (uint256 balance);
function burnForAddress(
uint256 _id,
uint256 _quantity,
address _address
) public virtual;
}
contract PandaCubz is ERC721A, Ownable, PaymentSplitter, ReentrancyGuard {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint16 maxPerWallet;
uint16 maxPerTransaction;
uint72 preSalePrice;
uint72 pubSalePrice;
bool preSaleIsActive;
bool saleIsActive;
bool claimIsActive;
bool supplyLock;
uint8 salePhase;
}
mapping(address => bool) public fiatAllowlist;
mapping(address => uint16) public hasMinted;
mapping(address => uint16) public hasClaimed;
bytes32 public saleMerkleRoot;
bytes32 public claimMerkleRoot;
Token public token;
string private baseURI;
uint16 public mintpassId;
address public mintpassAddress;
MintPass mintpass;
modifier onlyFiatMinter() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner,
Token memory _token
) ERC721A(_name, _symbol)
PaymentSplitter(_payees, _shares) {
}
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
function getClaimIneligibilityReason(address _address, uint256 _quantity) public view returns (string memory) {
}
function unclaimedSupply() public view returns (uint256) {
}
function price() public view returns (uint256) {
}
function addFiatMinter(address _address) public onlyOwner {
}
function removeFiatMinter(address _address) public onlyOwner {
}
function setMintPass(uint16 _id, address _address) external onlyOwner {
}
function setSaleRoot(bytes32 _root) public onlyOwner {
}
function setClaimRoot(bytes32 _root) public onlyOwner {
}
function lockSupply() public onlyOwner {
}
function updateConfig(
uint16 _maxSupply,
uint16 _maxPerWallet,
uint16 _maxPerTransaction,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function setBaseTokenURI(string memory _uri) public onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _saleIsActive,
bool _claimIsActive,
uint8 _salePhase
) public onlyOwner {
}
function mint(uint16 _quantity, bytes32[] memory _proof) public payable nonReentrant {
uint16 _maxSupply = token.maxSupply;
uint16 _maxPerWallet = token.maxPerWallet;
uint16 _maxPerTransaction = token.maxPerTransaction;
bool _saleIsActive = token.saleIsActive;
bool _preSaleIsActive = token.preSaleIsActive;
require(uint16(totalSupply()) + _quantity <= _maxSupply, "Insufficient supply");
require(_saleIsActive, "Sale inactive");
if(_preSaleIsActive) {
require(<FILL_ME>)
if (token.salePhase == 1) {
require(mintpass.balanceOf(msg.sender, mintpassId) >= _quantity, "Invalid quantity");
mintpass.burnForAddress(mintpassId, _quantity, msg.sender);
}
if (token.salePhase == 2) {
uint16 mintedAmount = hasMinted[msg.sender] + _quantity;
require(mintedAmount <= _maxPerWallet, "Invalid quantity");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_proof, saleMerkleRoot, leaf), "Not whitelisted");
hasMinted[msg.sender] = mintedAmount;
}
} else {
require(price() * _quantity <= msg.value, "ETH incorrect");
require(_quantity <= _maxPerTransaction, "Invalid quantity");
}
_safeMint(msg.sender, _quantity);
}
function claimTo(address _address, uint256 _quantity) public payable nonReentrant onlyFiatMinter {
}
function claimFree(uint16 _maxMint, uint16 _quantity, bytes32[] memory _proof) public {
}
function reserve(address _address, uint16 _quantity) public nonReentrant onlyOwner {
}
}
| token.preSalePrice*_quantity<=msg.value,"ETH incorrect" | 107,493 | token.preSalePrice*_quantity<=msg.value |
"Invalid quantity" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
abstract contract MintPass {
function balanceOf(address owner, uint256 id)
public
view
virtual
returns (uint256 balance);
function burnForAddress(
uint256 _id,
uint256 _quantity,
address _address
) public virtual;
}
contract PandaCubz is ERC721A, Ownable, PaymentSplitter, ReentrancyGuard {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint16 maxPerWallet;
uint16 maxPerTransaction;
uint72 preSalePrice;
uint72 pubSalePrice;
bool preSaleIsActive;
bool saleIsActive;
bool claimIsActive;
bool supplyLock;
uint8 salePhase;
}
mapping(address => bool) public fiatAllowlist;
mapping(address => uint16) public hasMinted;
mapping(address => uint16) public hasClaimed;
bytes32 public saleMerkleRoot;
bytes32 public claimMerkleRoot;
Token public token;
string private baseURI;
uint16 public mintpassId;
address public mintpassAddress;
MintPass mintpass;
modifier onlyFiatMinter() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner,
Token memory _token
) ERC721A(_name, _symbol)
PaymentSplitter(_payees, _shares) {
}
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
function getClaimIneligibilityReason(address _address, uint256 _quantity) public view returns (string memory) {
}
function unclaimedSupply() public view returns (uint256) {
}
function price() public view returns (uint256) {
}
function addFiatMinter(address _address) public onlyOwner {
}
function removeFiatMinter(address _address) public onlyOwner {
}
function setMintPass(uint16 _id, address _address) external onlyOwner {
}
function setSaleRoot(bytes32 _root) public onlyOwner {
}
function setClaimRoot(bytes32 _root) public onlyOwner {
}
function lockSupply() public onlyOwner {
}
function updateConfig(
uint16 _maxSupply,
uint16 _maxPerWallet,
uint16 _maxPerTransaction,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function setBaseTokenURI(string memory _uri) public onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _saleIsActive,
bool _claimIsActive,
uint8 _salePhase
) public onlyOwner {
}
function mint(uint16 _quantity, bytes32[] memory _proof) public payable nonReentrant {
uint16 _maxSupply = token.maxSupply;
uint16 _maxPerWallet = token.maxPerWallet;
uint16 _maxPerTransaction = token.maxPerTransaction;
bool _saleIsActive = token.saleIsActive;
bool _preSaleIsActive = token.preSaleIsActive;
require(uint16(totalSupply()) + _quantity <= _maxSupply, "Insufficient supply");
require(_saleIsActive, "Sale inactive");
if(_preSaleIsActive) {
require(token.preSalePrice * _quantity <= msg.value, "ETH incorrect");
if (token.salePhase == 1) {
require(<FILL_ME>)
mintpass.burnForAddress(mintpassId, _quantity, msg.sender);
}
if (token.salePhase == 2) {
uint16 mintedAmount = hasMinted[msg.sender] + _quantity;
require(mintedAmount <= _maxPerWallet, "Invalid quantity");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_proof, saleMerkleRoot, leaf), "Not whitelisted");
hasMinted[msg.sender] = mintedAmount;
}
} else {
require(price() * _quantity <= msg.value, "ETH incorrect");
require(_quantity <= _maxPerTransaction, "Invalid quantity");
}
_safeMint(msg.sender, _quantity);
}
function claimTo(address _address, uint256 _quantity) public payable nonReentrant onlyFiatMinter {
}
function claimFree(uint16 _maxMint, uint16 _quantity, bytes32[] memory _proof) public {
}
function reserve(address _address, uint16 _quantity) public nonReentrant onlyOwner {
}
}
| mintpass.balanceOf(msg.sender,mintpassId)>=_quantity,"Invalid quantity" | 107,493 | mintpass.balanceOf(msg.sender,mintpassId)>=_quantity |
"Not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
abstract contract MintPass {
function balanceOf(address owner, uint256 id)
public
view
virtual
returns (uint256 balance);
function burnForAddress(
uint256 _id,
uint256 _quantity,
address _address
) public virtual;
}
contract PandaCubz is ERC721A, Ownable, PaymentSplitter, ReentrancyGuard {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint16 maxPerWallet;
uint16 maxPerTransaction;
uint72 preSalePrice;
uint72 pubSalePrice;
bool preSaleIsActive;
bool saleIsActive;
bool claimIsActive;
bool supplyLock;
uint8 salePhase;
}
mapping(address => bool) public fiatAllowlist;
mapping(address => uint16) public hasMinted;
mapping(address => uint16) public hasClaimed;
bytes32 public saleMerkleRoot;
bytes32 public claimMerkleRoot;
Token public token;
string private baseURI;
uint16 public mintpassId;
address public mintpassAddress;
MintPass mintpass;
modifier onlyFiatMinter() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner,
Token memory _token
) ERC721A(_name, _symbol)
PaymentSplitter(_payees, _shares) {
}
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
function getClaimIneligibilityReason(address _address, uint256 _quantity) public view returns (string memory) {
}
function unclaimedSupply() public view returns (uint256) {
}
function price() public view returns (uint256) {
}
function addFiatMinter(address _address) public onlyOwner {
}
function removeFiatMinter(address _address) public onlyOwner {
}
function setMintPass(uint16 _id, address _address) external onlyOwner {
}
function setSaleRoot(bytes32 _root) public onlyOwner {
}
function setClaimRoot(bytes32 _root) public onlyOwner {
}
function lockSupply() public onlyOwner {
}
function updateConfig(
uint16 _maxSupply,
uint16 _maxPerWallet,
uint16 _maxPerTransaction,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function setBaseTokenURI(string memory _uri) public onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _saleIsActive,
bool _claimIsActive,
uint8 _salePhase
) public onlyOwner {
}
function mint(uint16 _quantity, bytes32[] memory _proof) public payable nonReentrant {
uint16 _maxSupply = token.maxSupply;
uint16 _maxPerWallet = token.maxPerWallet;
uint16 _maxPerTransaction = token.maxPerTransaction;
bool _saleIsActive = token.saleIsActive;
bool _preSaleIsActive = token.preSaleIsActive;
require(uint16(totalSupply()) + _quantity <= _maxSupply, "Insufficient supply");
require(_saleIsActive, "Sale inactive");
if(_preSaleIsActive) {
require(token.preSalePrice * _quantity <= msg.value, "ETH incorrect");
if (token.salePhase == 1) {
require(mintpass.balanceOf(msg.sender, mintpassId) >= _quantity, "Invalid quantity");
mintpass.burnForAddress(mintpassId, _quantity, msg.sender);
}
if (token.salePhase == 2) {
uint16 mintedAmount = hasMinted[msg.sender] + _quantity;
require(mintedAmount <= _maxPerWallet, "Invalid quantity");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
hasMinted[msg.sender] = mintedAmount;
}
} else {
require(price() * _quantity <= msg.value, "ETH incorrect");
require(_quantity <= _maxPerTransaction, "Invalid quantity");
}
_safeMint(msg.sender, _quantity);
}
function claimTo(address _address, uint256 _quantity) public payable nonReentrant onlyFiatMinter {
}
function claimFree(uint16 _maxMint, uint16 _quantity, bytes32[] memory _proof) public {
}
function reserve(address _address, uint16 _quantity) public nonReentrant onlyOwner {
}
}
| MerkleProof.verify(_proof,saleMerkleRoot,leaf),"Not whitelisted" | 107,493 | MerkleProof.verify(_proof,saleMerkleRoot,leaf) |
"ETH incorrect" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
abstract contract MintPass {
function balanceOf(address owner, uint256 id)
public
view
virtual
returns (uint256 balance);
function burnForAddress(
uint256 _id,
uint256 _quantity,
address _address
) public virtual;
}
contract PandaCubz is ERC721A, Ownable, PaymentSplitter, ReentrancyGuard {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint16 maxPerWallet;
uint16 maxPerTransaction;
uint72 preSalePrice;
uint72 pubSalePrice;
bool preSaleIsActive;
bool saleIsActive;
bool claimIsActive;
bool supplyLock;
uint8 salePhase;
}
mapping(address => bool) public fiatAllowlist;
mapping(address => uint16) public hasMinted;
mapping(address => uint16) public hasClaimed;
bytes32 public saleMerkleRoot;
bytes32 public claimMerkleRoot;
Token public token;
string private baseURI;
uint16 public mintpassId;
address public mintpassAddress;
MintPass mintpass;
modifier onlyFiatMinter() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner,
Token memory _token
) ERC721A(_name, _symbol)
PaymentSplitter(_payees, _shares) {
}
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
function getClaimIneligibilityReason(address _address, uint256 _quantity) public view returns (string memory) {
}
function unclaimedSupply() public view returns (uint256) {
}
function price() public view returns (uint256) {
}
function addFiatMinter(address _address) public onlyOwner {
}
function removeFiatMinter(address _address) public onlyOwner {
}
function setMintPass(uint16 _id, address _address) external onlyOwner {
}
function setSaleRoot(bytes32 _root) public onlyOwner {
}
function setClaimRoot(bytes32 _root) public onlyOwner {
}
function lockSupply() public onlyOwner {
}
function updateConfig(
uint16 _maxSupply,
uint16 _maxPerWallet,
uint16 _maxPerTransaction,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function setBaseTokenURI(string memory _uri) public onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _saleIsActive,
bool _claimIsActive,
uint8 _salePhase
) public onlyOwner {
}
function mint(uint16 _quantity, bytes32[] memory _proof) public payable nonReentrant {
uint16 _maxSupply = token.maxSupply;
uint16 _maxPerWallet = token.maxPerWallet;
uint16 _maxPerTransaction = token.maxPerTransaction;
bool _saleIsActive = token.saleIsActive;
bool _preSaleIsActive = token.preSaleIsActive;
require(uint16(totalSupply()) + _quantity <= _maxSupply, "Insufficient supply");
require(_saleIsActive, "Sale inactive");
if(_preSaleIsActive) {
require(token.preSalePrice * _quantity <= msg.value, "ETH incorrect");
if (token.salePhase == 1) {
require(mintpass.balanceOf(msg.sender, mintpassId) >= _quantity, "Invalid quantity");
mintpass.burnForAddress(mintpassId, _quantity, msg.sender);
}
if (token.salePhase == 2) {
uint16 mintedAmount = hasMinted[msg.sender] + _quantity;
require(mintedAmount <= _maxPerWallet, "Invalid quantity");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_proof, saleMerkleRoot, leaf), "Not whitelisted");
hasMinted[msg.sender] = mintedAmount;
}
} else {
require(<FILL_ME>)
require(_quantity <= _maxPerTransaction, "Invalid quantity");
}
_safeMint(msg.sender, _quantity);
}
function claimTo(address _address, uint256 _quantity) public payable nonReentrant onlyFiatMinter {
}
function claimFree(uint16 _maxMint, uint16 _quantity, bytes32[] memory _proof) public {
}
function reserve(address _address, uint16 _quantity) public nonReentrant onlyOwner {
}
}
| price()*_quantity<=msg.value,"ETH incorrect" | 107,493 | price()*_quantity<=msg.value |
"Sale is not active." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
abstract contract MintPass {
function balanceOf(address owner, uint256 id)
public
view
virtual
returns (uint256 balance);
function burnForAddress(
uint256 _id,
uint256 _quantity,
address _address
) public virtual;
}
contract PandaCubz is ERC721A, Ownable, PaymentSplitter, ReentrancyGuard {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint16 maxPerWallet;
uint16 maxPerTransaction;
uint72 preSalePrice;
uint72 pubSalePrice;
bool preSaleIsActive;
bool saleIsActive;
bool claimIsActive;
bool supplyLock;
uint8 salePhase;
}
mapping(address => bool) public fiatAllowlist;
mapping(address => uint16) public hasMinted;
mapping(address => uint16) public hasClaimed;
bytes32 public saleMerkleRoot;
bytes32 public claimMerkleRoot;
Token public token;
string private baseURI;
uint16 public mintpassId;
address public mintpassAddress;
MintPass mintpass;
modifier onlyFiatMinter() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner,
Token memory _token
) ERC721A(_name, _symbol)
PaymentSplitter(_payees, _shares) {
}
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
function getClaimIneligibilityReason(address _address, uint256 _quantity) public view returns (string memory) {
}
function unclaimedSupply() public view returns (uint256) {
}
function price() public view returns (uint256) {
}
function addFiatMinter(address _address) public onlyOwner {
}
function removeFiatMinter(address _address) public onlyOwner {
}
function setMintPass(uint16 _id, address _address) external onlyOwner {
}
function setSaleRoot(bytes32 _root) public onlyOwner {
}
function setClaimRoot(bytes32 _root) public onlyOwner {
}
function lockSupply() public onlyOwner {
}
function updateConfig(
uint16 _maxSupply,
uint16 _maxPerWallet,
uint16 _maxPerTransaction,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function setBaseTokenURI(string memory _uri) public onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _saleIsActive,
bool _claimIsActive,
uint8 _salePhase
) public onlyOwner {
}
function mint(uint16 _quantity, bytes32[] memory _proof) public payable nonReentrant {
}
function claimTo(address _address, uint256 _quantity) public payable nonReentrant onlyFiatMinter {
require(<FILL_ME>)
require(totalSupply() + _quantity <= uint256(token.maxSupply), "Insufficient supply");
require(price() * _quantity <= msg.value, "ETH incorrect");
_safeMint(_address, _quantity);
}
function claimFree(uint16 _maxMint, uint16 _quantity, bytes32[] memory _proof) public {
}
function reserve(address _address, uint16 _quantity) public nonReentrant onlyOwner {
}
}
| token.saleIsActive,"Sale is not active." | 107,493 | token.saleIsActive |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.