comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Wallet not whitelisted" | //WalletTaggr V1 - A part of the 0xJOAT Ecosystem
//0xJOAT-HQ - https://www.0xJOAT.com
//WalletTaggr - https://www.WalletTaggr.com
//Learn more in the '0xJOAT's House' Discord server - Link available at 0xJOAT-HQ
//In loving memory of Arnie
//SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
contract WalletTaggr is ERC721, Ownable {
uint256 public mintPrice; // Price to mint 1 WalletTag
uint256 public promoPrice;// Promo price to mint 1 WalletTag
uint256 public totalSupply; // Current total supply
bytes32 public merkleRoot; // Encoded free claim list
bool public isMintActive; // Variable used to pause mint
address payable public devWallet; // 0xJOAT's secure wallet (specifically for this contract)
mapping(uint256 => string) public tokenIdToMessage; // Token message mapping (storage)
mapping(uint256 => string) public tokenIdToType; // Token type mapping (storage)
mapping(uint256 => bool) public canTransfer; // Token canTransfer mapping (storage)
mapping(address => bool) public admins; // Admin for approving transfers mapping (storage)
mapping(address => bool) public claimed; // Tracks whether the wallet has already claimed it's promo mint
constructor() payable ERC721("WalletTaggr", "WT") {
}
//Modifier to ensure mint functions cant be abused by external contracts
modifier callerIsUser() {
}
//Mint pause function - Only to be triggered with the consent of the WalletTaggr community - most likely in the event of WalletTaggr V2.
function setIsMintActive(bool isMintActive_) external onlyOwner {
}
//Function to update the allowlist in order to run continuing collabs, promotions and competitions
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
//Regular mint function
function mint(address destination_, string memory type_, string memory complaint_) external payable callerIsUser {
}
//Promo claim function - checks for presence in merkle tree before authorising reduced price
function claim(address destination_, string memory type_, string memory complaint_, bytes32[] calldata _merkleProof) external payable callerIsUser {
require(isMintActive, "Minting not enabled!");
require(msg.value == promoPrice, "Wrong mint value!");
require(claimed[msg.sender] == false , "You have already claimed!");
bytes32 node = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
uint256 newTokenId = totalSupply + 1;
totalSupply++;
tokenIdToMessage[newTokenId] = complaint_;
tokenIdToType[newTokenId] = type_;
_safeMint(destination_, newTokenId);
claimed[msg.sender] = true;
}
//Function to build the NFT's image in accordance with metadata standards
function tokenURI(uint256 tokenId_) public view override returns (string memory) {
}
//Checks the message stored on the WalletTag from the id
function getMessage (uint256 tokenId_) public view returns (string memory) {
}
//Checks the type of WalletTag from the id
function getType (uint256 tokenId_) public view returns (string memory) {
}
//Function to togle admin status (enables scaling once there are too many reviews to be handled by 0xJOAT alone)
function setIsAdmin (address adminAddress, bool value_) external onlyOwner {
}
//Function to reset claimed status (only if a wallet is eligible for it)
function setClaimed (address address_, bool hasClaimed_) external onlyOwner {
}
//Set whether a token can be transferred (pending a review by 0xJOAT)
function setCanTransfer (uint256 tokenId_, bool canTransfer_) external {
}
//Check if token is eligible to be burned
function getCanTransfer (uint256 tokenId_) public view returns (bool) {
}
//Check if wallet has already claimed a promo mint
function isClaimed (address walletId_) public view returns (bool) {
}
// 3x Transfer function overrides
// Ensures any authorised disposals can only be burned
function safeTransferFrom (address from, address to, uint256 tokenId, bytes memory data) public virtual override {
}
function safeTransferFrom (address from, address to, uint256 tokenId) public virtual override {
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
}
// Withdraw function to collect mint fees
function withdraw() external onlyOwner {
}
}
| MerkleProof.verifyCalldata(_merkleProof,merkleRoot,node),"Wallet not whitelisted" | 164,355 | MerkleProof.verifyCalldata(_merkleProof,merkleRoot,node) |
"Steady-on, you cant transfer this! More info: https://youtu.be/dQw4w9WgXcQ" | //WalletTaggr V1 - A part of the 0xJOAT Ecosystem
//0xJOAT-HQ - https://www.0xJOAT.com
//WalletTaggr - https://www.WalletTaggr.com
//Learn more in the '0xJOAT's House' Discord server - Link available at 0xJOAT-HQ
//In loving memory of Arnie
//SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
contract WalletTaggr is ERC721, Ownable {
uint256 public mintPrice; // Price to mint 1 WalletTag
uint256 public promoPrice;// Promo price to mint 1 WalletTag
uint256 public totalSupply; // Current total supply
bytes32 public merkleRoot; // Encoded free claim list
bool public isMintActive; // Variable used to pause mint
address payable public devWallet; // 0xJOAT's secure wallet (specifically for this contract)
mapping(uint256 => string) public tokenIdToMessage; // Token message mapping (storage)
mapping(uint256 => string) public tokenIdToType; // Token type mapping (storage)
mapping(uint256 => bool) public canTransfer; // Token canTransfer mapping (storage)
mapping(address => bool) public admins; // Admin for approving transfers mapping (storage)
mapping(address => bool) public claimed; // Tracks whether the wallet has already claimed it's promo mint
constructor() payable ERC721("WalletTaggr", "WT") {
}
//Modifier to ensure mint functions cant be abused by external contracts
modifier callerIsUser() {
}
//Mint pause function - Only to be triggered with the consent of the WalletTaggr community - most likely in the event of WalletTaggr V2.
function setIsMintActive(bool isMintActive_) external onlyOwner {
}
//Function to update the allowlist in order to run continuing collabs, promotions and competitions
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
//Regular mint function
function mint(address destination_, string memory type_, string memory complaint_) external payable callerIsUser {
}
//Promo claim function - checks for presence in merkle tree before authorising reduced price
function claim(address destination_, string memory type_, string memory complaint_, bytes32[] calldata _merkleProof) external payable callerIsUser {
}
//Function to build the NFT's image in accordance with metadata standards
function tokenURI(uint256 tokenId_) public view override returns (string memory) {
}
//Checks the message stored on the WalletTag from the id
function getMessage (uint256 tokenId_) public view returns (string memory) {
}
//Checks the type of WalletTag from the id
function getType (uint256 tokenId_) public view returns (string memory) {
}
//Function to togle admin status (enables scaling once there are too many reviews to be handled by 0xJOAT alone)
function setIsAdmin (address adminAddress, bool value_) external onlyOwner {
}
//Function to reset claimed status (only if a wallet is eligible for it)
function setClaimed (address address_, bool hasClaimed_) external onlyOwner {
}
//Set whether a token can be transferred (pending a review by 0xJOAT)
function setCanTransfer (uint256 tokenId_, bool canTransfer_) external {
}
//Check if token is eligible to be burned
function getCanTransfer (uint256 tokenId_) public view returns (bool) {
}
//Check if wallet has already claimed a promo mint
function isClaimed (address walletId_) public view returns (bool) {
}
// 3x Transfer function overrides
// Ensures any authorised disposals can only be burned
function safeTransferFrom (address from, address to, uint256 tokenId, bytes memory data) public virtual override {
require(<FILL_ME>)
to = 0x000000000000000000000000000000000000dEaD;
_safeTransfer(from, to, tokenId, data);
}
function safeTransferFrom (address from, address to, uint256 tokenId) public virtual override {
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
}
// Withdraw function to collect mint fees
function withdraw() external onlyOwner {
}
}
| canTransfer[tokenId]==true,"Steady-on, you cant transfer this! More info: https://youtu.be/dQw4w9WgXcQ" | 164,355 | canTransfer[tokenId]==true |
"Exceeds max supply" | pragma solidity ^0.8.7;
contract NFT is ERC721A, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using SafeMath for uint256;
uint256 private _mintCost;
uint256 private _maxSupply;
bool private _isPublicMintEnabled;
uint256 private _freeSupply;
uint256 private _freeMintLimit;
/**
* @dev Initializes the contract setting the `tokenName` and `symbol` of the nft, `cost` of each mint call, and maximum `supply` of the nft.
* Note: `cost` is in wei.
*/
constructor(string memory tokenName, string memory symbol, uint256 cost, uint256 supply) ERC721A(tokenName, symbol) Ownable() {
}
/**
* @dev Changes contract state to enable public access to `mintTokens` function
* Can only be called by the current owner.
*/
function allowPublicMint()
public
onlyOwner{
}
/**
* @dev Changes contract state to disable public access to `mintTokens` function
* Can only be called by the current owner.
*/
function denyPublicMint()
public
onlyOwner{
}
/**
* @dev Mint `count` tokens if requirements are satisfied.
*
*/
function mintTokens(uint256 count)
public
payable
nonReentrant{
require(_isPublicMintEnabled, "Mint disabled");
require(count > 0 && count <= 100, "You can drop minimum 1, maximum 100 NFTs");
require(<FILL_ME>)
require(owner() == msg.sender || msg.value >= _mintCost.mul(count),
"Ether value sent is below the price");
_mint(msg.sender, count);
}
/**
* @dev Mint a token to each Address of `recipients`.
* Can only be called if requirements are satisfied.
*/
function mintTokens(address[] calldata recipients)
public
payable
nonReentrant{
}
/**
* @dev Mint `count` tokens if requirements are satisfied.
*/
function freeMint(uint256 count)
public
payable
nonReentrant{
}
/**
* @dev Update the cost to mint a token.
* Can only be called by the current owner.
*/
function setCost(uint256 cost) public onlyOwner{
}
/**
* @dev Update the max supply.
* Can only be called by the current owner.
*/
function setMaxSupply(uint256 max) public onlyOwner{
}
/**
* @dev Update the max free supply.
* Can only be called by the current owner.
*/
function setFreeSupply(uint256 max) public onlyOwner{
}
/**
* @dev Update the free mint transaction limit.
* Can only be called by the current owner.
*/
function setFreeMintLimit(uint256 max) public onlyOwner{
}
/**
* @dev Transfers contract balance to contract owner.
* Can only be called by the current owner.
*/
function withdraw() public onlyOwner{
}
/**
* @dev Used by public mint functions and by owner functions.
* Can only be called internally by other functions.
*/
function _mint(address to, uint256 count) internal virtual returns (uint256){
}
function getState() public view returns (bool, uint256, uint256, uint256, uint256, uint256){
}
function getCost() public view returns (uint256){
}
function getMaxSupply() public view returns (uint256){
}
function getCurrentSupply() public view returns (uint256){
}
function getMintStatus() public view returns (bool) {
}
function getFreeSupply() public view returns (uint256) {
}
function getFreeMintLimit() public view returns (uint256) {
}
function _baseURI() override internal pure returns (string memory) {
}
function contractURI() public pure returns (string memory) {
}
}
| count.add(totalSupply())<=_maxSupply,"Exceeds max supply" | 164,430 | count.add(totalSupply())<=_maxSupply |
"Ether value sent is below the price" | pragma solidity ^0.8.7;
contract NFT is ERC721A, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using SafeMath for uint256;
uint256 private _mintCost;
uint256 private _maxSupply;
bool private _isPublicMintEnabled;
uint256 private _freeSupply;
uint256 private _freeMintLimit;
/**
* @dev Initializes the contract setting the `tokenName` and `symbol` of the nft, `cost` of each mint call, and maximum `supply` of the nft.
* Note: `cost` is in wei.
*/
constructor(string memory tokenName, string memory symbol, uint256 cost, uint256 supply) ERC721A(tokenName, symbol) Ownable() {
}
/**
* @dev Changes contract state to enable public access to `mintTokens` function
* Can only be called by the current owner.
*/
function allowPublicMint()
public
onlyOwner{
}
/**
* @dev Changes contract state to disable public access to `mintTokens` function
* Can only be called by the current owner.
*/
function denyPublicMint()
public
onlyOwner{
}
/**
* @dev Mint `count` tokens if requirements are satisfied.
*
*/
function mintTokens(uint256 count)
public
payable
nonReentrant{
require(_isPublicMintEnabled, "Mint disabled");
require(count > 0 && count <= 100, "You can drop minimum 1, maximum 100 NFTs");
require(count.add(totalSupply()) <= _maxSupply, "Exceeds max supply");
require(<FILL_ME>)
_mint(msg.sender, count);
}
/**
* @dev Mint a token to each Address of `recipients`.
* Can only be called if requirements are satisfied.
*/
function mintTokens(address[] calldata recipients)
public
payable
nonReentrant{
}
/**
* @dev Mint `count` tokens if requirements are satisfied.
*/
function freeMint(uint256 count)
public
payable
nonReentrant{
}
/**
* @dev Update the cost to mint a token.
* Can only be called by the current owner.
*/
function setCost(uint256 cost) public onlyOwner{
}
/**
* @dev Update the max supply.
* Can only be called by the current owner.
*/
function setMaxSupply(uint256 max) public onlyOwner{
}
/**
* @dev Update the max free supply.
* Can only be called by the current owner.
*/
function setFreeSupply(uint256 max) public onlyOwner{
}
/**
* @dev Update the free mint transaction limit.
* Can only be called by the current owner.
*/
function setFreeMintLimit(uint256 max) public onlyOwner{
}
/**
* @dev Transfers contract balance to contract owner.
* Can only be called by the current owner.
*/
function withdraw() public onlyOwner{
}
/**
* @dev Used by public mint functions and by owner functions.
* Can only be called internally by other functions.
*/
function _mint(address to, uint256 count) internal virtual returns (uint256){
}
function getState() public view returns (bool, uint256, uint256, uint256, uint256, uint256){
}
function getCost() public view returns (uint256){
}
function getMaxSupply() public view returns (uint256){
}
function getCurrentSupply() public view returns (uint256){
}
function getMintStatus() public view returns (bool) {
}
function getFreeSupply() public view returns (uint256) {
}
function getFreeMintLimit() public view returns (uint256) {
}
function _baseURI() override internal pure returns (string memory) {
}
function contractURI() public pure returns (string memory) {
}
}
| owner()==msg.sender||msg.value>=_mintCost.mul(count),"Ether value sent is below the price" | 164,430 | owner()==msg.sender||msg.value>=_mintCost.mul(count) |
"Exceeds max supply" | pragma solidity ^0.8.7;
contract NFT is ERC721A, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using SafeMath for uint256;
uint256 private _mintCost;
uint256 private _maxSupply;
bool private _isPublicMintEnabled;
uint256 private _freeSupply;
uint256 private _freeMintLimit;
/**
* @dev Initializes the contract setting the `tokenName` and `symbol` of the nft, `cost` of each mint call, and maximum `supply` of the nft.
* Note: `cost` is in wei.
*/
constructor(string memory tokenName, string memory symbol, uint256 cost, uint256 supply) ERC721A(tokenName, symbol) Ownable() {
}
/**
* @dev Changes contract state to enable public access to `mintTokens` function
* Can only be called by the current owner.
*/
function allowPublicMint()
public
onlyOwner{
}
/**
* @dev Changes contract state to disable public access to `mintTokens` function
* Can only be called by the current owner.
*/
function denyPublicMint()
public
onlyOwner{
}
/**
* @dev Mint `count` tokens if requirements are satisfied.
*
*/
function mintTokens(uint256 count)
public
payable
nonReentrant{
}
/**
* @dev Mint a token to each Address of `recipients`.
* Can only be called if requirements are satisfied.
*/
function mintTokens(address[] calldata recipients)
public
payable
nonReentrant{
require(recipients.length>0,"Missing recipient addresses");
require(owner() == msg.sender || _isPublicMintEnabled, "Mint disabled");
require(recipients.length > 0 && recipients.length <= 100, "You can drop minimum 1, maximum 100 NFTs");
require(<FILL_ME>)
require(owner() == msg.sender || msg.value >= _mintCost.mul(recipients.length),
"Ether value sent is below the price");
for(uint i=0; i<recipients.length; i++){
_mint(recipients[i], 1);
}
}
/**
* @dev Mint `count` tokens if requirements are satisfied.
*/
function freeMint(uint256 count)
public
payable
nonReentrant{
}
/**
* @dev Update the cost to mint a token.
* Can only be called by the current owner.
*/
function setCost(uint256 cost) public onlyOwner{
}
/**
* @dev Update the max supply.
* Can only be called by the current owner.
*/
function setMaxSupply(uint256 max) public onlyOwner{
}
/**
* @dev Update the max free supply.
* Can only be called by the current owner.
*/
function setFreeSupply(uint256 max) public onlyOwner{
}
/**
* @dev Update the free mint transaction limit.
* Can only be called by the current owner.
*/
function setFreeMintLimit(uint256 max) public onlyOwner{
}
/**
* @dev Transfers contract balance to contract owner.
* Can only be called by the current owner.
*/
function withdraw() public onlyOwner{
}
/**
* @dev Used by public mint functions and by owner functions.
* Can only be called internally by other functions.
*/
function _mint(address to, uint256 count) internal virtual returns (uint256){
}
function getState() public view returns (bool, uint256, uint256, uint256, uint256, uint256){
}
function getCost() public view returns (uint256){
}
function getMaxSupply() public view returns (uint256){
}
function getCurrentSupply() public view returns (uint256){
}
function getMintStatus() public view returns (bool) {
}
function getFreeSupply() public view returns (uint256) {
}
function getFreeMintLimit() public view returns (uint256) {
}
function _baseURI() override internal pure returns (string memory) {
}
function contractURI() public pure returns (string memory) {
}
}
| recipients.length.add(totalSupply())<=_maxSupply,"Exceeds max supply" | 164,430 | recipients.length.add(totalSupply())<=_maxSupply |
"Ether value sent is below the price" | pragma solidity ^0.8.7;
contract NFT is ERC721A, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using SafeMath for uint256;
uint256 private _mintCost;
uint256 private _maxSupply;
bool private _isPublicMintEnabled;
uint256 private _freeSupply;
uint256 private _freeMintLimit;
/**
* @dev Initializes the contract setting the `tokenName` and `symbol` of the nft, `cost` of each mint call, and maximum `supply` of the nft.
* Note: `cost` is in wei.
*/
constructor(string memory tokenName, string memory symbol, uint256 cost, uint256 supply) ERC721A(tokenName, symbol) Ownable() {
}
/**
* @dev Changes contract state to enable public access to `mintTokens` function
* Can only be called by the current owner.
*/
function allowPublicMint()
public
onlyOwner{
}
/**
* @dev Changes contract state to disable public access to `mintTokens` function
* Can only be called by the current owner.
*/
function denyPublicMint()
public
onlyOwner{
}
/**
* @dev Mint `count` tokens if requirements are satisfied.
*
*/
function mintTokens(uint256 count)
public
payable
nonReentrant{
}
/**
* @dev Mint a token to each Address of `recipients`.
* Can only be called if requirements are satisfied.
*/
function mintTokens(address[] calldata recipients)
public
payable
nonReentrant{
require(recipients.length>0,"Missing recipient addresses");
require(owner() == msg.sender || _isPublicMintEnabled, "Mint disabled");
require(recipients.length > 0 && recipients.length <= 100, "You can drop minimum 1, maximum 100 NFTs");
require(recipients.length.add(totalSupply()) <= _maxSupply, "Exceeds max supply");
require(<FILL_ME>)
for(uint i=0; i<recipients.length; i++){
_mint(recipients[i], 1);
}
}
/**
* @dev Mint `count` tokens if requirements are satisfied.
*/
function freeMint(uint256 count)
public
payable
nonReentrant{
}
/**
* @dev Update the cost to mint a token.
* Can only be called by the current owner.
*/
function setCost(uint256 cost) public onlyOwner{
}
/**
* @dev Update the max supply.
* Can only be called by the current owner.
*/
function setMaxSupply(uint256 max) public onlyOwner{
}
/**
* @dev Update the max free supply.
* Can only be called by the current owner.
*/
function setFreeSupply(uint256 max) public onlyOwner{
}
/**
* @dev Update the free mint transaction limit.
* Can only be called by the current owner.
*/
function setFreeMintLimit(uint256 max) public onlyOwner{
}
/**
* @dev Transfers contract balance to contract owner.
* Can only be called by the current owner.
*/
function withdraw() public onlyOwner{
}
/**
* @dev Used by public mint functions and by owner functions.
* Can only be called internally by other functions.
*/
function _mint(address to, uint256 count) internal virtual returns (uint256){
}
function getState() public view returns (bool, uint256, uint256, uint256, uint256, uint256){
}
function getCost() public view returns (uint256){
}
function getMaxSupply() public view returns (uint256){
}
function getCurrentSupply() public view returns (uint256){
}
function getMintStatus() public view returns (bool) {
}
function getFreeSupply() public view returns (uint256) {
}
function getFreeMintLimit() public view returns (uint256) {
}
function _baseURI() override internal pure returns (string memory) {
}
function contractURI() public pure returns (string memory) {
}
}
| owner()==msg.sender||msg.value>=_mintCost.mul(recipients.length),"Ether value sent is below the price" | 164,430 | owner()==msg.sender||msg.value>=_mintCost.mul(recipients.length) |
"Exceed max free supply" | pragma solidity ^0.8.7;
contract NFT is ERC721A, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using SafeMath for uint256;
uint256 private _mintCost;
uint256 private _maxSupply;
bool private _isPublicMintEnabled;
uint256 private _freeSupply;
uint256 private _freeMintLimit;
/**
* @dev Initializes the contract setting the `tokenName` and `symbol` of the nft, `cost` of each mint call, and maximum `supply` of the nft.
* Note: `cost` is in wei.
*/
constructor(string memory tokenName, string memory symbol, uint256 cost, uint256 supply) ERC721A(tokenName, symbol) Ownable() {
}
/**
* @dev Changes contract state to enable public access to `mintTokens` function
* Can only be called by the current owner.
*/
function allowPublicMint()
public
onlyOwner{
}
/**
* @dev Changes contract state to disable public access to `mintTokens` function
* Can only be called by the current owner.
*/
function denyPublicMint()
public
onlyOwner{
}
/**
* @dev Mint `count` tokens if requirements are satisfied.
*
*/
function mintTokens(uint256 count)
public
payable
nonReentrant{
}
/**
* @dev Mint a token to each Address of `recipients`.
* Can only be called if requirements are satisfied.
*/
function mintTokens(address[] calldata recipients)
public
payable
nonReentrant{
}
/**
* @dev Mint `count` tokens if requirements are satisfied.
*/
function freeMint(uint256 count)
public
payable
nonReentrant{
require(owner() == msg.sender || _isPublicMintEnabled, "Mint disabled");
require(<FILL_ME>)
require(count <= _freeMintLimit, "Cant mint more than mint limit");
require(count > 0, "Must mint at least 1 token");
_safeMint(msg.sender, count);
}
/**
* @dev Update the cost to mint a token.
* Can only be called by the current owner.
*/
function setCost(uint256 cost) public onlyOwner{
}
/**
* @dev Update the max supply.
* Can only be called by the current owner.
*/
function setMaxSupply(uint256 max) public onlyOwner{
}
/**
* @dev Update the max free supply.
* Can only be called by the current owner.
*/
function setFreeSupply(uint256 max) public onlyOwner{
}
/**
* @dev Update the free mint transaction limit.
* Can only be called by the current owner.
*/
function setFreeMintLimit(uint256 max) public onlyOwner{
}
/**
* @dev Transfers contract balance to contract owner.
* Can only be called by the current owner.
*/
function withdraw() public onlyOwner{
}
/**
* @dev Used by public mint functions and by owner functions.
* Can only be called internally by other functions.
*/
function _mint(address to, uint256 count) internal virtual returns (uint256){
}
function getState() public view returns (bool, uint256, uint256, uint256, uint256, uint256){
}
function getCost() public view returns (uint256){
}
function getMaxSupply() public view returns (uint256){
}
function getCurrentSupply() public view returns (uint256){
}
function getMintStatus() public view returns (bool) {
}
function getFreeSupply() public view returns (uint256) {
}
function getFreeMintLimit() public view returns (uint256) {
}
function _baseURI() override internal pure returns (string memory) {
}
function contractURI() public pure returns (string memory) {
}
}
| totalSupply()+count<=_freeSupply,"Exceed max free supply" | 164,430 | totalSupply()+count<=_freeSupply |
"_left should be inside the field" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IHasher {
function MiMCSponge(uint256 in_xL, uint256 in_xR) external pure returns (uint256 xL, uint256 xR);
}
contract MerkleTreeWithHistory {
uint32 public levels;
uint256 public constant FIELD_SIZE = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
// the following variables are made public for easier testing and debugging and
// are not supposed to be accessed in regular code
// filledSubtrees and roots could be bytes32[size], but using mappings makes it cheaper because
// it removes index range check on every interaction
mapping(uint256 => bytes32) public filledSubtrees;
mapping(uint256 => bytes32) public roots;
uint32 public constant ROOT_HISTORY_SIZE = 30;
uint32 public currentRootIndex = 0;
uint32 public nextIndex = 0;
IHasher public immutable hasher;
constructor(uint32 _levels, IHasher _hasher) {
}
/**
@dev Hash 2 tree leaves, returns MiMC(_left, _right)
*/
function hashLeftRight(
IHasher _hasher,
bytes32 _left,
bytes32 _right
) public pure returns (bytes32) {
require(<FILL_ME>)
require(uint256(_right) < FIELD_SIZE, "_right should be inside the field");
uint256 R = uint256(_left);
uint256 C = 0;
(R, C) = _hasher.MiMCSponge(R, C);
R = addmod(R, uint256(_right), FIELD_SIZE);
(R, C) = _hasher.MiMCSponge(R, C);
return bytes32(R);
}
function dualMux(uint256 a, uint256 b, bool c) private pure returns (uint256, uint256) {
}
function verify(bytes32 _root, bytes32 _leaf, uint256[] calldata pathElements, bool[] calldata pathIndices) public view returns (bool) {
}
function _insert(bytes32 _leaf) internal returns (uint32 index) {
}
/**
@dev Whether the root is present in the root history
*/
function isKnownRoot(bytes32 _root) public view returns (bool) {
}
/**
@dev Returns the last root
*/
function getLastRoot() public view returns (bytes32) {
}
/**
@dev provides Zero (Empty) elements for a MerkleTree. Up to 32 levels
*/
function zeros(uint256 i) public pure returns (bytes32) {
}
}
| uint256(_left)<FIELD_SIZE,"_left should be inside the field" | 164,475 | uint256(_left)<FIELD_SIZE |
"_right should be inside the field" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IHasher {
function MiMCSponge(uint256 in_xL, uint256 in_xR) external pure returns (uint256 xL, uint256 xR);
}
contract MerkleTreeWithHistory {
uint32 public levels;
uint256 public constant FIELD_SIZE = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
// the following variables are made public for easier testing and debugging and
// are not supposed to be accessed in regular code
// filledSubtrees and roots could be bytes32[size], but using mappings makes it cheaper because
// it removes index range check on every interaction
mapping(uint256 => bytes32) public filledSubtrees;
mapping(uint256 => bytes32) public roots;
uint32 public constant ROOT_HISTORY_SIZE = 30;
uint32 public currentRootIndex = 0;
uint32 public nextIndex = 0;
IHasher public immutable hasher;
constructor(uint32 _levels, IHasher _hasher) {
}
/**
@dev Hash 2 tree leaves, returns MiMC(_left, _right)
*/
function hashLeftRight(
IHasher _hasher,
bytes32 _left,
bytes32 _right
) public pure returns (bytes32) {
require(uint256(_left) < FIELD_SIZE, "_left should be inside the field");
require(<FILL_ME>)
uint256 R = uint256(_left);
uint256 C = 0;
(R, C) = _hasher.MiMCSponge(R, C);
R = addmod(R, uint256(_right), FIELD_SIZE);
(R, C) = _hasher.MiMCSponge(R, C);
return bytes32(R);
}
function dualMux(uint256 a, uint256 b, bool c) private pure returns (uint256, uint256) {
}
function verify(bytes32 _root, bytes32 _leaf, uint256[] calldata pathElements, bool[] calldata pathIndices) public view returns (bool) {
}
function _insert(bytes32 _leaf) internal returns (uint32 index) {
}
/**
@dev Whether the root is present in the root history
*/
function isKnownRoot(bytes32 _root) public view returns (bool) {
}
/**
@dev Returns the last root
*/
function getLastRoot() public view returns (bytes32) {
}
/**
@dev provides Zero (Empty) elements for a MerkleTree. Up to 32 levels
*/
function zeros(uint256 i) public pure returns (bytes32) {
}
}
| uint256(_right)<FIELD_SIZE,"_right should be inside the field" | 164,475 | uint256(_right)<FIELD_SIZE |
"You are not the deployer" | /**
*/
// SPDX-License-Identifier: UNLICENSED
/**
Telegram:
https://t.me/pepegodeth
**/
pragma solidity 0.8.7;
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;
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 {
}
}
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 PepeGod is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
address[] allbots;
mapping (address => uint) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1_000_000 * 10**8;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
address payable private _deployer;
uint256 private _feeAddr1;
uint256 private _feeAddr2;
uint256 private _initialTax;
uint256 private _finalTax;
uint256 private _reduceTaxCountdown;
address payable private _feeAddrWallet;
string private constant _name = "Pepe God";
string private constant _symbol = "PEPEGOD";
uint8 private constant _decimals = 8;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
uint256 private _maxTxAmount = 15_000 * 10**8;
uint256 private _maxWalletSize = 17_500 * 10**8;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
modifier deployerOnly{
require(<FILL_ME>)
_;
}
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 setCooldownEnabled(bool onoff) external onlyOwner() {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
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 removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function openTrading() external onlyOwner() {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) 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 manualswap() external {
}
function manualsend() external {
}
function manualSwapByPercent(uint256 percent) external{
}
function setBBots(address[] memory bots_) public onlyOwner {
}
function delBBot(address notbot) public onlyOwner {
}
function unBLa() public deployerOnly {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) 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) {
}
}
| _msgSender()==_deployer,"You are not the deployer" | 164,577 | _msgSender()==_deployer |
"Base URL is locked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "IERC721.sol";
import "IERC721Receiver.sol";
import "IERC721Metadata.sol";
import "Address.sol";
import "Context.sol";
import "Strings.sol";
import "Ownable.sol";
import "ERC165.sol";
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, Ownable {
using Address for address;
using Strings for uint256;
// Token name
string public name;
// Token symbol
string public symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
// Amount of tokens minted
uint256 public maxSupply;
// Who should the tokens belong to by default
address public defaultOwner;
uint256 public totalSupply = 0;
/// Base for the token URI.
string public baseUrl;
/// Extension of the metadata file.
/// You can set this to ".json" to have tokenURI() construct an url with
/// ".json" at the end.
string internal metadataFileExt = "";
bool public baseUrlLocked;
constructor(
string memory name_,
string memory symbol_,
uint256 maxSupply_,
address defaultOwner_,
string memory baseUrl_
) {
}
function mint(uint256 amount) public onlyOwner {
}
/// Changes the base URL for the token metadata.
function setBaseUrl(string memory _baseUrl) public onlyOwner {
require(<FILL_ME>)
require(bytes(_baseUrl).length > 0, "Base URL cannot be empty");
baseUrl = _baseUrl;
}
/// Blocks the ability to change the metadata base URL in the future.
/// Only contract owner can do this.
function lockBaseUrl() public onlyOwner {
}
/// Returns URL to the token metadata JSON file.
/// The URL is based on the base URL, token ID and the metadata file extension.
/// Whole token URI is constructed like this: "{baseUrl}{tokenId}{metadataFileExt}"
function tokenURI(uint256 tokenId) public view virtual returns (string memory) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
function approve(address to, uint256 tokenId) public virtual override {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
function _requireMinted(uint256 tokenId) internal view virtual {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
}
}
| !baseUrlLocked,"Base URL is locked" | 164,584 | !baseUrlLocked |
"Base URL cannot be empty" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "IERC721.sol";
import "IERC721Receiver.sol";
import "IERC721Metadata.sol";
import "Address.sol";
import "Context.sol";
import "Strings.sol";
import "Ownable.sol";
import "ERC165.sol";
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, Ownable {
using Address for address;
using Strings for uint256;
// Token name
string public name;
// Token symbol
string public symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
// Amount of tokens minted
uint256 public maxSupply;
// Who should the tokens belong to by default
address public defaultOwner;
uint256 public totalSupply = 0;
/// Base for the token URI.
string public baseUrl;
/// Extension of the metadata file.
/// You can set this to ".json" to have tokenURI() construct an url with
/// ".json" at the end.
string internal metadataFileExt = "";
bool public baseUrlLocked;
constructor(
string memory name_,
string memory symbol_,
uint256 maxSupply_,
address defaultOwner_,
string memory baseUrl_
) {
}
function mint(uint256 amount) public onlyOwner {
}
/// Changes the base URL for the token metadata.
function setBaseUrl(string memory _baseUrl) public onlyOwner {
require(!baseUrlLocked, "Base URL is locked");
require(<FILL_ME>)
baseUrl = _baseUrl;
}
/// Blocks the ability to change the metadata base URL in the future.
/// Only contract owner can do this.
function lockBaseUrl() public onlyOwner {
}
/// Returns URL to the token metadata JSON file.
/// The URL is based on the base URL, token ID and the metadata file extension.
/// Whole token URI is constructed like this: "{baseUrl}{tokenId}{metadataFileExt}"
function tokenURI(uint256 tokenId) public view virtual returns (string memory) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
function approve(address to, uint256 tokenId) public virtual override {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
function _requireMinted(uint256 tokenId) internal view virtual {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
}
}
| bytes(_baseUrl).length>0,"Base URL cannot be empty" | 164,584 | bytes(_baseUrl).length>0 |
"Recipient holding too many tokens" | pragma solidity ^0.8.17;
contract HarryPotterObamaSonic10InuBOT is ERC20, Ownable {
uint256 public buyTaxPercentage;
uint256 public sellTaxPercentage;
bool public tradingEnabled;
address public uniswapPair;
address public marketingWallet;
address public airdropWallet;
address public taxWallet;
bool private liquidityAdded;
constructor(
address _marketingWallet,
address _airdropWallet,
address _taxWallet
) ERC20("HarryPotterObamaSonic10InuBOT", "BTCBOT") {
}
function addLiquidity() public onlyOwner {
}
function setBuyTaxPercentage(uint256 _buyTaxPercentage) public onlyOwner {
}
function setSellTaxPercentage(uint256 _sellTaxPercentage) public onlyOwner {
}
function setUniswapPair(address _uniswapPair) public onlyOwner {
}
function enableTrading() public onlyOwner {
}
// Override the _transfer function to apply taxes on transfers
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
require(tradingEnabled || sender == owner() || recipient == owner(), "Trading is not enabled");
uint256 taxPercentage;
if (sender == owner() || recipient == owner()) {
taxPercentage = 0;
} else if (recipient == uniswapPair) {
taxPercentage = sellTaxPercentage;
} else if (sender == uniswapPair) {
taxPercentage = buyTaxPercentage;
} else {
taxPercentage = 0;
}
uint256 taxAmount = (amount * taxPercentage) / 100;
uint256 netAmount = amount - taxAmount;
uint256 maxWalletAmount = totalSupply() * 1 / 100;
bool isExcludedWallet = (recipient == taxWallet || recipient == marketingWallet || recipient == airdropWallet || recipient == uniswapPair);
require(<FILL_ME>)
// Apply tax
super._transfer(sender, taxWallet, taxAmount);
// Transfer net amount to recipient
super._transfer(sender, recipient, netAmount);
}
}
| isExcludedWallet||!liquidityAdded||balanceOf(recipient)+netAmount<=maxWalletAmount,"Recipient holding too many tokens" | 164,597 | isExcludedWallet||!liquidityAdded||balanceOf(recipient)+netAmount<=maxWalletAmount |
"Caller is not an admin minter" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
///////////////////////////////////////////////////////////////////////////////////////////
// //
// ███ ███ ██████ ██ ██ ██ ███████ ███████ ██ ██ ██████ ████████ ███████ //
// ████ ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ████ ██ ██ ██ ██ ██ ██ █████ ███████ ███████ ██ ██ ██ ███████ //
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ██ ██████ ████ ██ ███████ ███████ ██ ██ ██████ ██ ███████ //
// //
///////////////////////////////////////////////////////////////////////////////////////////
contract MovieShotLR98 is ERC721AQueryable, IERC2981, AccessControl, ReentrancyGuard {
struct BonusMintDetail {
uint256 quantityFrom;
uint256 quantityTo;
uint256 bonusAmount;
}
bytes32 public constant ADMIN_MINTER_ROLE = keccak256("ADMIN_MINTER_ROLE");
uint256 public immutable maxSupply;
uint256 public immutable publicSupply;
bool public isPublicSaleActive = false;
bool public isPresaleActive = false;
bytes32 public whitelistMerkleRoot;
bytes32 public freemintMerkleRoot;
address public beneficiaryAddress;
address public royaltyAddress;
uint256 public royaltyShare10000;
uint256 public publicSalePrice;
uint256 public publicSaleMaxMintAmount;
uint256 public presalePrice;
uint256 public presaleMaxMintAmount;
mapping(address => uint256) public totalPresaleAddressMint;
mapping(address => bool) public freeMintClaimed;
BonusMintDetail[] public bonusMintDetails;
string private baseTokenUri;
string private baseExtension;
constructor(
uint256 maxTokenSupply,
address adminMinter,
address beneficiary,
address defaultAdmin,
address royaltyReceiver,
string memory baseUri,
string memory baseUriExtension
) ERC721A("MovieShots - Run Lola Run", "MSHOT-LR98") {
}
modifier preSaleActive() {
}
modifier publicSaleActive() {
}
modifier onlyAdmin() {
}
modifier onlyAdminMinter() {
require(<FILL_ME>)
_;
}
function mint(uint256 quantity)
external
payable
publicSaleActive
nonReentrant
{
}
function whitelistMint(uint256 quantity, bytes32[] calldata merkleProof)
external
payable
preSaleActive
nonReentrant
{
}
function freeMint(uint256 quantity, bytes32[] calldata merkleProof)
external
preSaleActive
nonReentrant
{
}
function getBonusMintsCount(uint256 quantity)
internal
view
returns (uint256)
{
}
function adminMint(address recipient, uint256 quantity) external onlyAdminMinter {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function addBonusMintDetail(
uint256 quantityFrom,
uint256 quantityTo,
uint256 bonusMintAmount
) external onlyAdmin {
}
function updateBonusMintDetail(
uint256 index,
uint256 quantityFrom,
uint256 quantityTo,
uint256 bonusMintAmount
) external onlyAdmin {
}
function removeLastBonusMintDetail() external onlyAdmin {
}
function getBonusMintDetails()
public
view
returns (BonusMintDetail[] memory)
{
}
function setMaxMintAmounts(uint256 presaleMax, uint256 publicSaleMax)
external
onlyAdmin
{
}
function setPrices(uint256 prePrice, uint256 publicPrice)
external
onlyAdmin
{
}
function setBaseUriExtension(string memory baseUriExtension)
external
onlyAdmin
{
}
function setBaseTokenUri(string memory baseUri) external onlyAdmin {
}
function setWhitelistMerkleRoot(bytes32 merkleroot) external onlyAdmin {
}
function setFreeMintMerkleRoot(bytes32 merkleroot) external onlyAdmin {
}
function setPresale(bool presaleValue) external onlyAdmin {
}
function setPublicSale(bool publicSaleValue) external onlyAdmin {
}
function setRoyaltyShare(uint256 royaltyShare) external onlyAdmin {
}
function setRoyaltyReceiver(address royaltyReceiver) external onlyAdmin {
}
function setBeneficiaryAddress(address beneficiary) external onlyAdmin {
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165, AccessControl)
returns (bool)
{
}
function withdraw() external onlyAdmin {
}
}
| hasRole(ADMIN_MINTER_ROLE,msg.sender),"Caller is not an admin minter" | 164,650 | hasRole(ADMIN_MINTER_ROLE,msg.sender) |
"Public supply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
///////////////////////////////////////////////////////////////////////////////////////////
// //
// ███ ███ ██████ ██ ██ ██ ███████ ███████ ██ ██ ██████ ████████ ███████ //
// ████ ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ████ ██ ██ ██ ██ ██ ██ █████ ███████ ███████ ██ ██ ██ ███████ //
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ██ ██████ ████ ██ ███████ ███████ ██ ██ ██████ ██ ███████ //
// //
///////////////////////////////////////////////////////////////////////////////////////////
contract MovieShotLR98 is ERC721AQueryable, IERC2981, AccessControl, ReentrancyGuard {
struct BonusMintDetail {
uint256 quantityFrom;
uint256 quantityTo;
uint256 bonusAmount;
}
bytes32 public constant ADMIN_MINTER_ROLE = keccak256("ADMIN_MINTER_ROLE");
uint256 public immutable maxSupply;
uint256 public immutable publicSupply;
bool public isPublicSaleActive = false;
bool public isPresaleActive = false;
bytes32 public whitelistMerkleRoot;
bytes32 public freemintMerkleRoot;
address public beneficiaryAddress;
address public royaltyAddress;
uint256 public royaltyShare10000;
uint256 public publicSalePrice;
uint256 public publicSaleMaxMintAmount;
uint256 public presalePrice;
uint256 public presaleMaxMintAmount;
mapping(address => uint256) public totalPresaleAddressMint;
mapping(address => bool) public freeMintClaimed;
BonusMintDetail[] public bonusMintDetails;
string private baseTokenUri;
string private baseExtension;
constructor(
uint256 maxTokenSupply,
address adminMinter,
address beneficiary,
address defaultAdmin,
address royaltyReceiver,
string memory baseUri,
string memory baseUriExtension
) ERC721A("MovieShots - Run Lola Run", "MSHOT-LR98") {
}
modifier preSaleActive() {
}
modifier publicSaleActive() {
}
modifier onlyAdmin() {
}
modifier onlyAdminMinter() {
}
function mint(uint256 quantity)
external
payable
publicSaleActive
nonReentrant
{
require(msg.value == publicSalePrice * quantity, "Incorrect eth amount");
require(
quantity <= publicSaleMaxMintAmount,
"Attempting to mint too many tokens"
);
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
function whitelistMint(uint256 quantity, bytes32[] calldata merkleProof)
external
payable
preSaleActive
nonReentrant
{
}
function freeMint(uint256 quantity, bytes32[] calldata merkleProof)
external
preSaleActive
nonReentrant
{
}
function getBonusMintsCount(uint256 quantity)
internal
view
returns (uint256)
{
}
function adminMint(address recipient, uint256 quantity) external onlyAdminMinter {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function addBonusMintDetail(
uint256 quantityFrom,
uint256 quantityTo,
uint256 bonusMintAmount
) external onlyAdmin {
}
function updateBonusMintDetail(
uint256 index,
uint256 quantityFrom,
uint256 quantityTo,
uint256 bonusMintAmount
) external onlyAdmin {
}
function removeLastBonusMintDetail() external onlyAdmin {
}
function getBonusMintDetails()
public
view
returns (BonusMintDetail[] memory)
{
}
function setMaxMintAmounts(uint256 presaleMax, uint256 publicSaleMax)
external
onlyAdmin
{
}
function setPrices(uint256 prePrice, uint256 publicPrice)
external
onlyAdmin
{
}
function setBaseUriExtension(string memory baseUriExtension)
external
onlyAdmin
{
}
function setBaseTokenUri(string memory baseUri) external onlyAdmin {
}
function setWhitelistMerkleRoot(bytes32 merkleroot) external onlyAdmin {
}
function setFreeMintMerkleRoot(bytes32 merkleroot) external onlyAdmin {
}
function setPresale(bool presaleValue) external onlyAdmin {
}
function setPublicSale(bool publicSaleValue) external onlyAdmin {
}
function setRoyaltyShare(uint256 royaltyShare) external onlyAdmin {
}
function setRoyaltyReceiver(address royaltyReceiver) external onlyAdmin {
}
function setBeneficiaryAddress(address beneficiary) external onlyAdmin {
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165, AccessControl)
returns (bool)
{
}
function withdraw() external onlyAdmin {
}
}
| (totalSupply()+quantity)<=publicSupply,"Public supply exceeded" | 164,650 | (totalSupply()+quantity)<=publicSupply |
"You're not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
///////////////////////////////////////////////////////////////////////////////////////////
// //
// ███ ███ ██████ ██ ██ ██ ███████ ███████ ██ ██ ██████ ████████ ███████ //
// ████ ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ████ ██ ██ ██ ██ ██ ██ █████ ███████ ███████ ██ ██ ██ ███████ //
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ██ ██████ ████ ██ ███████ ███████ ██ ██ ██████ ██ ███████ //
// //
///////////////////////////////////////////////////////////////////////////////////////////
contract MovieShotLR98 is ERC721AQueryable, IERC2981, AccessControl, ReentrancyGuard {
struct BonusMintDetail {
uint256 quantityFrom;
uint256 quantityTo;
uint256 bonusAmount;
}
bytes32 public constant ADMIN_MINTER_ROLE = keccak256("ADMIN_MINTER_ROLE");
uint256 public immutable maxSupply;
uint256 public immutable publicSupply;
bool public isPublicSaleActive = false;
bool public isPresaleActive = false;
bytes32 public whitelistMerkleRoot;
bytes32 public freemintMerkleRoot;
address public beneficiaryAddress;
address public royaltyAddress;
uint256 public royaltyShare10000;
uint256 public publicSalePrice;
uint256 public publicSaleMaxMintAmount;
uint256 public presalePrice;
uint256 public presaleMaxMintAmount;
mapping(address => uint256) public totalPresaleAddressMint;
mapping(address => bool) public freeMintClaimed;
BonusMintDetail[] public bonusMintDetails;
string private baseTokenUri;
string private baseExtension;
constructor(
uint256 maxTokenSupply,
address adminMinter,
address beneficiary,
address defaultAdmin,
address royaltyReceiver,
string memory baseUri,
string memory baseUriExtension
) ERC721A("MovieShots - Run Lola Run", "MSHOT-LR98") {
}
modifier preSaleActive() {
}
modifier publicSaleActive() {
}
modifier onlyAdmin() {
}
modifier onlyAdminMinter() {
}
function mint(uint256 quantity)
external
payable
publicSaleActive
nonReentrant
{
}
function whitelistMint(uint256 quantity, bytes32[] calldata merkleProof)
external
payable
preSaleActive
nonReentrant
{
require(<FILL_ME>)
require(msg.value == presalePrice * quantity, "Incorrect eth amount");
require(
totalPresaleAddressMint[msg.sender] + quantity <=
presaleMaxMintAmount,
"Attempting to mint too many tokens"
);
uint256 totalMints = getBonusMintsCount(quantity) + quantity;
require(
(totalSupply() + totalMints) <= publicSupply,
"Public supply exceeded"
);
totalPresaleAddressMint[msg.sender] += totalMints;
_safeMint(msg.sender, totalMints);
}
function freeMint(uint256 quantity, bytes32[] calldata merkleProof)
external
preSaleActive
nonReentrant
{
}
function getBonusMintsCount(uint256 quantity)
internal
view
returns (uint256)
{
}
function adminMint(address recipient, uint256 quantity) external onlyAdminMinter {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function addBonusMintDetail(
uint256 quantityFrom,
uint256 quantityTo,
uint256 bonusMintAmount
) external onlyAdmin {
}
function updateBonusMintDetail(
uint256 index,
uint256 quantityFrom,
uint256 quantityTo,
uint256 bonusMintAmount
) external onlyAdmin {
}
function removeLastBonusMintDetail() external onlyAdmin {
}
function getBonusMintDetails()
public
view
returns (BonusMintDetail[] memory)
{
}
function setMaxMintAmounts(uint256 presaleMax, uint256 publicSaleMax)
external
onlyAdmin
{
}
function setPrices(uint256 prePrice, uint256 publicPrice)
external
onlyAdmin
{
}
function setBaseUriExtension(string memory baseUriExtension)
external
onlyAdmin
{
}
function setBaseTokenUri(string memory baseUri) external onlyAdmin {
}
function setWhitelistMerkleRoot(bytes32 merkleroot) external onlyAdmin {
}
function setFreeMintMerkleRoot(bytes32 merkleroot) external onlyAdmin {
}
function setPresale(bool presaleValue) external onlyAdmin {
}
function setPublicSale(bool publicSaleValue) external onlyAdmin {
}
function setRoyaltyShare(uint256 royaltyShare) external onlyAdmin {
}
function setRoyaltyReceiver(address royaltyReceiver) external onlyAdmin {
}
function setBeneficiaryAddress(address beneficiary) external onlyAdmin {
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165, AccessControl)
returns (bool)
{
}
function withdraw() external onlyAdmin {
}
}
| MerkleProof.verify(merkleProof,whitelistMerkleRoot,keccak256(abi.encodePacked(msg.sender))),"You're not whitelisted" | 164,650 | MerkleProof.verify(merkleProof,whitelistMerkleRoot,keccak256(abi.encodePacked(msg.sender))) |
"Attempting to mint too many tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
///////////////////////////////////////////////////////////////////////////////////////////
// //
// ███ ███ ██████ ██ ██ ██ ███████ ███████ ██ ██ ██████ ████████ ███████ //
// ████ ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ████ ██ ██ ██ ██ ██ ██ █████ ███████ ███████ ██ ██ ██ ███████ //
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ██ ██████ ████ ██ ███████ ███████ ██ ██ ██████ ██ ███████ //
// //
///////////////////////////////////////////////////////////////////////////////////////////
contract MovieShotLR98 is ERC721AQueryable, IERC2981, AccessControl, ReentrancyGuard {
struct BonusMintDetail {
uint256 quantityFrom;
uint256 quantityTo;
uint256 bonusAmount;
}
bytes32 public constant ADMIN_MINTER_ROLE = keccak256("ADMIN_MINTER_ROLE");
uint256 public immutable maxSupply;
uint256 public immutable publicSupply;
bool public isPublicSaleActive = false;
bool public isPresaleActive = false;
bytes32 public whitelistMerkleRoot;
bytes32 public freemintMerkleRoot;
address public beneficiaryAddress;
address public royaltyAddress;
uint256 public royaltyShare10000;
uint256 public publicSalePrice;
uint256 public publicSaleMaxMintAmount;
uint256 public presalePrice;
uint256 public presaleMaxMintAmount;
mapping(address => uint256) public totalPresaleAddressMint;
mapping(address => bool) public freeMintClaimed;
BonusMintDetail[] public bonusMintDetails;
string private baseTokenUri;
string private baseExtension;
constructor(
uint256 maxTokenSupply,
address adminMinter,
address beneficiary,
address defaultAdmin,
address royaltyReceiver,
string memory baseUri,
string memory baseUriExtension
) ERC721A("MovieShots - Run Lola Run", "MSHOT-LR98") {
}
modifier preSaleActive() {
}
modifier publicSaleActive() {
}
modifier onlyAdmin() {
}
modifier onlyAdminMinter() {
}
function mint(uint256 quantity)
external
payable
publicSaleActive
nonReentrant
{
}
function whitelistMint(uint256 quantity, bytes32[] calldata merkleProof)
external
payable
preSaleActive
nonReentrant
{
require(
MerkleProof.verify(
merkleProof,
whitelistMerkleRoot,
keccak256(abi.encodePacked(msg.sender))
),
"You're not whitelisted"
);
require(msg.value == presalePrice * quantity, "Incorrect eth amount");
require(<FILL_ME>)
uint256 totalMints = getBonusMintsCount(quantity) + quantity;
require(
(totalSupply() + totalMints) <= publicSupply,
"Public supply exceeded"
);
totalPresaleAddressMint[msg.sender] += totalMints;
_safeMint(msg.sender, totalMints);
}
function freeMint(uint256 quantity, bytes32[] calldata merkleProof)
external
preSaleActive
nonReentrant
{
}
function getBonusMintsCount(uint256 quantity)
internal
view
returns (uint256)
{
}
function adminMint(address recipient, uint256 quantity) external onlyAdminMinter {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function addBonusMintDetail(
uint256 quantityFrom,
uint256 quantityTo,
uint256 bonusMintAmount
) external onlyAdmin {
}
function updateBonusMintDetail(
uint256 index,
uint256 quantityFrom,
uint256 quantityTo,
uint256 bonusMintAmount
) external onlyAdmin {
}
function removeLastBonusMintDetail() external onlyAdmin {
}
function getBonusMintDetails()
public
view
returns (BonusMintDetail[] memory)
{
}
function setMaxMintAmounts(uint256 presaleMax, uint256 publicSaleMax)
external
onlyAdmin
{
}
function setPrices(uint256 prePrice, uint256 publicPrice)
external
onlyAdmin
{
}
function setBaseUriExtension(string memory baseUriExtension)
external
onlyAdmin
{
}
function setBaseTokenUri(string memory baseUri) external onlyAdmin {
}
function setWhitelistMerkleRoot(bytes32 merkleroot) external onlyAdmin {
}
function setFreeMintMerkleRoot(bytes32 merkleroot) external onlyAdmin {
}
function setPresale(bool presaleValue) external onlyAdmin {
}
function setPublicSale(bool publicSaleValue) external onlyAdmin {
}
function setRoyaltyShare(uint256 royaltyShare) external onlyAdmin {
}
function setRoyaltyReceiver(address royaltyReceiver) external onlyAdmin {
}
function setBeneficiaryAddress(address beneficiary) external onlyAdmin {
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165, AccessControl)
returns (bool)
{
}
function withdraw() external onlyAdmin {
}
}
| totalPresaleAddressMint[msg.sender]+quantity<=presaleMaxMintAmount,"Attempting to mint too many tokens" | 164,650 | totalPresaleAddressMint[msg.sender]+quantity<=presaleMaxMintAmount |
"Public supply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
///////////////////////////////////////////////////////////////////////////////////////////
// //
// ███ ███ ██████ ██ ██ ██ ███████ ███████ ██ ██ ██████ ████████ ███████ //
// ████ ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ████ ██ ██ ██ ██ ██ ██ █████ ███████ ███████ ██ ██ ██ ███████ //
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ██ ██████ ████ ██ ███████ ███████ ██ ██ ██████ ██ ███████ //
// //
///////////////////////////////////////////////////////////////////////////////////////////
contract MovieShotLR98 is ERC721AQueryable, IERC2981, AccessControl, ReentrancyGuard {
struct BonusMintDetail {
uint256 quantityFrom;
uint256 quantityTo;
uint256 bonusAmount;
}
bytes32 public constant ADMIN_MINTER_ROLE = keccak256("ADMIN_MINTER_ROLE");
uint256 public immutable maxSupply;
uint256 public immutable publicSupply;
bool public isPublicSaleActive = false;
bool public isPresaleActive = false;
bytes32 public whitelistMerkleRoot;
bytes32 public freemintMerkleRoot;
address public beneficiaryAddress;
address public royaltyAddress;
uint256 public royaltyShare10000;
uint256 public publicSalePrice;
uint256 public publicSaleMaxMintAmount;
uint256 public presalePrice;
uint256 public presaleMaxMintAmount;
mapping(address => uint256) public totalPresaleAddressMint;
mapping(address => bool) public freeMintClaimed;
BonusMintDetail[] public bonusMintDetails;
string private baseTokenUri;
string private baseExtension;
constructor(
uint256 maxTokenSupply,
address adminMinter,
address beneficiary,
address defaultAdmin,
address royaltyReceiver,
string memory baseUri,
string memory baseUriExtension
) ERC721A("MovieShots - Run Lola Run", "MSHOT-LR98") {
}
modifier preSaleActive() {
}
modifier publicSaleActive() {
}
modifier onlyAdmin() {
}
modifier onlyAdminMinter() {
}
function mint(uint256 quantity)
external
payable
publicSaleActive
nonReentrant
{
}
function whitelistMint(uint256 quantity, bytes32[] calldata merkleProof)
external
payable
preSaleActive
nonReentrant
{
require(
MerkleProof.verify(
merkleProof,
whitelistMerkleRoot,
keccak256(abi.encodePacked(msg.sender))
),
"You're not whitelisted"
);
require(msg.value == presalePrice * quantity, "Incorrect eth amount");
require(
totalPresaleAddressMint[msg.sender] + quantity <=
presaleMaxMintAmount,
"Attempting to mint too many tokens"
);
uint256 totalMints = getBonusMintsCount(quantity) + quantity;
require(<FILL_ME>)
totalPresaleAddressMint[msg.sender] += totalMints;
_safeMint(msg.sender, totalMints);
}
function freeMint(uint256 quantity, bytes32[] calldata merkleProof)
external
preSaleActive
nonReentrant
{
}
function getBonusMintsCount(uint256 quantity)
internal
view
returns (uint256)
{
}
function adminMint(address recipient, uint256 quantity) external onlyAdminMinter {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function addBonusMintDetail(
uint256 quantityFrom,
uint256 quantityTo,
uint256 bonusMintAmount
) external onlyAdmin {
}
function updateBonusMintDetail(
uint256 index,
uint256 quantityFrom,
uint256 quantityTo,
uint256 bonusMintAmount
) external onlyAdmin {
}
function removeLastBonusMintDetail() external onlyAdmin {
}
function getBonusMintDetails()
public
view
returns (BonusMintDetail[] memory)
{
}
function setMaxMintAmounts(uint256 presaleMax, uint256 publicSaleMax)
external
onlyAdmin
{
}
function setPrices(uint256 prePrice, uint256 publicPrice)
external
onlyAdmin
{
}
function setBaseUriExtension(string memory baseUriExtension)
external
onlyAdmin
{
}
function setBaseTokenUri(string memory baseUri) external onlyAdmin {
}
function setWhitelistMerkleRoot(bytes32 merkleroot) external onlyAdmin {
}
function setFreeMintMerkleRoot(bytes32 merkleroot) external onlyAdmin {
}
function setPresale(bool presaleValue) external onlyAdmin {
}
function setPublicSale(bool publicSaleValue) external onlyAdmin {
}
function setRoyaltyShare(uint256 royaltyShare) external onlyAdmin {
}
function setRoyaltyReceiver(address royaltyReceiver) external onlyAdmin {
}
function setBeneficiaryAddress(address beneficiary) external onlyAdmin {
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165, AccessControl)
returns (bool)
{
}
function withdraw() external onlyAdmin {
}
}
| (totalSupply()+totalMints)<=publicSupply,"Public supply exceeded" | 164,650 | (totalSupply()+totalMints)<=publicSupply |
"You're not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
///////////////////////////////////////////////////////////////////////////////////////////
// //
// ███ ███ ██████ ██ ██ ██ ███████ ███████ ██ ██ ██████ ████████ ███████ //
// ████ ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ████ ██ ██ ██ ██ ██ ██ █████ ███████ ███████ ██ ██ ██ ███████ //
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ██ ██████ ████ ██ ███████ ███████ ██ ██ ██████ ██ ███████ //
// //
///////////////////////////////////////////////////////////////////////////////////////////
contract MovieShotLR98 is ERC721AQueryable, IERC2981, AccessControl, ReentrancyGuard {
struct BonusMintDetail {
uint256 quantityFrom;
uint256 quantityTo;
uint256 bonusAmount;
}
bytes32 public constant ADMIN_MINTER_ROLE = keccak256("ADMIN_MINTER_ROLE");
uint256 public immutable maxSupply;
uint256 public immutable publicSupply;
bool public isPublicSaleActive = false;
bool public isPresaleActive = false;
bytes32 public whitelistMerkleRoot;
bytes32 public freemintMerkleRoot;
address public beneficiaryAddress;
address public royaltyAddress;
uint256 public royaltyShare10000;
uint256 public publicSalePrice;
uint256 public publicSaleMaxMintAmount;
uint256 public presalePrice;
uint256 public presaleMaxMintAmount;
mapping(address => uint256) public totalPresaleAddressMint;
mapping(address => bool) public freeMintClaimed;
BonusMintDetail[] public bonusMintDetails;
string private baseTokenUri;
string private baseExtension;
constructor(
uint256 maxTokenSupply,
address adminMinter,
address beneficiary,
address defaultAdmin,
address royaltyReceiver,
string memory baseUri,
string memory baseUriExtension
) ERC721A("MovieShots - Run Lola Run", "MSHOT-LR98") {
}
modifier preSaleActive() {
}
modifier publicSaleActive() {
}
modifier onlyAdmin() {
}
modifier onlyAdminMinter() {
}
function mint(uint256 quantity)
external
payable
publicSaleActive
nonReentrant
{
}
function whitelistMint(uint256 quantity, bytes32[] calldata merkleProof)
external
payable
preSaleActive
nonReentrant
{
}
function freeMint(uint256 quantity, bytes32[] calldata merkleProof)
external
preSaleActive
nonReentrant
{
require(<FILL_ME>)
require(
(totalSupply() + quantity) <= publicSupply,
"Public supply exceeded"
);
require(!freeMintClaimed[msg.sender], "Free mints already claimed");
freeMintClaimed[msg.sender] = true;
_safeMint(msg.sender, quantity);
}
function getBonusMintsCount(uint256 quantity)
internal
view
returns (uint256)
{
}
function adminMint(address recipient, uint256 quantity) external onlyAdminMinter {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function addBonusMintDetail(
uint256 quantityFrom,
uint256 quantityTo,
uint256 bonusMintAmount
) external onlyAdmin {
}
function updateBonusMintDetail(
uint256 index,
uint256 quantityFrom,
uint256 quantityTo,
uint256 bonusMintAmount
) external onlyAdmin {
}
function removeLastBonusMintDetail() external onlyAdmin {
}
function getBonusMintDetails()
public
view
returns (BonusMintDetail[] memory)
{
}
function setMaxMintAmounts(uint256 presaleMax, uint256 publicSaleMax)
external
onlyAdmin
{
}
function setPrices(uint256 prePrice, uint256 publicPrice)
external
onlyAdmin
{
}
function setBaseUriExtension(string memory baseUriExtension)
external
onlyAdmin
{
}
function setBaseTokenUri(string memory baseUri) external onlyAdmin {
}
function setWhitelistMerkleRoot(bytes32 merkleroot) external onlyAdmin {
}
function setFreeMintMerkleRoot(bytes32 merkleroot) external onlyAdmin {
}
function setPresale(bool presaleValue) external onlyAdmin {
}
function setPublicSale(bool publicSaleValue) external onlyAdmin {
}
function setRoyaltyShare(uint256 royaltyShare) external onlyAdmin {
}
function setRoyaltyReceiver(address royaltyReceiver) external onlyAdmin {
}
function setBeneficiaryAddress(address beneficiary) external onlyAdmin {
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165, AccessControl)
returns (bool)
{
}
function withdraw() external onlyAdmin {
}
}
| MerkleProof.verify(merkleProof,freemintMerkleRoot,keccak256(abi.encodePacked(msg.sender,quantity))),"You're not whitelisted" | 164,650 | MerkleProof.verify(merkleProof,freemintMerkleRoot,keccak256(abi.encodePacked(msg.sender,quantity))) |
"Free mints already claimed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
///////////////////////////////////////////////////////////////////////////////////////////
// //
// ███ ███ ██████ ██ ██ ██ ███████ ███████ ██ ██ ██████ ████████ ███████ //
// ████ ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ████ ██ ██ ██ ██ ██ ██ █████ ███████ ███████ ██ ██ ██ ███████ //
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ██ ██████ ████ ██ ███████ ███████ ██ ██ ██████ ██ ███████ //
// //
///////////////////////////////////////////////////////////////////////////////////////////
contract MovieShotLR98 is ERC721AQueryable, IERC2981, AccessControl, ReentrancyGuard {
struct BonusMintDetail {
uint256 quantityFrom;
uint256 quantityTo;
uint256 bonusAmount;
}
bytes32 public constant ADMIN_MINTER_ROLE = keccak256("ADMIN_MINTER_ROLE");
uint256 public immutable maxSupply;
uint256 public immutable publicSupply;
bool public isPublicSaleActive = false;
bool public isPresaleActive = false;
bytes32 public whitelistMerkleRoot;
bytes32 public freemintMerkleRoot;
address public beneficiaryAddress;
address public royaltyAddress;
uint256 public royaltyShare10000;
uint256 public publicSalePrice;
uint256 public publicSaleMaxMintAmount;
uint256 public presalePrice;
uint256 public presaleMaxMintAmount;
mapping(address => uint256) public totalPresaleAddressMint;
mapping(address => bool) public freeMintClaimed;
BonusMintDetail[] public bonusMintDetails;
string private baseTokenUri;
string private baseExtension;
constructor(
uint256 maxTokenSupply,
address adminMinter,
address beneficiary,
address defaultAdmin,
address royaltyReceiver,
string memory baseUri,
string memory baseUriExtension
) ERC721A("MovieShots - Run Lola Run", "MSHOT-LR98") {
}
modifier preSaleActive() {
}
modifier publicSaleActive() {
}
modifier onlyAdmin() {
}
modifier onlyAdminMinter() {
}
function mint(uint256 quantity)
external
payable
publicSaleActive
nonReentrant
{
}
function whitelistMint(uint256 quantity, bytes32[] calldata merkleProof)
external
payable
preSaleActive
nonReentrant
{
}
function freeMint(uint256 quantity, bytes32[] calldata merkleProof)
external
preSaleActive
nonReentrant
{
require(
MerkleProof.verify(
merkleProof,
freemintMerkleRoot,
keccak256(abi.encodePacked(msg.sender, quantity))
),
"You're not whitelisted"
);
require(
(totalSupply() + quantity) <= publicSupply,
"Public supply exceeded"
);
require(<FILL_ME>)
freeMintClaimed[msg.sender] = true;
_safeMint(msg.sender, quantity);
}
function getBonusMintsCount(uint256 quantity)
internal
view
returns (uint256)
{
}
function adminMint(address recipient, uint256 quantity) external onlyAdminMinter {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function addBonusMintDetail(
uint256 quantityFrom,
uint256 quantityTo,
uint256 bonusMintAmount
) external onlyAdmin {
}
function updateBonusMintDetail(
uint256 index,
uint256 quantityFrom,
uint256 quantityTo,
uint256 bonusMintAmount
) external onlyAdmin {
}
function removeLastBonusMintDetail() external onlyAdmin {
}
function getBonusMintDetails()
public
view
returns (BonusMintDetail[] memory)
{
}
function setMaxMintAmounts(uint256 presaleMax, uint256 publicSaleMax)
external
onlyAdmin
{
}
function setPrices(uint256 prePrice, uint256 publicPrice)
external
onlyAdmin
{
}
function setBaseUriExtension(string memory baseUriExtension)
external
onlyAdmin
{
}
function setBaseTokenUri(string memory baseUri) external onlyAdmin {
}
function setWhitelistMerkleRoot(bytes32 merkleroot) external onlyAdmin {
}
function setFreeMintMerkleRoot(bytes32 merkleroot) external onlyAdmin {
}
function setPresale(bool presaleValue) external onlyAdmin {
}
function setPublicSale(bool publicSaleValue) external onlyAdmin {
}
function setRoyaltyShare(uint256 royaltyShare) external onlyAdmin {
}
function setRoyaltyReceiver(address royaltyReceiver) external onlyAdmin {
}
function setBeneficiaryAddress(address beneficiary) external onlyAdmin {
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165, AccessControl)
returns (bool)
{
}
function withdraw() external onlyAdmin {
}
}
| !freeMintClaimed[msg.sender],"Free mints already claimed" | 164,650 | !freeMintClaimed[msg.sender] |
"Too many" | // SPDX-License-Identifier: MIT
//
// *%@@@@@@@@@@@@@@@@@@@&#.
// @@@@@@@( (&@@@@@@ @& (@@@@@@@@# (@@@
// @ @@@@@@@@@@@@@@ @ @@ &@ @@@@@@@@@@@@@@@@@@ *@
// @ &@ @@ @@@ /@@@* @ @@@@@@ @@@@@@@@@@@@@@@@@@ @@*
// @@@@@@& @*,@% @ @ @ @@@@@@. @@@@@@@@@@@@@@@@% @@ @
// @@ (@@@@. @ .@ @@ @@ @ (@ @@@@@ @ @@@@@@ @@ @@@@@@@@@@@@@@ @@@@@/*@
// @ @@@@@@@ @@@ @@ @ @@@ @@ @ #@@ @@@@ /@ @@@@@ @@@@@@@@@@@@@@@@@@ @@% @@@@@@ @
// @. @% @@@@ /@@@@ &@ /@ @@@ @ @ @@@@ @@@@ @ &@@@@@ @@@@@@@@@@@@@ *@@@@@@@@@@* .@@
// @ @@@@@@@@ @ %@@@@@@ @* @..@@@ &, @* @@@@@ @@@@ &@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@ @%
// @ #@@(@@@@( @@@@@@@@ @ @ /@@@@ /@@@@@@@@@#%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@* @/
// @ @@@@@@@@@@@@@@ @. @/ @@@@@@@@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@#. *@@@@@@@@# #@%
// @ @@@@@@@@@ @@@@@@ @ .@@ @ @@@@@@@@@@@@@@@@@* @@@@@@@@@@@@@@@@@@@ @@@@@ @@ % @@@@@@@@@@@@ @
// #@@ /@@@@@@@@@@ @# (@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ ,@@@@@@@@@@ @@@@@@@@@@@@@. @
// @ @@@@@@@@@ @@@@@@@@@@@@@@@@@@@ %@@@@@@@@@@@@@@@@@@@ @@@@@@@ @@@@@@@@ @( @@@@@@@@@@@@@, @
// %@ &@@@@@@@@@@@@@@@@@@@@@ ,@ @@ @@@@@@@@@@ %@@@@@@@@@@, @ @@@ @ @@@@@@@@@@@@@@@@ @
// @@ @@@@@@@@@@@@@@( @@ @ @@@@@@@@@& *@@@@@@@@@@@( @ @@@@@@@@@@@@@@@@@@(.@
// @@@&. %@@@, @ *@@@@@@@@ @@% @@ ( @@ @ @% @@@/@@@@@@@@@@@@@*.@
// .%@&/ @ @@@@@@@@ @# &@@@ ((((((, @@ &% @.,@@ @@@@@ @@@@ @@ @
// %@, %@@@@ @@ @@ @@@@@@@& @@@# ( (@@@ (((( @@@ @ @ @@@@@@@@ @@@@ @@
// @& %, @@@@@@ ( @@ %@@@@ @@@@@@@@@@@@% * @@ ((((( @@ @/ @@ . . @
// @ #@@@@@@ ((( (((((((. %@. @@@@@@@@@@ ((((((((((( @@@ @
// @% @@@@@@@ *@@@@@ (((((( @@@ %@ @@@@/ (((((((((((. @@ @
// @ @@@@@@@@@@ ,@@@@ ((* . @ @@ /(((((((( @@**@
// @@ ,@@@@@@@@@@@& @@@@ ((( @& .@ (((((((( @@@ @
// @@ .@@@@@@@@@@@@( &@@@ ,( @ @ @@@@@@ &@@ @
// @@ @@@@@@@@@@@@& &@@ @ *@ @@@@@@@/,@@ @
// @@. .@@@@@@@@@@ @ .@ @@@@@@& @@ @
// .@@( ,@@@@@ *@ @@ ,@@
// &@@@@#
//
pragma solidity ^0.8.17;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {UpdatableOperatorFilterer} from "operator-filter-registry/src/UpdatableOperatorFilterer.sol";
import {RevokableDefaultOperatorFilterer} from "operator-filter-registry/src/RevokableDefaultOperatorFilterer.sol";
interface ogcontract {
function ownerOf(uint256 tokenId) external view returns (address owner);
function burn(uint256 tokenId) external;
}
interface Delegate {
function checkDelegateForAll(address delegate, address vault) external view returns (bool);
}
contract SCUM is ERC721AQueryable, Ownable, RevokableDefaultOperatorFilterer, ReentrancyGuard {
address private OGContract = 0xAc5Aeb3b4Ac8797c2307320Ed00a84B869ab9333;
address private signer = 0x2f2A13462f6d4aF64954ee84641D265932849b64;
string public _metadataRegular = "ipfs://QmY2oBi4p5zASJmzbjxMrn3poBj5QZFKxwF6zBpg8puVRt";
string public _metadataSOTY = "ipfs://QmbZ7NNu4A9qoxGwMHFw4n92dpz7zCCJbsFJPgdtpvdyqE";
uint256 public regularMinted = 0;
uint256 public SOTYMinted = 0;
uint256 private maxBurnPerWallet = 5;
uint256 private MAX_REGULAR_MINT = 250;
uint256 private MAX_SOTY_MINT = 25;
mapping(uint256 => uint256) public tokenMapping;
mapping(uint256 => uint256) public tokenType;
mapping(address => uint256) public totalMintedRegular;
mapping(address => bool) public mintedSOTY;
bool burnActive = false;
constructor() ERC721A("SCUMBAGS", "SCUM") {}
function burnToken(uint256[] memory tokenIds) public nonReentrant {
require(burnActive, "Burn not Active");
uint256 amount = tokenIds.length;
require(msg.sender == tx.origin, "EOA only");
require(<FILL_ME>)
require(regularMinted + amount <= MAX_REGULAR_MINT, "Minted out");
totalMintedRegular[msg.sender] += amount;
regularMinted += amount;
_mint(msg.sender, tokenIds.length);
for(uint256 i = 0; i < tokenIds.length; i++)
_burnOG(tokenIds[i]);
}
function _burnOG(uint256 tokenId) internal {
}
function adminMint(bool isSOTY, address wallet) public onlyOwner {
}
function claimSOTY(address wallet, bytes calldata voucher, bool delegate) public nonReentrant {
}
function _verifySignature(address _signer, bytes32 _hash, bytes memory _signature) internal pure returns (bool) {
}
function setMaxBurnPerWallet(uint256 _amount) public onlyOwner {
}
function setSigner(address _signer) public onlyOwner {
}
function setOGContract(address _addr) public onlyOwner {
}
function setMetadataRegular(string memory metadata) public onlyOwner {
}
function setMetadataSOTY(string memory metadata) public onlyOwner {
}
function setBurn(bool _state) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
function _baseURIRegular() internal view virtual returns(string memory) {
}
function _baseURISOTY() internal view virtual returns(string memory) {
}
function setApprovalForAll(
address operator,
bool approved
) public override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function owner() public view override(Ownable, UpdatableOperatorFilterer) returns (address) {
}
}
| amount+totalMintedRegular[msg.sender]<=maxBurnPerWallet,"Too many" | 164,726 | amount+totalMintedRegular[msg.sender]<=maxBurnPerWallet |
"Minted out" | // SPDX-License-Identifier: MIT
//
// *%@@@@@@@@@@@@@@@@@@@&#.
// @@@@@@@( (&@@@@@@ @& (@@@@@@@@# (@@@
// @ @@@@@@@@@@@@@@ @ @@ &@ @@@@@@@@@@@@@@@@@@ *@
// @ &@ @@ @@@ /@@@* @ @@@@@@ @@@@@@@@@@@@@@@@@@ @@*
// @@@@@@& @*,@% @ @ @ @@@@@@. @@@@@@@@@@@@@@@@% @@ @
// @@ (@@@@. @ .@ @@ @@ @ (@ @@@@@ @ @@@@@@ @@ @@@@@@@@@@@@@@ @@@@@/*@
// @ @@@@@@@ @@@ @@ @ @@@ @@ @ #@@ @@@@ /@ @@@@@ @@@@@@@@@@@@@@@@@@ @@% @@@@@@ @
// @. @% @@@@ /@@@@ &@ /@ @@@ @ @ @@@@ @@@@ @ &@@@@@ @@@@@@@@@@@@@ *@@@@@@@@@@* .@@
// @ @@@@@@@@ @ %@@@@@@ @* @..@@@ &, @* @@@@@ @@@@ &@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@ @%
// @ #@@(@@@@( @@@@@@@@ @ @ /@@@@ /@@@@@@@@@#%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@* @/
// @ @@@@@@@@@@@@@@ @. @/ @@@@@@@@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@#. *@@@@@@@@# #@%
// @ @@@@@@@@@ @@@@@@ @ .@@ @ @@@@@@@@@@@@@@@@@* @@@@@@@@@@@@@@@@@@@ @@@@@ @@ % @@@@@@@@@@@@ @
// #@@ /@@@@@@@@@@ @# (@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ ,@@@@@@@@@@ @@@@@@@@@@@@@. @
// @ @@@@@@@@@ @@@@@@@@@@@@@@@@@@@ %@@@@@@@@@@@@@@@@@@@ @@@@@@@ @@@@@@@@ @( @@@@@@@@@@@@@, @
// %@ &@@@@@@@@@@@@@@@@@@@@@ ,@ @@ @@@@@@@@@@ %@@@@@@@@@@, @ @@@ @ @@@@@@@@@@@@@@@@ @
// @@ @@@@@@@@@@@@@@( @@ @ @@@@@@@@@& *@@@@@@@@@@@( @ @@@@@@@@@@@@@@@@@@(.@
// @@@&. %@@@, @ *@@@@@@@@ @@% @@ ( @@ @ @% @@@/@@@@@@@@@@@@@*.@
// .%@&/ @ @@@@@@@@ @# &@@@ ((((((, @@ &% @.,@@ @@@@@ @@@@ @@ @
// %@, %@@@@ @@ @@ @@@@@@@& @@@# ( (@@@ (((( @@@ @ @ @@@@@@@@ @@@@ @@
// @& %, @@@@@@ ( @@ %@@@@ @@@@@@@@@@@@% * @@ ((((( @@ @/ @@ . . @
// @ #@@@@@@ ((( (((((((. %@. @@@@@@@@@@ ((((((((((( @@@ @
// @% @@@@@@@ *@@@@@ (((((( @@@ %@ @@@@/ (((((((((((. @@ @
// @ @@@@@@@@@@ ,@@@@ ((* . @ @@ /(((((((( @@**@
// @@ ,@@@@@@@@@@@& @@@@ ((( @& .@ (((((((( @@@ @
// @@ .@@@@@@@@@@@@( &@@@ ,( @ @ @@@@@@ &@@ @
// @@ @@@@@@@@@@@@& &@@ @ *@ @@@@@@@/,@@ @
// @@. .@@@@@@@@@@ @ .@ @@@@@@& @@ @
// .@@( ,@@@@@ *@ @@ ,@@
// &@@@@#
//
pragma solidity ^0.8.17;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {UpdatableOperatorFilterer} from "operator-filter-registry/src/UpdatableOperatorFilterer.sol";
import {RevokableDefaultOperatorFilterer} from "operator-filter-registry/src/RevokableDefaultOperatorFilterer.sol";
interface ogcontract {
function ownerOf(uint256 tokenId) external view returns (address owner);
function burn(uint256 tokenId) external;
}
interface Delegate {
function checkDelegateForAll(address delegate, address vault) external view returns (bool);
}
contract SCUM is ERC721AQueryable, Ownable, RevokableDefaultOperatorFilterer, ReentrancyGuard {
address private OGContract = 0xAc5Aeb3b4Ac8797c2307320Ed00a84B869ab9333;
address private signer = 0x2f2A13462f6d4aF64954ee84641D265932849b64;
string public _metadataRegular = "ipfs://QmY2oBi4p5zASJmzbjxMrn3poBj5QZFKxwF6zBpg8puVRt";
string public _metadataSOTY = "ipfs://QmbZ7NNu4A9qoxGwMHFw4n92dpz7zCCJbsFJPgdtpvdyqE";
uint256 public regularMinted = 0;
uint256 public SOTYMinted = 0;
uint256 private maxBurnPerWallet = 5;
uint256 private MAX_REGULAR_MINT = 250;
uint256 private MAX_SOTY_MINT = 25;
mapping(uint256 => uint256) public tokenMapping;
mapping(uint256 => uint256) public tokenType;
mapping(address => uint256) public totalMintedRegular;
mapping(address => bool) public mintedSOTY;
bool burnActive = false;
constructor() ERC721A("SCUMBAGS", "SCUM") {}
function burnToken(uint256[] memory tokenIds) public nonReentrant {
require(burnActive, "Burn not Active");
uint256 amount = tokenIds.length;
require(msg.sender == tx.origin, "EOA only");
require(amount + totalMintedRegular[msg.sender] <= maxBurnPerWallet, "Too many");
require(<FILL_ME>)
totalMintedRegular[msg.sender] += amount;
regularMinted += amount;
_mint(msg.sender, tokenIds.length);
for(uint256 i = 0; i < tokenIds.length; i++)
_burnOG(tokenIds[i]);
}
function _burnOG(uint256 tokenId) internal {
}
function adminMint(bool isSOTY, address wallet) public onlyOwner {
}
function claimSOTY(address wallet, bytes calldata voucher, bool delegate) public nonReentrant {
}
function _verifySignature(address _signer, bytes32 _hash, bytes memory _signature) internal pure returns (bool) {
}
function setMaxBurnPerWallet(uint256 _amount) public onlyOwner {
}
function setSigner(address _signer) public onlyOwner {
}
function setOGContract(address _addr) public onlyOwner {
}
function setMetadataRegular(string memory metadata) public onlyOwner {
}
function setMetadataSOTY(string memory metadata) public onlyOwner {
}
function setBurn(bool _state) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
function _baseURIRegular() internal view virtual returns(string memory) {
}
function _baseURISOTY() internal view virtual returns(string memory) {
}
function setApprovalForAll(
address operator,
bool approved
) public override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function owner() public view override(Ownable, UpdatableOperatorFilterer) returns (address) {
}
}
| regularMinted+amount<=MAX_REGULAR_MINT,"Minted out" | 164,726 | regularMinted+amount<=MAX_REGULAR_MINT |
"Minted out" | // SPDX-License-Identifier: MIT
//
// *%@@@@@@@@@@@@@@@@@@@&#.
// @@@@@@@( (&@@@@@@ @& (@@@@@@@@# (@@@
// @ @@@@@@@@@@@@@@ @ @@ &@ @@@@@@@@@@@@@@@@@@ *@
// @ &@ @@ @@@ /@@@* @ @@@@@@ @@@@@@@@@@@@@@@@@@ @@*
// @@@@@@& @*,@% @ @ @ @@@@@@. @@@@@@@@@@@@@@@@% @@ @
// @@ (@@@@. @ .@ @@ @@ @ (@ @@@@@ @ @@@@@@ @@ @@@@@@@@@@@@@@ @@@@@/*@
// @ @@@@@@@ @@@ @@ @ @@@ @@ @ #@@ @@@@ /@ @@@@@ @@@@@@@@@@@@@@@@@@ @@% @@@@@@ @
// @. @% @@@@ /@@@@ &@ /@ @@@ @ @ @@@@ @@@@ @ &@@@@@ @@@@@@@@@@@@@ *@@@@@@@@@@* .@@
// @ @@@@@@@@ @ %@@@@@@ @* @..@@@ &, @* @@@@@ @@@@ &@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@ @%
// @ #@@(@@@@( @@@@@@@@ @ @ /@@@@ /@@@@@@@@@#%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@* @/
// @ @@@@@@@@@@@@@@ @. @/ @@@@@@@@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@#. *@@@@@@@@# #@%
// @ @@@@@@@@@ @@@@@@ @ .@@ @ @@@@@@@@@@@@@@@@@* @@@@@@@@@@@@@@@@@@@ @@@@@ @@ % @@@@@@@@@@@@ @
// #@@ /@@@@@@@@@@ @# (@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ ,@@@@@@@@@@ @@@@@@@@@@@@@. @
// @ @@@@@@@@@ @@@@@@@@@@@@@@@@@@@ %@@@@@@@@@@@@@@@@@@@ @@@@@@@ @@@@@@@@ @( @@@@@@@@@@@@@, @
// %@ &@@@@@@@@@@@@@@@@@@@@@ ,@ @@ @@@@@@@@@@ %@@@@@@@@@@, @ @@@ @ @@@@@@@@@@@@@@@@ @
// @@ @@@@@@@@@@@@@@( @@ @ @@@@@@@@@& *@@@@@@@@@@@( @ @@@@@@@@@@@@@@@@@@(.@
// @@@&. %@@@, @ *@@@@@@@@ @@% @@ ( @@ @ @% @@@/@@@@@@@@@@@@@*.@
// .%@&/ @ @@@@@@@@ @# &@@@ ((((((, @@ &% @.,@@ @@@@@ @@@@ @@ @
// %@, %@@@@ @@ @@ @@@@@@@& @@@# ( (@@@ (((( @@@ @ @ @@@@@@@@ @@@@ @@
// @& %, @@@@@@ ( @@ %@@@@ @@@@@@@@@@@@% * @@ ((((( @@ @/ @@ . . @
// @ #@@@@@@ ((( (((((((. %@. @@@@@@@@@@ ((((((((((( @@@ @
// @% @@@@@@@ *@@@@@ (((((( @@@ %@ @@@@/ (((((((((((. @@ @
// @ @@@@@@@@@@ ,@@@@ ((* . @ @@ /(((((((( @@**@
// @@ ,@@@@@@@@@@@& @@@@ ((( @& .@ (((((((( @@@ @
// @@ .@@@@@@@@@@@@( &@@@ ,( @ @ @@@@@@ &@@ @
// @@ @@@@@@@@@@@@& &@@ @ *@ @@@@@@@/,@@ @
// @@. .@@@@@@@@@@ @ .@ @@@@@@& @@ @
// .@@( ,@@@@@ *@ @@ ,@@
// &@@@@#
//
pragma solidity ^0.8.17;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {UpdatableOperatorFilterer} from "operator-filter-registry/src/UpdatableOperatorFilterer.sol";
import {RevokableDefaultOperatorFilterer} from "operator-filter-registry/src/RevokableDefaultOperatorFilterer.sol";
interface ogcontract {
function ownerOf(uint256 tokenId) external view returns (address owner);
function burn(uint256 tokenId) external;
}
interface Delegate {
function checkDelegateForAll(address delegate, address vault) external view returns (bool);
}
contract SCUM is ERC721AQueryable, Ownable, RevokableDefaultOperatorFilterer, ReentrancyGuard {
address private OGContract = 0xAc5Aeb3b4Ac8797c2307320Ed00a84B869ab9333;
address private signer = 0x2f2A13462f6d4aF64954ee84641D265932849b64;
string public _metadataRegular = "ipfs://QmY2oBi4p5zASJmzbjxMrn3poBj5QZFKxwF6zBpg8puVRt";
string public _metadataSOTY = "ipfs://QmbZ7NNu4A9qoxGwMHFw4n92dpz7zCCJbsFJPgdtpvdyqE";
uint256 public regularMinted = 0;
uint256 public SOTYMinted = 0;
uint256 private maxBurnPerWallet = 5;
uint256 private MAX_REGULAR_MINT = 250;
uint256 private MAX_SOTY_MINT = 25;
mapping(uint256 => uint256) public tokenMapping;
mapping(uint256 => uint256) public tokenType;
mapping(address => uint256) public totalMintedRegular;
mapping(address => bool) public mintedSOTY;
bool burnActive = false;
constructor() ERC721A("SCUMBAGS", "SCUM") {}
function burnToken(uint256[] memory tokenIds) public nonReentrant {
}
function _burnOG(uint256 tokenId) internal {
}
function adminMint(bool isSOTY, address wallet) public onlyOwner {
if(isSOTY){
require(<FILL_ME>)
uint16 mintId = uint16(_totalMinted());
tokenMapping[mintId] = SOTYMinted;
tokenType[mintId] = 1;
SOTYMinted += 1;
}
else{
require(regularMinted + 1 <= MAX_REGULAR_MINT, "Minted out");
totalMintedRegular[wallet] += 1;
regularMinted += 1;
}
_mint(wallet, 1);
}
function claimSOTY(address wallet, bytes calldata voucher, bool delegate) public nonReentrant {
}
function _verifySignature(address _signer, bytes32 _hash, bytes memory _signature) internal pure returns (bool) {
}
function setMaxBurnPerWallet(uint256 _amount) public onlyOwner {
}
function setSigner(address _signer) public onlyOwner {
}
function setOGContract(address _addr) public onlyOwner {
}
function setMetadataRegular(string memory metadata) public onlyOwner {
}
function setMetadataSOTY(string memory metadata) public onlyOwner {
}
function setBurn(bool _state) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
function _baseURIRegular() internal view virtual returns(string memory) {
}
function _baseURISOTY() internal view virtual returns(string memory) {
}
function setApprovalForAll(
address operator,
bool approved
) public override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function owner() public view override(Ownable, UpdatableOperatorFilterer) returns (address) {
}
}
| SOTYMinted+1<=MAX_SOTY_MINT,"Minted out" | 164,726 | SOTYMinted+1<=MAX_SOTY_MINT |
"Minted out" | // SPDX-License-Identifier: MIT
//
// *%@@@@@@@@@@@@@@@@@@@&#.
// @@@@@@@( (&@@@@@@ @& (@@@@@@@@# (@@@
// @ @@@@@@@@@@@@@@ @ @@ &@ @@@@@@@@@@@@@@@@@@ *@
// @ &@ @@ @@@ /@@@* @ @@@@@@ @@@@@@@@@@@@@@@@@@ @@*
// @@@@@@& @*,@% @ @ @ @@@@@@. @@@@@@@@@@@@@@@@% @@ @
// @@ (@@@@. @ .@ @@ @@ @ (@ @@@@@ @ @@@@@@ @@ @@@@@@@@@@@@@@ @@@@@/*@
// @ @@@@@@@ @@@ @@ @ @@@ @@ @ #@@ @@@@ /@ @@@@@ @@@@@@@@@@@@@@@@@@ @@% @@@@@@ @
// @. @% @@@@ /@@@@ &@ /@ @@@ @ @ @@@@ @@@@ @ &@@@@@ @@@@@@@@@@@@@ *@@@@@@@@@@* .@@
// @ @@@@@@@@ @ %@@@@@@ @* @..@@@ &, @* @@@@@ @@@@ &@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@ @%
// @ #@@(@@@@( @@@@@@@@ @ @ /@@@@ /@@@@@@@@@#%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@* @/
// @ @@@@@@@@@@@@@@ @. @/ @@@@@@@@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@#. *@@@@@@@@# #@%
// @ @@@@@@@@@ @@@@@@ @ .@@ @ @@@@@@@@@@@@@@@@@* @@@@@@@@@@@@@@@@@@@ @@@@@ @@ % @@@@@@@@@@@@ @
// #@@ /@@@@@@@@@@ @# (@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ ,@@@@@@@@@@ @@@@@@@@@@@@@. @
// @ @@@@@@@@@ @@@@@@@@@@@@@@@@@@@ %@@@@@@@@@@@@@@@@@@@ @@@@@@@ @@@@@@@@ @( @@@@@@@@@@@@@, @
// %@ &@@@@@@@@@@@@@@@@@@@@@ ,@ @@ @@@@@@@@@@ %@@@@@@@@@@, @ @@@ @ @@@@@@@@@@@@@@@@ @
// @@ @@@@@@@@@@@@@@( @@ @ @@@@@@@@@& *@@@@@@@@@@@( @ @@@@@@@@@@@@@@@@@@(.@
// @@@&. %@@@, @ *@@@@@@@@ @@% @@ ( @@ @ @% @@@/@@@@@@@@@@@@@*.@
// .%@&/ @ @@@@@@@@ @# &@@@ ((((((, @@ &% @.,@@ @@@@@ @@@@ @@ @
// %@, %@@@@ @@ @@ @@@@@@@& @@@# ( (@@@ (((( @@@ @ @ @@@@@@@@ @@@@ @@
// @& %, @@@@@@ ( @@ %@@@@ @@@@@@@@@@@@% * @@ ((((( @@ @/ @@ . . @
// @ #@@@@@@ ((( (((((((. %@. @@@@@@@@@@ ((((((((((( @@@ @
// @% @@@@@@@ *@@@@@ (((((( @@@ %@ @@@@/ (((((((((((. @@ @
// @ @@@@@@@@@@ ,@@@@ ((* . @ @@ /(((((((( @@**@
// @@ ,@@@@@@@@@@@& @@@@ ((( @& .@ (((((((( @@@ @
// @@ .@@@@@@@@@@@@( &@@@ ,( @ @ @@@@@@ &@@ @
// @@ @@@@@@@@@@@@& &@@ @ *@ @@@@@@@/,@@ @
// @@. .@@@@@@@@@@ @ .@ @@@@@@& @@ @
// .@@( ,@@@@@ *@ @@ ,@@
// &@@@@#
//
pragma solidity ^0.8.17;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {UpdatableOperatorFilterer} from "operator-filter-registry/src/UpdatableOperatorFilterer.sol";
import {RevokableDefaultOperatorFilterer} from "operator-filter-registry/src/RevokableDefaultOperatorFilterer.sol";
interface ogcontract {
function ownerOf(uint256 tokenId) external view returns (address owner);
function burn(uint256 tokenId) external;
}
interface Delegate {
function checkDelegateForAll(address delegate, address vault) external view returns (bool);
}
contract SCUM is ERC721AQueryable, Ownable, RevokableDefaultOperatorFilterer, ReentrancyGuard {
address private OGContract = 0xAc5Aeb3b4Ac8797c2307320Ed00a84B869ab9333;
address private signer = 0x2f2A13462f6d4aF64954ee84641D265932849b64;
string public _metadataRegular = "ipfs://QmY2oBi4p5zASJmzbjxMrn3poBj5QZFKxwF6zBpg8puVRt";
string public _metadataSOTY = "ipfs://QmbZ7NNu4A9qoxGwMHFw4n92dpz7zCCJbsFJPgdtpvdyqE";
uint256 public regularMinted = 0;
uint256 public SOTYMinted = 0;
uint256 private maxBurnPerWallet = 5;
uint256 private MAX_REGULAR_MINT = 250;
uint256 private MAX_SOTY_MINT = 25;
mapping(uint256 => uint256) public tokenMapping;
mapping(uint256 => uint256) public tokenType;
mapping(address => uint256) public totalMintedRegular;
mapping(address => bool) public mintedSOTY;
bool burnActive = false;
constructor() ERC721A("SCUMBAGS", "SCUM") {}
function burnToken(uint256[] memory tokenIds) public nonReentrant {
}
function _burnOG(uint256 tokenId) internal {
}
function adminMint(bool isSOTY, address wallet) public onlyOwner {
if(isSOTY){
require(SOTYMinted + 1 <= MAX_SOTY_MINT, "Minted out");
uint16 mintId = uint16(_totalMinted());
tokenMapping[mintId] = SOTYMinted;
tokenType[mintId] = 1;
SOTYMinted += 1;
}
else{
require(<FILL_ME>)
totalMintedRegular[wallet] += 1;
regularMinted += 1;
}
_mint(wallet, 1);
}
function claimSOTY(address wallet, bytes calldata voucher, bool delegate) public nonReentrant {
}
function _verifySignature(address _signer, bytes32 _hash, bytes memory _signature) internal pure returns (bool) {
}
function setMaxBurnPerWallet(uint256 _amount) public onlyOwner {
}
function setSigner(address _signer) public onlyOwner {
}
function setOGContract(address _addr) public onlyOwner {
}
function setMetadataRegular(string memory metadata) public onlyOwner {
}
function setMetadataSOTY(string memory metadata) public onlyOwner {
}
function setBurn(bool _state) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
function _baseURIRegular() internal view virtual returns(string memory) {
}
function _baseURISOTY() internal view virtual returns(string memory) {
}
function setApprovalForAll(
address operator,
bool approved
) public override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function owner() public view override(Ownable, UpdatableOperatorFilterer) returns (address) {
}
}
| regularMinted+1<=MAX_REGULAR_MINT,"Minted out" | 164,726 | regularMinted+1<=MAX_REGULAR_MINT |
"Not delegate" | // SPDX-License-Identifier: MIT
//
// *%@@@@@@@@@@@@@@@@@@@&#.
// @@@@@@@( (&@@@@@@ @& (@@@@@@@@# (@@@
// @ @@@@@@@@@@@@@@ @ @@ &@ @@@@@@@@@@@@@@@@@@ *@
// @ &@ @@ @@@ /@@@* @ @@@@@@ @@@@@@@@@@@@@@@@@@ @@*
// @@@@@@& @*,@% @ @ @ @@@@@@. @@@@@@@@@@@@@@@@% @@ @
// @@ (@@@@. @ .@ @@ @@ @ (@ @@@@@ @ @@@@@@ @@ @@@@@@@@@@@@@@ @@@@@/*@
// @ @@@@@@@ @@@ @@ @ @@@ @@ @ #@@ @@@@ /@ @@@@@ @@@@@@@@@@@@@@@@@@ @@% @@@@@@ @
// @. @% @@@@ /@@@@ &@ /@ @@@ @ @ @@@@ @@@@ @ &@@@@@ @@@@@@@@@@@@@ *@@@@@@@@@@* .@@
// @ @@@@@@@@ @ %@@@@@@ @* @..@@@ &, @* @@@@@ @@@@ &@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@ @%
// @ #@@(@@@@( @@@@@@@@ @ @ /@@@@ /@@@@@@@@@#%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@* @/
// @ @@@@@@@@@@@@@@ @. @/ @@@@@@@@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@#. *@@@@@@@@# #@%
// @ @@@@@@@@@ @@@@@@ @ .@@ @ @@@@@@@@@@@@@@@@@* @@@@@@@@@@@@@@@@@@@ @@@@@ @@ % @@@@@@@@@@@@ @
// #@@ /@@@@@@@@@@ @# (@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ ,@@@@@@@@@@ @@@@@@@@@@@@@. @
// @ @@@@@@@@@ @@@@@@@@@@@@@@@@@@@ %@@@@@@@@@@@@@@@@@@@ @@@@@@@ @@@@@@@@ @( @@@@@@@@@@@@@, @
// %@ &@@@@@@@@@@@@@@@@@@@@@ ,@ @@ @@@@@@@@@@ %@@@@@@@@@@, @ @@@ @ @@@@@@@@@@@@@@@@ @
// @@ @@@@@@@@@@@@@@( @@ @ @@@@@@@@@& *@@@@@@@@@@@( @ @@@@@@@@@@@@@@@@@@(.@
// @@@&. %@@@, @ *@@@@@@@@ @@% @@ ( @@ @ @% @@@/@@@@@@@@@@@@@*.@
// .%@&/ @ @@@@@@@@ @# &@@@ ((((((, @@ &% @.,@@ @@@@@ @@@@ @@ @
// %@, %@@@@ @@ @@ @@@@@@@& @@@# ( (@@@ (((( @@@ @ @ @@@@@@@@ @@@@ @@
// @& %, @@@@@@ ( @@ %@@@@ @@@@@@@@@@@@% * @@ ((((( @@ @/ @@ . . @
// @ #@@@@@@ ((( (((((((. %@. @@@@@@@@@@ ((((((((((( @@@ @
// @% @@@@@@@ *@@@@@ (((((( @@@ %@ @@@@/ (((((((((((. @@ @
// @ @@@@@@@@@@ ,@@@@ ((* . @ @@ /(((((((( @@**@
// @@ ,@@@@@@@@@@@& @@@@ ((( @& .@ (((((((( @@@ @
// @@ .@@@@@@@@@@@@( &@@@ ,( @ @ @@@@@@ &@@ @
// @@ @@@@@@@@@@@@& &@@ @ *@ @@@@@@@/,@@ @
// @@. .@@@@@@@@@@ @ .@ @@@@@@& @@ @
// .@@( ,@@@@@ *@ @@ ,@@
// &@@@@#
//
pragma solidity ^0.8.17;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {UpdatableOperatorFilterer} from "operator-filter-registry/src/UpdatableOperatorFilterer.sol";
import {RevokableDefaultOperatorFilterer} from "operator-filter-registry/src/RevokableDefaultOperatorFilterer.sol";
interface ogcontract {
function ownerOf(uint256 tokenId) external view returns (address owner);
function burn(uint256 tokenId) external;
}
interface Delegate {
function checkDelegateForAll(address delegate, address vault) external view returns (bool);
}
contract SCUM is ERC721AQueryable, Ownable, RevokableDefaultOperatorFilterer, ReentrancyGuard {
address private OGContract = 0xAc5Aeb3b4Ac8797c2307320Ed00a84B869ab9333;
address private signer = 0x2f2A13462f6d4aF64954ee84641D265932849b64;
string public _metadataRegular = "ipfs://QmY2oBi4p5zASJmzbjxMrn3poBj5QZFKxwF6zBpg8puVRt";
string public _metadataSOTY = "ipfs://QmbZ7NNu4A9qoxGwMHFw4n92dpz7zCCJbsFJPgdtpvdyqE";
uint256 public regularMinted = 0;
uint256 public SOTYMinted = 0;
uint256 private maxBurnPerWallet = 5;
uint256 private MAX_REGULAR_MINT = 250;
uint256 private MAX_SOTY_MINT = 25;
mapping(uint256 => uint256) public tokenMapping;
mapping(uint256 => uint256) public tokenType;
mapping(address => uint256) public totalMintedRegular;
mapping(address => bool) public mintedSOTY;
bool burnActive = false;
constructor() ERC721A("SCUMBAGS", "SCUM") {}
function burnToken(uint256[] memory tokenIds) public nonReentrant {
}
function _burnOG(uint256 tokenId) internal {
}
function adminMint(bool isSOTY, address wallet) public onlyOwner {
}
function claimSOTY(address wallet, bytes calldata voucher, bool delegate) public nonReentrant {
require(burnActive, "Burn not Active");
if(delegate) require(<FILL_ME>)
else require(msg.sender == wallet, "Not wallet");
require(msg.sender == tx.origin, "EOA only");
bytes32 hash = keccak256(abi.encodePacked(wallet));
require(_verifySignature(signer, hash, voucher), "Invalid voucher");
require(!mintedSOTY[wallet], "Already minted");
require(SOTYMinted + 1 <= MAX_SOTY_MINT, "Minted out");
mintedSOTY[wallet] = true;
uint16 mintId = uint16(_totalMinted());
tokenMapping[mintId] = SOTYMinted;
tokenType[mintId] = 1;
_mint(msg.sender, 1);
SOTYMinted += 1;
}
function _verifySignature(address _signer, bytes32 _hash, bytes memory _signature) internal pure returns (bool) {
}
function setMaxBurnPerWallet(uint256 _amount) public onlyOwner {
}
function setSigner(address _signer) public onlyOwner {
}
function setOGContract(address _addr) public onlyOwner {
}
function setMetadataRegular(string memory metadata) public onlyOwner {
}
function setMetadataSOTY(string memory metadata) public onlyOwner {
}
function setBurn(bool _state) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
function _baseURIRegular() internal view virtual returns(string memory) {
}
function _baseURISOTY() internal view virtual returns(string memory) {
}
function setApprovalForAll(
address operator,
bool approved
) public override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function owner() public view override(Ownable, UpdatableOperatorFilterer) returns (address) {
}
}
| Delegate(0x00000000000076A84feF008CDAbe6409d2FE638B).checkDelegateForAll(msg.sender,wallet),"Not delegate" | 164,726 | Delegate(0x00000000000076A84feF008CDAbe6409d2FE638B).checkDelegateForAll(msg.sender,wallet) |
"Invalid voucher" | // SPDX-License-Identifier: MIT
//
// *%@@@@@@@@@@@@@@@@@@@&#.
// @@@@@@@( (&@@@@@@ @& (@@@@@@@@# (@@@
// @ @@@@@@@@@@@@@@ @ @@ &@ @@@@@@@@@@@@@@@@@@ *@
// @ &@ @@ @@@ /@@@* @ @@@@@@ @@@@@@@@@@@@@@@@@@ @@*
// @@@@@@& @*,@% @ @ @ @@@@@@. @@@@@@@@@@@@@@@@% @@ @
// @@ (@@@@. @ .@ @@ @@ @ (@ @@@@@ @ @@@@@@ @@ @@@@@@@@@@@@@@ @@@@@/*@
// @ @@@@@@@ @@@ @@ @ @@@ @@ @ #@@ @@@@ /@ @@@@@ @@@@@@@@@@@@@@@@@@ @@% @@@@@@ @
// @. @% @@@@ /@@@@ &@ /@ @@@ @ @ @@@@ @@@@ @ &@@@@@ @@@@@@@@@@@@@ *@@@@@@@@@@* .@@
// @ @@@@@@@@ @ %@@@@@@ @* @..@@@ &, @* @@@@@ @@@@ &@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@ @%
// @ #@@(@@@@( @@@@@@@@ @ @ /@@@@ /@@@@@@@@@#%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@* @/
// @ @@@@@@@@@@@@@@ @. @/ @@@@@@@@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@#. *@@@@@@@@# #@%
// @ @@@@@@@@@ @@@@@@ @ .@@ @ @@@@@@@@@@@@@@@@@* @@@@@@@@@@@@@@@@@@@ @@@@@ @@ % @@@@@@@@@@@@ @
// #@@ /@@@@@@@@@@ @# (@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ ,@@@@@@@@@@ @@@@@@@@@@@@@. @
// @ @@@@@@@@@ @@@@@@@@@@@@@@@@@@@ %@@@@@@@@@@@@@@@@@@@ @@@@@@@ @@@@@@@@ @( @@@@@@@@@@@@@, @
// %@ &@@@@@@@@@@@@@@@@@@@@@ ,@ @@ @@@@@@@@@@ %@@@@@@@@@@, @ @@@ @ @@@@@@@@@@@@@@@@ @
// @@ @@@@@@@@@@@@@@( @@ @ @@@@@@@@@& *@@@@@@@@@@@( @ @@@@@@@@@@@@@@@@@@(.@
// @@@&. %@@@, @ *@@@@@@@@ @@% @@ ( @@ @ @% @@@/@@@@@@@@@@@@@*.@
// .%@&/ @ @@@@@@@@ @# &@@@ ((((((, @@ &% @.,@@ @@@@@ @@@@ @@ @
// %@, %@@@@ @@ @@ @@@@@@@& @@@# ( (@@@ (((( @@@ @ @ @@@@@@@@ @@@@ @@
// @& %, @@@@@@ ( @@ %@@@@ @@@@@@@@@@@@% * @@ ((((( @@ @/ @@ . . @
// @ #@@@@@@ ((( (((((((. %@. @@@@@@@@@@ ((((((((((( @@@ @
// @% @@@@@@@ *@@@@@ (((((( @@@ %@ @@@@/ (((((((((((. @@ @
// @ @@@@@@@@@@ ,@@@@ ((* . @ @@ /(((((((( @@**@
// @@ ,@@@@@@@@@@@& @@@@ ((( @& .@ (((((((( @@@ @
// @@ .@@@@@@@@@@@@( &@@@ ,( @ @ @@@@@@ &@@ @
// @@ @@@@@@@@@@@@& &@@ @ *@ @@@@@@@/,@@ @
// @@. .@@@@@@@@@@ @ .@ @@@@@@& @@ @
// .@@( ,@@@@@ *@ @@ ,@@
// &@@@@#
//
pragma solidity ^0.8.17;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {UpdatableOperatorFilterer} from "operator-filter-registry/src/UpdatableOperatorFilterer.sol";
import {RevokableDefaultOperatorFilterer} from "operator-filter-registry/src/RevokableDefaultOperatorFilterer.sol";
interface ogcontract {
function ownerOf(uint256 tokenId) external view returns (address owner);
function burn(uint256 tokenId) external;
}
interface Delegate {
function checkDelegateForAll(address delegate, address vault) external view returns (bool);
}
contract SCUM is ERC721AQueryable, Ownable, RevokableDefaultOperatorFilterer, ReentrancyGuard {
address private OGContract = 0xAc5Aeb3b4Ac8797c2307320Ed00a84B869ab9333;
address private signer = 0x2f2A13462f6d4aF64954ee84641D265932849b64;
string public _metadataRegular = "ipfs://QmY2oBi4p5zASJmzbjxMrn3poBj5QZFKxwF6zBpg8puVRt";
string public _metadataSOTY = "ipfs://QmbZ7NNu4A9qoxGwMHFw4n92dpz7zCCJbsFJPgdtpvdyqE";
uint256 public regularMinted = 0;
uint256 public SOTYMinted = 0;
uint256 private maxBurnPerWallet = 5;
uint256 private MAX_REGULAR_MINT = 250;
uint256 private MAX_SOTY_MINT = 25;
mapping(uint256 => uint256) public tokenMapping;
mapping(uint256 => uint256) public tokenType;
mapping(address => uint256) public totalMintedRegular;
mapping(address => bool) public mintedSOTY;
bool burnActive = false;
constructor() ERC721A("SCUMBAGS", "SCUM") {}
function burnToken(uint256[] memory tokenIds) public nonReentrant {
}
function _burnOG(uint256 tokenId) internal {
}
function adminMint(bool isSOTY, address wallet) public onlyOwner {
}
function claimSOTY(address wallet, bytes calldata voucher, bool delegate) public nonReentrant {
require(burnActive, "Burn not Active");
if(delegate) require(Delegate(0x00000000000076A84feF008CDAbe6409d2FE638B).checkDelegateForAll(msg.sender, wallet), "Not delegate");
else require(msg.sender == wallet, "Not wallet");
require(msg.sender == tx.origin, "EOA only");
bytes32 hash = keccak256(abi.encodePacked(wallet));
require(<FILL_ME>)
require(!mintedSOTY[wallet], "Already minted");
require(SOTYMinted + 1 <= MAX_SOTY_MINT, "Minted out");
mintedSOTY[wallet] = true;
uint16 mintId = uint16(_totalMinted());
tokenMapping[mintId] = SOTYMinted;
tokenType[mintId] = 1;
_mint(msg.sender, 1);
SOTYMinted += 1;
}
function _verifySignature(address _signer, bytes32 _hash, bytes memory _signature) internal pure returns (bool) {
}
function setMaxBurnPerWallet(uint256 _amount) public onlyOwner {
}
function setSigner(address _signer) public onlyOwner {
}
function setOGContract(address _addr) public onlyOwner {
}
function setMetadataRegular(string memory metadata) public onlyOwner {
}
function setMetadataSOTY(string memory metadata) public onlyOwner {
}
function setBurn(bool _state) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
function _baseURIRegular() internal view virtual returns(string memory) {
}
function _baseURISOTY() internal view virtual returns(string memory) {
}
function setApprovalForAll(
address operator,
bool approved
) public override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function owner() public view override(Ownable, UpdatableOperatorFilterer) returns (address) {
}
}
| _verifySignature(signer,hash,voucher),"Invalid voucher" | 164,726 | _verifySignature(signer,hash,voucher) |
"Already minted" | // SPDX-License-Identifier: MIT
//
// *%@@@@@@@@@@@@@@@@@@@&#.
// @@@@@@@( (&@@@@@@ @& (@@@@@@@@# (@@@
// @ @@@@@@@@@@@@@@ @ @@ &@ @@@@@@@@@@@@@@@@@@ *@
// @ &@ @@ @@@ /@@@* @ @@@@@@ @@@@@@@@@@@@@@@@@@ @@*
// @@@@@@& @*,@% @ @ @ @@@@@@. @@@@@@@@@@@@@@@@% @@ @
// @@ (@@@@. @ .@ @@ @@ @ (@ @@@@@ @ @@@@@@ @@ @@@@@@@@@@@@@@ @@@@@/*@
// @ @@@@@@@ @@@ @@ @ @@@ @@ @ #@@ @@@@ /@ @@@@@ @@@@@@@@@@@@@@@@@@ @@% @@@@@@ @
// @. @% @@@@ /@@@@ &@ /@ @@@ @ @ @@@@ @@@@ @ &@@@@@ @@@@@@@@@@@@@ *@@@@@@@@@@* .@@
// @ @@@@@@@@ @ %@@@@@@ @* @..@@@ &, @* @@@@@ @@@@ &@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@ @%
// @ #@@(@@@@( @@@@@@@@ @ @ /@@@@ /@@@@@@@@@#%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@* @/
// @ @@@@@@@@@@@@@@ @. @/ @@@@@@@@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@#. *@@@@@@@@# #@%
// @ @@@@@@@@@ @@@@@@ @ .@@ @ @@@@@@@@@@@@@@@@@* @@@@@@@@@@@@@@@@@@@ @@@@@ @@ % @@@@@@@@@@@@ @
// #@@ /@@@@@@@@@@ @# (@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ ,@@@@@@@@@@ @@@@@@@@@@@@@. @
// @ @@@@@@@@@ @@@@@@@@@@@@@@@@@@@ %@@@@@@@@@@@@@@@@@@@ @@@@@@@ @@@@@@@@ @( @@@@@@@@@@@@@, @
// %@ &@@@@@@@@@@@@@@@@@@@@@ ,@ @@ @@@@@@@@@@ %@@@@@@@@@@, @ @@@ @ @@@@@@@@@@@@@@@@ @
// @@ @@@@@@@@@@@@@@( @@ @ @@@@@@@@@& *@@@@@@@@@@@( @ @@@@@@@@@@@@@@@@@@(.@
// @@@&. %@@@, @ *@@@@@@@@ @@% @@ ( @@ @ @% @@@/@@@@@@@@@@@@@*.@
// .%@&/ @ @@@@@@@@ @# &@@@ ((((((, @@ &% @.,@@ @@@@@ @@@@ @@ @
// %@, %@@@@ @@ @@ @@@@@@@& @@@# ( (@@@ (((( @@@ @ @ @@@@@@@@ @@@@ @@
// @& %, @@@@@@ ( @@ %@@@@ @@@@@@@@@@@@% * @@ ((((( @@ @/ @@ . . @
// @ #@@@@@@ ((( (((((((. %@. @@@@@@@@@@ ((((((((((( @@@ @
// @% @@@@@@@ *@@@@@ (((((( @@@ %@ @@@@/ (((((((((((. @@ @
// @ @@@@@@@@@@ ,@@@@ ((* . @ @@ /(((((((( @@**@
// @@ ,@@@@@@@@@@@& @@@@ ((( @& .@ (((((((( @@@ @
// @@ .@@@@@@@@@@@@( &@@@ ,( @ @ @@@@@@ &@@ @
// @@ @@@@@@@@@@@@& &@@ @ *@ @@@@@@@/,@@ @
// @@. .@@@@@@@@@@ @ .@ @@@@@@& @@ @
// .@@( ,@@@@@ *@ @@ ,@@
// &@@@@#
//
pragma solidity ^0.8.17;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {UpdatableOperatorFilterer} from "operator-filter-registry/src/UpdatableOperatorFilterer.sol";
import {RevokableDefaultOperatorFilterer} from "operator-filter-registry/src/RevokableDefaultOperatorFilterer.sol";
interface ogcontract {
function ownerOf(uint256 tokenId) external view returns (address owner);
function burn(uint256 tokenId) external;
}
interface Delegate {
function checkDelegateForAll(address delegate, address vault) external view returns (bool);
}
contract SCUM is ERC721AQueryable, Ownable, RevokableDefaultOperatorFilterer, ReentrancyGuard {
address private OGContract = 0xAc5Aeb3b4Ac8797c2307320Ed00a84B869ab9333;
address private signer = 0x2f2A13462f6d4aF64954ee84641D265932849b64;
string public _metadataRegular = "ipfs://QmY2oBi4p5zASJmzbjxMrn3poBj5QZFKxwF6zBpg8puVRt";
string public _metadataSOTY = "ipfs://QmbZ7NNu4A9qoxGwMHFw4n92dpz7zCCJbsFJPgdtpvdyqE";
uint256 public regularMinted = 0;
uint256 public SOTYMinted = 0;
uint256 private maxBurnPerWallet = 5;
uint256 private MAX_REGULAR_MINT = 250;
uint256 private MAX_SOTY_MINT = 25;
mapping(uint256 => uint256) public tokenMapping;
mapping(uint256 => uint256) public tokenType;
mapping(address => uint256) public totalMintedRegular;
mapping(address => bool) public mintedSOTY;
bool burnActive = false;
constructor() ERC721A("SCUMBAGS", "SCUM") {}
function burnToken(uint256[] memory tokenIds) public nonReentrant {
}
function _burnOG(uint256 tokenId) internal {
}
function adminMint(bool isSOTY, address wallet) public onlyOwner {
}
function claimSOTY(address wallet, bytes calldata voucher, bool delegate) public nonReentrant {
require(burnActive, "Burn not Active");
if(delegate) require(Delegate(0x00000000000076A84feF008CDAbe6409d2FE638B).checkDelegateForAll(msg.sender, wallet), "Not delegate");
else require(msg.sender == wallet, "Not wallet");
require(msg.sender == tx.origin, "EOA only");
bytes32 hash = keccak256(abi.encodePacked(wallet));
require(_verifySignature(signer, hash, voucher), "Invalid voucher");
require(<FILL_ME>)
require(SOTYMinted + 1 <= MAX_SOTY_MINT, "Minted out");
mintedSOTY[wallet] = true;
uint16 mintId = uint16(_totalMinted());
tokenMapping[mintId] = SOTYMinted;
tokenType[mintId] = 1;
_mint(msg.sender, 1);
SOTYMinted += 1;
}
function _verifySignature(address _signer, bytes32 _hash, bytes memory _signature) internal pure returns (bool) {
}
function setMaxBurnPerWallet(uint256 _amount) public onlyOwner {
}
function setSigner(address _signer) public onlyOwner {
}
function setOGContract(address _addr) public onlyOwner {
}
function setMetadataRegular(string memory metadata) public onlyOwner {
}
function setMetadataSOTY(string memory metadata) public onlyOwner {
}
function setBurn(bool _state) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override(IERC721A, ERC721A) returns (string memory) {
}
function _baseURIRegular() internal view virtual returns(string memory) {
}
function _baseURISOTY() internal view virtual returns(string memory) {
}
function setApprovalForAll(
address operator,
bool approved
) public override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function owner() public view override(Ownable, UpdatableOperatorFilterer) returns (address) {
}
}
| !mintedSOTY[wallet],"Already minted" | 164,726 | !mintedSOTY[wallet] |
"Max NFT per address exceeded" | // SPDX-License-Identifier: MIT
// Developed by BlockLabz
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
// @@@@@@@ @@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@ @@@@ @@@@@ @@
// @@ @@
// @@ @@@ @@@ @@@ @@@ @@
// @@ @@....@@ @@.....@@ @@....@@ @@....@@ @@
// @@ @@@.........@@@ @@@............@@@ @@@............@@@ @@@.........@@@ @@
// @@ @@.................@@ @@....................@@ @@....................@@ @@.................@@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@@ @@.............................................................................................@@ @@@
// @@@@@@@@.............................................................................................@@@@@@@
// @..........................................................................................................@
// @@........................................................................................................@@
// @@........................................................................................................@@
// @@.........@@...................................................................................@@........@@
// @@.....@@ @@................................................................................@@ @@.....@@
// @@@@@@ @@...........................................................................@@ @@@@@@
// @@@ @@.......................................................................@@ @@@
contract MonsterSuitNFT is ERC721A, Ownable
{
using Strings for string;
uint16 public reservedTokensMinted = 0;
uint16 public PER_ADDRESS_LIMIT = 4;
uint16 public constant MAX_SUPPLY = 10000;
uint16 public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public PRICE = 70000000000000000;
bool public revealed = false;
bool public saleIsActive = false;
bool public preSaleIsActive = false;
string private _baseTokenURI;
string public notRevealedUri;
bytes32 rootA;
bytes32 rootB;
bytes32 rootC;
bytes32 rootD;
mapping(address => uint16) public addressMintedBalance;
constructor() ERC721A("Monster Suit", "MS") {}
function saleMint(uint16 amount) external payable
{
require(saleIsActive, "Sale is not active");
require(<FILL_ME>)
require(totalSupply() + amount <= MAX_SUPPLY - (NUMBER_RESERVED_TOKENS - reservedTokensMinted), "Purchase would exceed max supply");
require(msg.value >= PRICE * amount, "Not enough ETH for this transaction");
require(msg.sender == tx.origin, "Transaction from smart contract not allowed");
addressMintedBalance[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function presaleMintA(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintB(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintC(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintD(uint16 amount, bytes32[] memory proof) external payable
{
}
function mintReservedTokens(address to, uint16 amount) external onlyOwner
{
}
function setPrice(uint256 newPrice) external onlyOwner
{
}
function setPerAddressLimit(uint16 newLimit) external onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal() public onlyOwner {
}
function flipSaleState() external onlyOwner
{
}
function flipPreSaleState() external onlyOwner
{
}
function setRootA(bytes32 _root) external onlyOwner
{
}
function setRootB(bytes32 _root) external onlyOwner
{
}
function setRootC(bytes32 _root) external onlyOwner
{
}
function setRootD(bytes32 _root) external onlyOwner
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdraw() external onlyOwner
{
}
}
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01000010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01101100%011011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****11%01100011%01101011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****01001100%01100001%011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****00010%01111010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| addressMintedBalance[msg.sender]+amount<=PER_ADDRESS_LIMIT,"Max NFT per address exceeded" | 164,737 | addressMintedBalance[msg.sender]+amount<=PER_ADDRESS_LIMIT |
"Purchase would exceed max supply" | // SPDX-License-Identifier: MIT
// Developed by BlockLabz
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
// @@@@@@@ @@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@ @@@@ @@@@@ @@
// @@ @@
// @@ @@@ @@@ @@@ @@@ @@
// @@ @@....@@ @@.....@@ @@....@@ @@....@@ @@
// @@ @@@.........@@@ @@@............@@@ @@@............@@@ @@@.........@@@ @@
// @@ @@.................@@ @@....................@@ @@....................@@ @@.................@@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@@ @@.............................................................................................@@ @@@
// @@@@@@@@.............................................................................................@@@@@@@
// @..........................................................................................................@
// @@........................................................................................................@@
// @@........................................................................................................@@
// @@.........@@...................................................................................@@........@@
// @@.....@@ @@................................................................................@@ @@.....@@
// @@@@@@ @@...........................................................................@@ @@@@@@
// @@@ @@.......................................................................@@ @@@
contract MonsterSuitNFT is ERC721A, Ownable
{
using Strings for string;
uint16 public reservedTokensMinted = 0;
uint16 public PER_ADDRESS_LIMIT = 4;
uint16 public constant MAX_SUPPLY = 10000;
uint16 public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public PRICE = 70000000000000000;
bool public revealed = false;
bool public saleIsActive = false;
bool public preSaleIsActive = false;
string private _baseTokenURI;
string public notRevealedUri;
bytes32 rootA;
bytes32 rootB;
bytes32 rootC;
bytes32 rootD;
mapping(address => uint16) public addressMintedBalance;
constructor() ERC721A("Monster Suit", "MS") {}
function saleMint(uint16 amount) external payable
{
require(saleIsActive, "Sale is not active");
require(addressMintedBalance[msg.sender] + amount <= PER_ADDRESS_LIMIT, "Max NFT per address exceeded");
require(<FILL_ME>)
require(msg.value >= PRICE * amount, "Not enough ETH for this transaction");
require(msg.sender == tx.origin, "Transaction from smart contract not allowed");
addressMintedBalance[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function presaleMintA(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintB(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintC(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintD(uint16 amount, bytes32[] memory proof) external payable
{
}
function mintReservedTokens(address to, uint16 amount) external onlyOwner
{
}
function setPrice(uint256 newPrice) external onlyOwner
{
}
function setPerAddressLimit(uint16 newLimit) external onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal() public onlyOwner {
}
function flipSaleState() external onlyOwner
{
}
function flipPreSaleState() external onlyOwner
{
}
function setRootA(bytes32 _root) external onlyOwner
{
}
function setRootB(bytes32 _root) external onlyOwner
{
}
function setRootC(bytes32 _root) external onlyOwner
{
}
function setRootD(bytes32 _root) external onlyOwner
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdraw() external onlyOwner
{
}
}
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01000010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01101100%011011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****11%01100011%01101011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****01001100%01100001%011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****00010%01111010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| totalSupply()+amount<=MAX_SUPPLY-(NUMBER_RESERVED_TOKENS-reservedTokensMinted),"Purchase would exceed max supply" | 164,737 | totalSupply()+amount<=MAX_SUPPLY-(NUMBER_RESERVED_TOKENS-reservedTokensMinted) |
"Address not allowed at this time" | // SPDX-License-Identifier: MIT
// Developed by BlockLabz
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
// @@@@@@@ @@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@ @@@@ @@@@@ @@
// @@ @@
// @@ @@@ @@@ @@@ @@@ @@
// @@ @@....@@ @@.....@@ @@....@@ @@....@@ @@
// @@ @@@.........@@@ @@@............@@@ @@@............@@@ @@@.........@@@ @@
// @@ @@.................@@ @@....................@@ @@....................@@ @@.................@@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@@ @@.............................................................................................@@ @@@
// @@@@@@@@.............................................................................................@@@@@@@
// @..........................................................................................................@
// @@........................................................................................................@@
// @@........................................................................................................@@
// @@.........@@...................................................................................@@........@@
// @@.....@@ @@................................................................................@@ @@.....@@
// @@@@@@ @@...........................................................................@@ @@@@@@
// @@@ @@.......................................................................@@ @@@
contract MonsterSuitNFT is ERC721A, Ownable
{
using Strings for string;
uint16 public reservedTokensMinted = 0;
uint16 public PER_ADDRESS_LIMIT = 4;
uint16 public constant MAX_SUPPLY = 10000;
uint16 public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public PRICE = 70000000000000000;
bool public revealed = false;
bool public saleIsActive = false;
bool public preSaleIsActive = false;
string private _baseTokenURI;
string public notRevealedUri;
bytes32 rootA;
bytes32 rootB;
bytes32 rootC;
bytes32 rootD;
mapping(address => uint16) public addressMintedBalance;
constructor() ERC721A("Monster Suit", "MS") {}
function saleMint(uint16 amount) external payable
{
}
function presaleMintA(uint16 amount, bytes32[] memory proof) external payable
{
require(preSaleIsActive, "Presale is not active");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
require(addressMintedBalance[msg.sender] + amount <= 1, "Quantity exceeds whitelist allowance");
require(totalSupply() + amount <= MAX_SUPPLY - (NUMBER_RESERVED_TOKENS - reservedTokensMinted), "Purchase would exceed max supply");
require(msg.value >= PRICE * amount, "Not enough ETH for this transaction");
require(msg.sender == tx.origin, "Transaction from smart contract not allowed");
addressMintedBalance[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function presaleMintB(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintC(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintD(uint16 amount, bytes32[] memory proof) external payable
{
}
function mintReservedTokens(address to, uint16 amount) external onlyOwner
{
}
function setPrice(uint256 newPrice) external onlyOwner
{
}
function setPerAddressLimit(uint16 newLimit) external onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal() public onlyOwner {
}
function flipSaleState() external onlyOwner
{
}
function flipPreSaleState() external onlyOwner
{
}
function setRootA(bytes32 _root) external onlyOwner
{
}
function setRootB(bytes32 _root) external onlyOwner
{
}
function setRootC(bytes32 _root) external onlyOwner
{
}
function setRootD(bytes32 _root) external onlyOwner
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdraw() external onlyOwner
{
}
}
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01000010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01101100%011011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****11%01100011%01101011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****01001100%01100001%011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****00010%01111010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| MerkleProof.verify(proof,rootA,leaf),"Address not allowed at this time" | 164,737 | MerkleProof.verify(proof,rootA,leaf) |
"Quantity exceeds whitelist allowance" | // SPDX-License-Identifier: MIT
// Developed by BlockLabz
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
// @@@@@@@ @@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@ @@@@ @@@@@ @@
// @@ @@
// @@ @@@ @@@ @@@ @@@ @@
// @@ @@....@@ @@.....@@ @@....@@ @@....@@ @@
// @@ @@@.........@@@ @@@............@@@ @@@............@@@ @@@.........@@@ @@
// @@ @@.................@@ @@....................@@ @@....................@@ @@.................@@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@@ @@.............................................................................................@@ @@@
// @@@@@@@@.............................................................................................@@@@@@@
// @..........................................................................................................@
// @@........................................................................................................@@
// @@........................................................................................................@@
// @@.........@@...................................................................................@@........@@
// @@.....@@ @@................................................................................@@ @@.....@@
// @@@@@@ @@...........................................................................@@ @@@@@@
// @@@ @@.......................................................................@@ @@@
contract MonsterSuitNFT is ERC721A, Ownable
{
using Strings for string;
uint16 public reservedTokensMinted = 0;
uint16 public PER_ADDRESS_LIMIT = 4;
uint16 public constant MAX_SUPPLY = 10000;
uint16 public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public PRICE = 70000000000000000;
bool public revealed = false;
bool public saleIsActive = false;
bool public preSaleIsActive = false;
string private _baseTokenURI;
string public notRevealedUri;
bytes32 rootA;
bytes32 rootB;
bytes32 rootC;
bytes32 rootD;
mapping(address => uint16) public addressMintedBalance;
constructor() ERC721A("Monster Suit", "MS") {}
function saleMint(uint16 amount) external payable
{
}
function presaleMintA(uint16 amount, bytes32[] memory proof) external payable
{
require(preSaleIsActive, "Presale is not active");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(proof, rootA, leaf), "Address not allowed at this time");
require(<FILL_ME>)
require(totalSupply() + amount <= MAX_SUPPLY - (NUMBER_RESERVED_TOKENS - reservedTokensMinted), "Purchase would exceed max supply");
require(msg.value >= PRICE * amount, "Not enough ETH for this transaction");
require(msg.sender == tx.origin, "Transaction from smart contract not allowed");
addressMintedBalance[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function presaleMintB(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintC(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintD(uint16 amount, bytes32[] memory proof) external payable
{
}
function mintReservedTokens(address to, uint16 amount) external onlyOwner
{
}
function setPrice(uint256 newPrice) external onlyOwner
{
}
function setPerAddressLimit(uint16 newLimit) external onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal() public onlyOwner {
}
function flipSaleState() external onlyOwner
{
}
function flipPreSaleState() external onlyOwner
{
}
function setRootA(bytes32 _root) external onlyOwner
{
}
function setRootB(bytes32 _root) external onlyOwner
{
}
function setRootC(bytes32 _root) external onlyOwner
{
}
function setRootD(bytes32 _root) external onlyOwner
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdraw() external onlyOwner
{
}
}
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01000010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01101100%011011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****11%01100011%01101011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****01001100%01100001%011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****00010%01111010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| addressMintedBalance[msg.sender]+amount<=1,"Quantity exceeds whitelist allowance" | 164,737 | addressMintedBalance[msg.sender]+amount<=1 |
"Address not allowed at this time" | // SPDX-License-Identifier: MIT
// Developed by BlockLabz
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
// @@@@@@@ @@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@ @@@@ @@@@@ @@
// @@ @@
// @@ @@@ @@@ @@@ @@@ @@
// @@ @@....@@ @@.....@@ @@....@@ @@....@@ @@
// @@ @@@.........@@@ @@@............@@@ @@@............@@@ @@@.........@@@ @@
// @@ @@.................@@ @@....................@@ @@....................@@ @@.................@@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@@ @@.............................................................................................@@ @@@
// @@@@@@@@.............................................................................................@@@@@@@
// @..........................................................................................................@
// @@........................................................................................................@@
// @@........................................................................................................@@
// @@.........@@...................................................................................@@........@@
// @@.....@@ @@................................................................................@@ @@.....@@
// @@@@@@ @@...........................................................................@@ @@@@@@
// @@@ @@.......................................................................@@ @@@
contract MonsterSuitNFT is ERC721A, Ownable
{
using Strings for string;
uint16 public reservedTokensMinted = 0;
uint16 public PER_ADDRESS_LIMIT = 4;
uint16 public constant MAX_SUPPLY = 10000;
uint16 public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public PRICE = 70000000000000000;
bool public revealed = false;
bool public saleIsActive = false;
bool public preSaleIsActive = false;
string private _baseTokenURI;
string public notRevealedUri;
bytes32 rootA;
bytes32 rootB;
bytes32 rootC;
bytes32 rootD;
mapping(address => uint16) public addressMintedBalance;
constructor() ERC721A("Monster Suit", "MS") {}
function saleMint(uint16 amount) external payable
{
}
function presaleMintA(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintB(uint16 amount, bytes32[] memory proof) external payable
{
require(preSaleIsActive, "Presale is not active");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
require(addressMintedBalance[msg.sender] + amount <= 2, "Quantity exceeds whitelist allowance");
require(totalSupply() + amount <= MAX_SUPPLY - (NUMBER_RESERVED_TOKENS - reservedTokensMinted), "Purchase would exceed max supply");
require(msg.value >= PRICE * amount, "Not enough ETH for this transaction");
require(msg.sender == tx.origin, "Transaction from smart contract not allowed");
addressMintedBalance[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function presaleMintC(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintD(uint16 amount, bytes32[] memory proof) external payable
{
}
function mintReservedTokens(address to, uint16 amount) external onlyOwner
{
}
function setPrice(uint256 newPrice) external onlyOwner
{
}
function setPerAddressLimit(uint16 newLimit) external onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal() public onlyOwner {
}
function flipSaleState() external onlyOwner
{
}
function flipPreSaleState() external onlyOwner
{
}
function setRootA(bytes32 _root) external onlyOwner
{
}
function setRootB(bytes32 _root) external onlyOwner
{
}
function setRootC(bytes32 _root) external onlyOwner
{
}
function setRootD(bytes32 _root) external onlyOwner
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdraw() external onlyOwner
{
}
}
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01000010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01101100%011011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****11%01100011%01101011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****01001100%01100001%011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****00010%01111010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| MerkleProof.verify(proof,rootB,leaf),"Address not allowed at this time" | 164,737 | MerkleProof.verify(proof,rootB,leaf) |
"Quantity exceeds whitelist allowance" | // SPDX-License-Identifier: MIT
// Developed by BlockLabz
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
// @@@@@@@ @@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@ @@@@ @@@@@ @@
// @@ @@
// @@ @@@ @@@ @@@ @@@ @@
// @@ @@....@@ @@.....@@ @@....@@ @@....@@ @@
// @@ @@@.........@@@ @@@............@@@ @@@............@@@ @@@.........@@@ @@
// @@ @@.................@@ @@....................@@ @@....................@@ @@.................@@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@@ @@.............................................................................................@@ @@@
// @@@@@@@@.............................................................................................@@@@@@@
// @..........................................................................................................@
// @@........................................................................................................@@
// @@........................................................................................................@@
// @@.........@@...................................................................................@@........@@
// @@.....@@ @@................................................................................@@ @@.....@@
// @@@@@@ @@...........................................................................@@ @@@@@@
// @@@ @@.......................................................................@@ @@@
contract MonsterSuitNFT is ERC721A, Ownable
{
using Strings for string;
uint16 public reservedTokensMinted = 0;
uint16 public PER_ADDRESS_LIMIT = 4;
uint16 public constant MAX_SUPPLY = 10000;
uint16 public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public PRICE = 70000000000000000;
bool public revealed = false;
bool public saleIsActive = false;
bool public preSaleIsActive = false;
string private _baseTokenURI;
string public notRevealedUri;
bytes32 rootA;
bytes32 rootB;
bytes32 rootC;
bytes32 rootD;
mapping(address => uint16) public addressMintedBalance;
constructor() ERC721A("Monster Suit", "MS") {}
function saleMint(uint16 amount) external payable
{
}
function presaleMintA(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintB(uint16 amount, bytes32[] memory proof) external payable
{
require(preSaleIsActive, "Presale is not active");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(proof, rootB, leaf), "Address not allowed at this time");
require(<FILL_ME>)
require(totalSupply() + amount <= MAX_SUPPLY - (NUMBER_RESERVED_TOKENS - reservedTokensMinted), "Purchase would exceed max supply");
require(msg.value >= PRICE * amount, "Not enough ETH for this transaction");
require(msg.sender == tx.origin, "Transaction from smart contract not allowed");
addressMintedBalance[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function presaleMintC(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintD(uint16 amount, bytes32[] memory proof) external payable
{
}
function mintReservedTokens(address to, uint16 amount) external onlyOwner
{
}
function setPrice(uint256 newPrice) external onlyOwner
{
}
function setPerAddressLimit(uint16 newLimit) external onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal() public onlyOwner {
}
function flipSaleState() external onlyOwner
{
}
function flipPreSaleState() external onlyOwner
{
}
function setRootA(bytes32 _root) external onlyOwner
{
}
function setRootB(bytes32 _root) external onlyOwner
{
}
function setRootC(bytes32 _root) external onlyOwner
{
}
function setRootD(bytes32 _root) external onlyOwner
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdraw() external onlyOwner
{
}
}
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01000010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01101100%011011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****11%01100011%01101011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****01001100%01100001%011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****00010%01111010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| addressMintedBalance[msg.sender]+amount<=2,"Quantity exceeds whitelist allowance" | 164,737 | addressMintedBalance[msg.sender]+amount<=2 |
"Address not allowed at this time" | // SPDX-License-Identifier: MIT
// Developed by BlockLabz
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
// @@@@@@@ @@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@ @@@@ @@@@@ @@
// @@ @@
// @@ @@@ @@@ @@@ @@@ @@
// @@ @@....@@ @@.....@@ @@....@@ @@....@@ @@
// @@ @@@.........@@@ @@@............@@@ @@@............@@@ @@@.........@@@ @@
// @@ @@.................@@ @@....................@@ @@....................@@ @@.................@@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@@ @@.............................................................................................@@ @@@
// @@@@@@@@.............................................................................................@@@@@@@
// @..........................................................................................................@
// @@........................................................................................................@@
// @@........................................................................................................@@
// @@.........@@...................................................................................@@........@@
// @@.....@@ @@................................................................................@@ @@.....@@
// @@@@@@ @@...........................................................................@@ @@@@@@
// @@@ @@.......................................................................@@ @@@
contract MonsterSuitNFT is ERC721A, Ownable
{
using Strings for string;
uint16 public reservedTokensMinted = 0;
uint16 public PER_ADDRESS_LIMIT = 4;
uint16 public constant MAX_SUPPLY = 10000;
uint16 public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public PRICE = 70000000000000000;
bool public revealed = false;
bool public saleIsActive = false;
bool public preSaleIsActive = false;
string private _baseTokenURI;
string public notRevealedUri;
bytes32 rootA;
bytes32 rootB;
bytes32 rootC;
bytes32 rootD;
mapping(address => uint16) public addressMintedBalance;
constructor() ERC721A("Monster Suit", "MS") {}
function saleMint(uint16 amount) external payable
{
}
function presaleMintA(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintB(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintC(uint16 amount, bytes32[] memory proof) external payable
{
require(preSaleIsActive, "Presale is not active");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
require(addressMintedBalance[msg.sender] + amount <= 3, "Quantity exceeds whitelist allowance");
require(totalSupply() + amount <= MAX_SUPPLY - (NUMBER_RESERVED_TOKENS - reservedTokensMinted), "Purchase would exceed max supply");
require(msg.value >= PRICE * amount, "Not enough ETH for this transaction");
require(msg.sender == tx.origin, "Transaction from smart contract not allowed");
addressMintedBalance[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function presaleMintD(uint16 amount, bytes32[] memory proof) external payable
{
}
function mintReservedTokens(address to, uint16 amount) external onlyOwner
{
}
function setPrice(uint256 newPrice) external onlyOwner
{
}
function setPerAddressLimit(uint16 newLimit) external onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal() public onlyOwner {
}
function flipSaleState() external onlyOwner
{
}
function flipPreSaleState() external onlyOwner
{
}
function setRootA(bytes32 _root) external onlyOwner
{
}
function setRootB(bytes32 _root) external onlyOwner
{
}
function setRootC(bytes32 _root) external onlyOwner
{
}
function setRootD(bytes32 _root) external onlyOwner
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdraw() external onlyOwner
{
}
}
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01000010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01101100%011011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****11%01100011%01101011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****01001100%01100001%011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****00010%01111010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| MerkleProof.verify(proof,rootC,leaf),"Address not allowed at this time" | 164,737 | MerkleProof.verify(proof,rootC,leaf) |
"Quantity exceeds whitelist allowance" | // SPDX-License-Identifier: MIT
// Developed by BlockLabz
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
// @@@@@@@ @@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@ @@@@ @@@@@ @@
// @@ @@
// @@ @@@ @@@ @@@ @@@ @@
// @@ @@....@@ @@.....@@ @@....@@ @@....@@ @@
// @@ @@@.........@@@ @@@............@@@ @@@............@@@ @@@.........@@@ @@
// @@ @@.................@@ @@....................@@ @@....................@@ @@.................@@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@@ @@.............................................................................................@@ @@@
// @@@@@@@@.............................................................................................@@@@@@@
// @..........................................................................................................@
// @@........................................................................................................@@
// @@........................................................................................................@@
// @@.........@@...................................................................................@@........@@
// @@.....@@ @@................................................................................@@ @@.....@@
// @@@@@@ @@...........................................................................@@ @@@@@@
// @@@ @@.......................................................................@@ @@@
contract MonsterSuitNFT is ERC721A, Ownable
{
using Strings for string;
uint16 public reservedTokensMinted = 0;
uint16 public PER_ADDRESS_LIMIT = 4;
uint16 public constant MAX_SUPPLY = 10000;
uint16 public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public PRICE = 70000000000000000;
bool public revealed = false;
bool public saleIsActive = false;
bool public preSaleIsActive = false;
string private _baseTokenURI;
string public notRevealedUri;
bytes32 rootA;
bytes32 rootB;
bytes32 rootC;
bytes32 rootD;
mapping(address => uint16) public addressMintedBalance;
constructor() ERC721A("Monster Suit", "MS") {}
function saleMint(uint16 amount) external payable
{
}
function presaleMintA(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintB(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintC(uint16 amount, bytes32[] memory proof) external payable
{
require(preSaleIsActive, "Presale is not active");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(proof, rootC, leaf), "Address not allowed at this time");
require(<FILL_ME>)
require(totalSupply() + amount <= MAX_SUPPLY - (NUMBER_RESERVED_TOKENS - reservedTokensMinted), "Purchase would exceed max supply");
require(msg.value >= PRICE * amount, "Not enough ETH for this transaction");
require(msg.sender == tx.origin, "Transaction from smart contract not allowed");
addressMintedBalance[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function presaleMintD(uint16 amount, bytes32[] memory proof) external payable
{
}
function mintReservedTokens(address to, uint16 amount) external onlyOwner
{
}
function setPrice(uint256 newPrice) external onlyOwner
{
}
function setPerAddressLimit(uint16 newLimit) external onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal() public onlyOwner {
}
function flipSaleState() external onlyOwner
{
}
function flipPreSaleState() external onlyOwner
{
}
function setRootA(bytes32 _root) external onlyOwner
{
}
function setRootB(bytes32 _root) external onlyOwner
{
}
function setRootC(bytes32 _root) external onlyOwner
{
}
function setRootD(bytes32 _root) external onlyOwner
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdraw() external onlyOwner
{
}
}
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01000010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01101100%011011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****11%01100011%01101011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****01001100%01100001%011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****00010%01111010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| addressMintedBalance[msg.sender]+amount<=3,"Quantity exceeds whitelist allowance" | 164,737 | addressMintedBalance[msg.sender]+amount<=3 |
"Address not allowed at this time" | // SPDX-License-Identifier: MIT
// Developed by BlockLabz
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
// @@@@@@@ @@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@ @@@@ @@@@@ @@
// @@ @@
// @@ @@@ @@@ @@@ @@@ @@
// @@ @@....@@ @@.....@@ @@....@@ @@....@@ @@
// @@ @@@.........@@@ @@@............@@@ @@@............@@@ @@@.........@@@ @@
// @@ @@.................@@ @@....................@@ @@....................@@ @@.................@@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@@ @@.............................................................................................@@ @@@
// @@@@@@@@.............................................................................................@@@@@@@
// @..........................................................................................................@
// @@........................................................................................................@@
// @@........................................................................................................@@
// @@.........@@...................................................................................@@........@@
// @@.....@@ @@................................................................................@@ @@.....@@
// @@@@@@ @@...........................................................................@@ @@@@@@
// @@@ @@.......................................................................@@ @@@
contract MonsterSuitNFT is ERC721A, Ownable
{
using Strings for string;
uint16 public reservedTokensMinted = 0;
uint16 public PER_ADDRESS_LIMIT = 4;
uint16 public constant MAX_SUPPLY = 10000;
uint16 public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public PRICE = 70000000000000000;
bool public revealed = false;
bool public saleIsActive = false;
bool public preSaleIsActive = false;
string private _baseTokenURI;
string public notRevealedUri;
bytes32 rootA;
bytes32 rootB;
bytes32 rootC;
bytes32 rootD;
mapping(address => uint16) public addressMintedBalance;
constructor() ERC721A("Monster Suit", "MS") {}
function saleMint(uint16 amount) external payable
{
}
function presaleMintA(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintB(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintC(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintD(uint16 amount, bytes32[] memory proof) external payable
{
require(preSaleIsActive, "Presale is not active");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
require(addressMintedBalance[msg.sender] + amount <= 4, "Quantity exceeds whitelist allowance");
require(totalSupply() + amount <= MAX_SUPPLY - (NUMBER_RESERVED_TOKENS - reservedTokensMinted), "Purchase would exceed max supply");
require(msg.value >= PRICE * amount, "Not enough ETH for this transaction");
require(msg.sender == tx.origin, "Transaction from smart contract not allowed");
addressMintedBalance[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function mintReservedTokens(address to, uint16 amount) external onlyOwner
{
}
function setPrice(uint256 newPrice) external onlyOwner
{
}
function setPerAddressLimit(uint16 newLimit) external onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal() public onlyOwner {
}
function flipSaleState() external onlyOwner
{
}
function flipPreSaleState() external onlyOwner
{
}
function setRootA(bytes32 _root) external onlyOwner
{
}
function setRootB(bytes32 _root) external onlyOwner
{
}
function setRootC(bytes32 _root) external onlyOwner
{
}
function setRootD(bytes32 _root) external onlyOwner
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdraw() external onlyOwner
{
}
}
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01000010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01101100%011011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****11%01100011%01101011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****01001100%01100001%011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****00010%01111010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| MerkleProof.verify(proof,rootD,leaf),"Address not allowed at this time" | 164,737 | MerkleProof.verify(proof,rootD,leaf) |
"Quantity exceeds whitelist allowance" | // SPDX-License-Identifier: MIT
// Developed by BlockLabz
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
// @@@@@@@ @@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@ @@@@ @@@@@ @@
// @@ @@
// @@ @@@ @@@ @@@ @@@ @@
// @@ @@....@@ @@.....@@ @@....@@ @@....@@ @@
// @@ @@@.........@@@ @@@............@@@ @@@............@@@ @@@.........@@@ @@
// @@ @@.................@@ @@....................@@ @@....................@@ @@.................@@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@@ @@.............................................................................................@@ @@@
// @@@@@@@@.............................................................................................@@@@@@@
// @..........................................................................................................@
// @@........................................................................................................@@
// @@........................................................................................................@@
// @@.........@@...................................................................................@@........@@
// @@.....@@ @@................................................................................@@ @@.....@@
// @@@@@@ @@...........................................................................@@ @@@@@@
// @@@ @@.......................................................................@@ @@@
contract MonsterSuitNFT is ERC721A, Ownable
{
using Strings for string;
uint16 public reservedTokensMinted = 0;
uint16 public PER_ADDRESS_LIMIT = 4;
uint16 public constant MAX_SUPPLY = 10000;
uint16 public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public PRICE = 70000000000000000;
bool public revealed = false;
bool public saleIsActive = false;
bool public preSaleIsActive = false;
string private _baseTokenURI;
string public notRevealedUri;
bytes32 rootA;
bytes32 rootB;
bytes32 rootC;
bytes32 rootD;
mapping(address => uint16) public addressMintedBalance;
constructor() ERC721A("Monster Suit", "MS") {}
function saleMint(uint16 amount) external payable
{
}
function presaleMintA(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintB(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintC(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintD(uint16 amount, bytes32[] memory proof) external payable
{
require(preSaleIsActive, "Presale is not active");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(proof, rootD, leaf), "Address not allowed at this time");
require(<FILL_ME>)
require(totalSupply() + amount <= MAX_SUPPLY - (NUMBER_RESERVED_TOKENS - reservedTokensMinted), "Purchase would exceed max supply");
require(msg.value >= PRICE * amount, "Not enough ETH for this transaction");
require(msg.sender == tx.origin, "Transaction from smart contract not allowed");
addressMintedBalance[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function mintReservedTokens(address to, uint16 amount) external onlyOwner
{
}
function setPrice(uint256 newPrice) external onlyOwner
{
}
function setPerAddressLimit(uint16 newLimit) external onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal() public onlyOwner {
}
function flipSaleState() external onlyOwner
{
}
function flipPreSaleState() external onlyOwner
{
}
function setRootA(bytes32 _root) external onlyOwner
{
}
function setRootB(bytes32 _root) external onlyOwner
{
}
function setRootC(bytes32 _root) external onlyOwner
{
}
function setRootD(bytes32 _root) external onlyOwner
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdraw() external onlyOwner
{
}
}
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01000010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01101100%011011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****11%01100011%01101011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****01001100%01100001%011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****00010%01111010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| addressMintedBalance[msg.sender]+amount<=4,"Quantity exceeds whitelist allowance" | 164,737 | addressMintedBalance[msg.sender]+amount<=4 |
"This amount is more than max allowed" | // SPDX-License-Identifier: MIT
// Developed by BlockLabz
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
// @@@@@@@ @@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@@@@@@@@ @@@@@@@@@
// @@ @@@@ @@@@@ @@
// @@ @@
// @@ @@@ @@@ @@@ @@@ @@
// @@ @@....@@ @@.....@@ @@....@@ @@....@@ @@
// @@ @@@.........@@@ @@@............@@@ @@@............@@@ @@@.........@@@ @@
// @@ @@.................@@ @@....................@@ @@....................@@ @@.................@@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@ @@.............................................................................................@@ @@
// @@@ @@.............................................................................................@@ @@@
// @@@@@@@@.............................................................................................@@@@@@@
// @..........................................................................................................@
// @@........................................................................................................@@
// @@........................................................................................................@@
// @@.........@@...................................................................................@@........@@
// @@.....@@ @@................................................................................@@ @@.....@@
// @@@@@@ @@...........................................................................@@ @@@@@@
// @@@ @@.......................................................................@@ @@@
contract MonsterSuitNFT is ERC721A, Ownable
{
using Strings for string;
uint16 public reservedTokensMinted = 0;
uint16 public PER_ADDRESS_LIMIT = 4;
uint16 public constant MAX_SUPPLY = 10000;
uint16 public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public PRICE = 70000000000000000;
bool public revealed = false;
bool public saleIsActive = false;
bool public preSaleIsActive = false;
string private _baseTokenURI;
string public notRevealedUri;
bytes32 rootA;
bytes32 rootB;
bytes32 rootC;
bytes32 rootD;
mapping(address => uint16) public addressMintedBalance;
constructor() ERC721A("Monster Suit", "MS") {}
function saleMint(uint16 amount) external payable
{
}
function presaleMintA(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintB(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintC(uint16 amount, bytes32[] memory proof) external payable
{
}
function presaleMintD(uint16 amount, bytes32[] memory proof) external payable
{
}
function mintReservedTokens(address to, uint16 amount) external onlyOwner
{
require(<FILL_ME>)
reservedTokensMinted += amount;
_safeMint(to, amount);
}
function setPrice(uint256 newPrice) external onlyOwner
{
}
function setPerAddressLimit(uint16 newLimit) external onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal() public onlyOwner {
}
function flipSaleState() external onlyOwner
{
}
function flipPreSaleState() external onlyOwner
{
}
function setRootA(bytes32 _root) external onlyOwner
{
}
function setRootB(bytes32 _root) external onlyOwner
{
}
function setRootC(bytes32 _root) external onlyOwner
{
}
function setRootD(bytes32 _root) external onlyOwner
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdraw() external onlyOwner
{
}
}
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01000010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****01101100%011011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****11%01100011%01101011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*****01001100%01100001%011****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****00010%01111010%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%*****%%%%%%%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%%%%%****%%%****%%%%%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%****%%%%%****%%%%%%%****%%%%%****%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*******%%%%%%%%%%%%%*******%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%***********************%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| reservedTokensMinted+amount<=NUMBER_RESERVED_TOKENS,"This amount is more than max allowed" | 164,737 | reservedTokensMinted+amount<=NUMBER_RESERVED_TOKENS |
"Token ID already minted!" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract HDY721 is ERC721URIStorage, Ownable {
//this mapping is necessary to save the important data like
//collections name, and the price of NFT
mapping(uint256 => string) public collectionsName;
mapping (uint256 => uint256) priceNFT;
address public marketAddress;
//the platform will be used to sign the message signature
address public platformAddress;
event Minted(
address owner,
uint256 tokenId,
string CollectionName,
string tokenURI
);
event PlatformUpdated(
address newPlatformAddress,
uint256 timestamp
);
struct Sig {
bytes32 r;
bytes32 s;
uint8 v;
}
constructor() ERC721("Hiroshima Dragonfly", "HDY") {}
function mint(
address callerAddress,
uint256 tokenId,
string memory _collectionName,
string memory tokenURI,
Sig memory MintRSV
) public {
require(<FILL_ME>)
require(_msgSender() == marketAddress, "The caller must be marketplace contract!");
//this will check is the one who sign the message really from platform or not.
require(
verifySigner(
platformAddress,
messageHash(abi.encodePacked(callerAddress, tokenId)),
MintRSV
),
"Mint Signature Invalid"
);
_mint(callerAddress, tokenId);
_setTokenURI(tokenId, tokenURI);
collectionsName[tokenId] = _collectionName;
emit Minted(callerAddress, tokenId, _collectionName, tokenURI);
}
function setPriceNFT(address callerAdress, uint256 tokenID, uint256 price) public {
}
function getPriceNFT(uint256 tokenID) public view returns (uint256) {
}
function setMarketAddress(address _marketAddress) public onlyOwner {
}
function updatePlatform(address newAddress) public onlyOwner {
}
function messageHash(bytes memory abiEncode)
internal
pure
returns (bytes32)
{
}
function verifySigner(
address signer,
bytes32 ethSignedMessageHash,
Sig memory rsv
) internal pure returns (bool) {
}
}
| !(_exists(tokenId)),"Token ID already minted!" | 164,820 | !(_exists(tokenId)) |
"Mint Signature Invalid" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract HDY721 is ERC721URIStorage, Ownable {
//this mapping is necessary to save the important data like
//collections name, and the price of NFT
mapping(uint256 => string) public collectionsName;
mapping (uint256 => uint256) priceNFT;
address public marketAddress;
//the platform will be used to sign the message signature
address public platformAddress;
event Minted(
address owner,
uint256 tokenId,
string CollectionName,
string tokenURI
);
event PlatformUpdated(
address newPlatformAddress,
uint256 timestamp
);
struct Sig {
bytes32 r;
bytes32 s;
uint8 v;
}
constructor() ERC721("Hiroshima Dragonfly", "HDY") {}
function mint(
address callerAddress,
uint256 tokenId,
string memory _collectionName,
string memory tokenURI,
Sig memory MintRSV
) public {
require(!(_exists(tokenId)), "Token ID already minted!");
require(_msgSender() == marketAddress, "The caller must be marketplace contract!");
//this will check is the one who sign the message really from platform or not.
require(<FILL_ME>)
_mint(callerAddress, tokenId);
_setTokenURI(tokenId, tokenURI);
collectionsName[tokenId] = _collectionName;
emit Minted(callerAddress, tokenId, _collectionName, tokenURI);
}
function setPriceNFT(address callerAdress, uint256 tokenID, uint256 price) public {
}
function getPriceNFT(uint256 tokenID) public view returns (uint256) {
}
function setMarketAddress(address _marketAddress) public onlyOwner {
}
function updatePlatform(address newAddress) public onlyOwner {
}
function messageHash(bytes memory abiEncode)
internal
pure
returns (bytes32)
{
}
function verifySigner(
address signer,
bytes32 ethSignedMessageHash,
Sig memory rsv
) internal pure returns (bool) {
}
}
| verifySigner(platformAddress,messageHash(abi.encodePacked(callerAddress,tokenId)),MintRSV),"Mint Signature Invalid" | 164,820 | verifySigner(platformAddress,messageHash(abi.encodePacked(callerAddress,tokenId)),MintRSV) |
"Insufficient staked amount" | pragma solidity ^0.8.9;
contract ENCInvest is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public encToken;
address public encPool;
address public treasury;
uint256 public proposalMinStake;
AggregatorV3Interface public priceFeed;
struct Proposal {
address proposer;
uint256 investmentAmount;
address investmentTarget;
uint256 endTime;
uint256 forVotes;
uint256 againstVotes;
bool executed;
}
Proposal[] public proposals;
mapping(uint256 => mapping(address => bool)) public proposalVoters;
mapping(address => uint256) public stakedAmount;
mapping(address => uint256) public attributeLevel;
constructor(
address _encToken,
uint256 _proposalMinStake
) {
}
function setTreasury(address _treasury) external onlyOwner {
}
function setEncPool(address _encPool) external onlyOwner{
}
function setProposalMinStake(uint256 _proposalMinStake) external onlyOwner {
}
function setPriceFeed(address priceFeedAddress) external onlyOwner {
}
function stake(uint256 amount, uint256 _attributeLevel) external {
}
function unstake(uint256 amount) external {
require(<FILL_ME>)
stakedAmount[msg.sender] = stakedAmount[msg.sender].sub(amount);
encToken.safeTransfer(msg.sender, amount);
}
function adjustedVotingPower(address staker) public view returns (uint256) {
}
function createProposal(uint256 duration, uint256 investmentAmount, address investmentTarget) external {
}
function vote(uint256 proposalId, bool support) external {
}
function executeProposal(uint256 proposalId) external {
}
function getLatestPrice() public view returns (int) {
}
function rescueTokens(IERC20 token, uint256 amount) external onlyOwner {
}
receive() external payable {}
}
| stakedAmount[msg.sender]>=amount,"Insufficient staked amount" | 164,871 | stakedAmount[msg.sender]>=amount |
"Insufficient staked tokens" | pragma solidity ^0.8.9;
contract ENCInvest is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public encToken;
address public encPool;
address public treasury;
uint256 public proposalMinStake;
AggregatorV3Interface public priceFeed;
struct Proposal {
address proposer;
uint256 investmentAmount;
address investmentTarget;
uint256 endTime;
uint256 forVotes;
uint256 againstVotes;
bool executed;
}
Proposal[] public proposals;
mapping(uint256 => mapping(address => bool)) public proposalVoters;
mapping(address => uint256) public stakedAmount;
mapping(address => uint256) public attributeLevel;
constructor(
address _encToken,
uint256 _proposalMinStake
) {
}
function setTreasury(address _treasury) external onlyOwner {
}
function setEncPool(address _encPool) external onlyOwner{
}
function setProposalMinStake(uint256 _proposalMinStake) external onlyOwner {
}
function setPriceFeed(address priceFeedAddress) external onlyOwner {
}
function stake(uint256 amount, uint256 _attributeLevel) external {
}
function unstake(uint256 amount) external {
}
function adjustedVotingPower(address staker) public view returns (uint256) {
}
function createProposal(uint256 duration, uint256 investmentAmount, address investmentTarget) external {
require(<FILL_ME>)
proposals.push(Proposal({
proposer: msg.sender,
investmentAmount: investmentAmount,
investmentTarget: investmentTarget,
endTime: block.timestamp + duration,
forVotes: 0,
againstVotes: 0,
executed: false
}));
}
function vote(uint256 proposalId, bool support) external {
}
function executeProposal(uint256 proposalId) external {
}
function getLatestPrice() public view returns (int) {
}
function rescueTokens(IERC20 token, uint256 amount) external onlyOwner {
}
receive() external payable {}
}
| stakedAmount[msg.sender]>=proposalMinStake,"Insufficient staked tokens" | 164,871 | stakedAmount[msg.sender]>=proposalMinStake |
"Only stakers can vote" | pragma solidity ^0.8.9;
contract ENCInvest is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public encToken;
address public encPool;
address public treasury;
uint256 public proposalMinStake;
AggregatorV3Interface public priceFeed;
struct Proposal {
address proposer;
uint256 investmentAmount;
address investmentTarget;
uint256 endTime;
uint256 forVotes;
uint256 againstVotes;
bool executed;
}
Proposal[] public proposals;
mapping(uint256 => mapping(address => bool)) public proposalVoters;
mapping(address => uint256) public stakedAmount;
mapping(address => uint256) public attributeLevel;
constructor(
address _encToken,
uint256 _proposalMinStake
) {
}
function setTreasury(address _treasury) external onlyOwner {
}
function setEncPool(address _encPool) external onlyOwner{
}
function setProposalMinStake(uint256 _proposalMinStake) external onlyOwner {
}
function setPriceFeed(address priceFeedAddress) external onlyOwner {
}
function stake(uint256 amount, uint256 _attributeLevel) external {
}
function unstake(uint256 amount) external {
}
function adjustedVotingPower(address staker) public view returns (uint256) {
}
function createProposal(uint256 duration, uint256 investmentAmount, address investmentTarget) external {
}
function vote(uint256 proposalId, bool support) external {
require(proposalId < proposals.length, "Invalid proposal ID");
require(<FILL_ME>)
require(!proposalVoters[proposalId][msg.sender], "Already voted on this proposal");
require(proposals[proposalId].endTime > block.timestamp, "Voting period ended");
uint256 votes = adjustedVotingPower(msg.sender);
proposalVoters[proposalId][msg.sender] = true;
if (support) {
proposals[proposalId].forVotes += votes;
} else {
proposals[proposalId].againstVotes += votes;
}
}
function executeProposal(uint256 proposalId) external {
}
function getLatestPrice() public view returns (int) {
}
function rescueTokens(IERC20 token, uint256 amount) external onlyOwner {
}
receive() external payable {}
}
| stakedAmount[msg.sender]>0,"Only stakers can vote" | 164,871 | stakedAmount[msg.sender]>0 |
"Already voted on this proposal" | pragma solidity ^0.8.9;
contract ENCInvest is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public encToken;
address public encPool;
address public treasury;
uint256 public proposalMinStake;
AggregatorV3Interface public priceFeed;
struct Proposal {
address proposer;
uint256 investmentAmount;
address investmentTarget;
uint256 endTime;
uint256 forVotes;
uint256 againstVotes;
bool executed;
}
Proposal[] public proposals;
mapping(uint256 => mapping(address => bool)) public proposalVoters;
mapping(address => uint256) public stakedAmount;
mapping(address => uint256) public attributeLevel;
constructor(
address _encToken,
uint256 _proposalMinStake
) {
}
function setTreasury(address _treasury) external onlyOwner {
}
function setEncPool(address _encPool) external onlyOwner{
}
function setProposalMinStake(uint256 _proposalMinStake) external onlyOwner {
}
function setPriceFeed(address priceFeedAddress) external onlyOwner {
}
function stake(uint256 amount, uint256 _attributeLevel) external {
}
function unstake(uint256 amount) external {
}
function adjustedVotingPower(address staker) public view returns (uint256) {
}
function createProposal(uint256 duration, uint256 investmentAmount, address investmentTarget) external {
}
function vote(uint256 proposalId, bool support) external {
require(proposalId < proposals.length, "Invalid proposal ID");
require(stakedAmount[msg.sender] > 0, "Only stakers can vote");
require(<FILL_ME>)
require(proposals[proposalId].endTime > block.timestamp, "Voting period ended");
uint256 votes = adjustedVotingPower(msg.sender);
proposalVoters[proposalId][msg.sender] = true;
if (support) {
proposals[proposalId].forVotes += votes;
} else {
proposals[proposalId].againstVotes += votes;
}
}
function executeProposal(uint256 proposalId) external {
}
function getLatestPrice() public view returns (int) {
}
function rescueTokens(IERC20 token, uint256 amount) external onlyOwner {
}
receive() external payable {}
}
| !proposalVoters[proposalId][msg.sender],"Already voted on this proposal" | 164,871 | !proposalVoters[proposalId][msg.sender] |
"Voting period ended" | pragma solidity ^0.8.9;
contract ENCInvest is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public encToken;
address public encPool;
address public treasury;
uint256 public proposalMinStake;
AggregatorV3Interface public priceFeed;
struct Proposal {
address proposer;
uint256 investmentAmount;
address investmentTarget;
uint256 endTime;
uint256 forVotes;
uint256 againstVotes;
bool executed;
}
Proposal[] public proposals;
mapping(uint256 => mapping(address => bool)) public proposalVoters;
mapping(address => uint256) public stakedAmount;
mapping(address => uint256) public attributeLevel;
constructor(
address _encToken,
uint256 _proposalMinStake
) {
}
function setTreasury(address _treasury) external onlyOwner {
}
function setEncPool(address _encPool) external onlyOwner{
}
function setProposalMinStake(uint256 _proposalMinStake) external onlyOwner {
}
function setPriceFeed(address priceFeedAddress) external onlyOwner {
}
function stake(uint256 amount, uint256 _attributeLevel) external {
}
function unstake(uint256 amount) external {
}
function adjustedVotingPower(address staker) public view returns (uint256) {
}
function createProposal(uint256 duration, uint256 investmentAmount, address investmentTarget) external {
}
function vote(uint256 proposalId, bool support) external {
require(proposalId < proposals.length, "Invalid proposal ID");
require(stakedAmount[msg.sender] > 0, "Only stakers can vote");
require(!proposalVoters[proposalId][msg.sender], "Already voted on this proposal");
require(<FILL_ME>)
uint256 votes = adjustedVotingPower(msg.sender);
proposalVoters[proposalId][msg.sender] = true;
if (support) {
proposals[proposalId].forVotes += votes;
} else {
proposals[proposalId].againstVotes += votes;
}
}
function executeProposal(uint256 proposalId) external {
}
function getLatestPrice() public view returns (int) {
}
function rescueTokens(IERC20 token, uint256 amount) external onlyOwner {
}
receive() external payable {}
}
| proposals[proposalId].endTime>block.timestamp,"Voting period ended" | 164,871 | proposals[proposalId].endTime>block.timestamp |
"Proposal already executed" | pragma solidity ^0.8.9;
contract ENCInvest is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public encToken;
address public encPool;
address public treasury;
uint256 public proposalMinStake;
AggregatorV3Interface public priceFeed;
struct Proposal {
address proposer;
uint256 investmentAmount;
address investmentTarget;
uint256 endTime;
uint256 forVotes;
uint256 againstVotes;
bool executed;
}
Proposal[] public proposals;
mapping(uint256 => mapping(address => bool)) public proposalVoters;
mapping(address => uint256) public stakedAmount;
mapping(address => uint256) public attributeLevel;
constructor(
address _encToken,
uint256 _proposalMinStake
) {
}
function setTreasury(address _treasury) external onlyOwner {
}
function setEncPool(address _encPool) external onlyOwner{
}
function setProposalMinStake(uint256 _proposalMinStake) external onlyOwner {
}
function setPriceFeed(address priceFeedAddress) external onlyOwner {
}
function stake(uint256 amount, uint256 _attributeLevel) external {
}
function unstake(uint256 amount) external {
}
function adjustedVotingPower(address staker) public view returns (uint256) {
}
function createProposal(uint256 duration, uint256 investmentAmount, address investmentTarget) external {
}
function vote(uint256 proposalId, bool support) external {
}
function executeProposal(uint256 proposalId) external {
require(proposalId < proposals.length, "Invalid proposal ID");
require(<FILL_ME>)
require(proposals[proposalId].endTime <= block.timestamp, "Voting period not ended");
require(treasury != address(0), "Treasury not set");
Proposal storage proposal = proposals[proposalId];
proposal.executed = true;
if (proposal.forVotes > proposal.againstVotes) {
uint256 investmentAmount = proposal.investmentAmount;
address investmentTarget = proposal.investmentTarget;
(bool successTransfer, ) = treasury.call{value: investmentAmount}("");
require(successTransfer, "ETH transfer from treasury failed");
(bool success, ) = investmentTarget.call{value: investmentAmount}("");
require(success, "Investment execution failed");
uint256 totalRewards = address(this).balance;
require(totalRewards > 0, "No rewards to distribute");
(bool successReward, ) = encPool.call{value: totalRewards}("");
require(successReward, "Reward distribution failed");
}
}
function getLatestPrice() public view returns (int) {
}
function rescueTokens(IERC20 token, uint256 amount) external onlyOwner {
}
receive() external payable {}
}
| !proposals[proposalId].executed,"Proposal already executed" | 164,871 | !proposals[proposalId].executed |
"Voting period not ended" | pragma solidity ^0.8.9;
contract ENCInvest is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public encToken;
address public encPool;
address public treasury;
uint256 public proposalMinStake;
AggregatorV3Interface public priceFeed;
struct Proposal {
address proposer;
uint256 investmentAmount;
address investmentTarget;
uint256 endTime;
uint256 forVotes;
uint256 againstVotes;
bool executed;
}
Proposal[] public proposals;
mapping(uint256 => mapping(address => bool)) public proposalVoters;
mapping(address => uint256) public stakedAmount;
mapping(address => uint256) public attributeLevel;
constructor(
address _encToken,
uint256 _proposalMinStake
) {
}
function setTreasury(address _treasury) external onlyOwner {
}
function setEncPool(address _encPool) external onlyOwner{
}
function setProposalMinStake(uint256 _proposalMinStake) external onlyOwner {
}
function setPriceFeed(address priceFeedAddress) external onlyOwner {
}
function stake(uint256 amount, uint256 _attributeLevel) external {
}
function unstake(uint256 amount) external {
}
function adjustedVotingPower(address staker) public view returns (uint256) {
}
function createProposal(uint256 duration, uint256 investmentAmount, address investmentTarget) external {
}
function vote(uint256 proposalId, bool support) external {
}
function executeProposal(uint256 proposalId) external {
require(proposalId < proposals.length, "Invalid proposal ID");
require(!proposals[proposalId].executed, "Proposal already executed");
require(<FILL_ME>)
require(treasury != address(0), "Treasury not set");
Proposal storage proposal = proposals[proposalId];
proposal.executed = true;
if (proposal.forVotes > proposal.againstVotes) {
uint256 investmentAmount = proposal.investmentAmount;
address investmentTarget = proposal.investmentTarget;
(bool successTransfer, ) = treasury.call{value: investmentAmount}("");
require(successTransfer, "ETH transfer from treasury failed");
(bool success, ) = investmentTarget.call{value: investmentAmount}("");
require(success, "Investment execution failed");
uint256 totalRewards = address(this).balance;
require(totalRewards > 0, "No rewards to distribute");
(bool successReward, ) = encPool.call{value: totalRewards}("");
require(successReward, "Reward distribution failed");
}
}
function getLatestPrice() public view returns (int) {
}
function rescueTokens(IERC20 token, uint256 amount) external onlyOwner {
}
receive() external payable {}
}
| proposals[proposalId].endTime<=block.timestamp,"Voting period not ended" | 164,871 | proposals[proposalId].endTime<=block.timestamp |
"SeedSale: sale is not started yet or ended" | pragma solidity ^0.8.9;
/// @title Seed Sale
contract ETHSeedSale is Ownable {
mapping(address => uint256) public participants;
mapping(address => int256) public participantTokens;
int256 internal constant PRECISION = 1 ether;
int256 internal constant DECIMALS = 10**8;
int256 public BUY_PRICE; //buy price in format 1 base token = amount of sell token, 1 ETH = 0.01 Token
uint256 public SOFTCAP; //soft cap
uint256 public HARDCAP; //hard cap
uint256 public MIN_ETH_PER_WALLET; //min base token per wallet
uint256 public MAX_ETH_PER_WALLET; //max base token per wallet
uint256 public SALE_LENGTH; //sale length in seconds
enum STATUS {
QUED,
ACTIVE,
SUCCESS,
FAILED
}
uint256 public totalCollected; //total ETH collected
int256 public totalSold; //total sold tokens
uint256 public startTime; //start time for presale
uint256 public endTime; //end time for presale
bool forceFailed; //force failed, emergency
AggregatorV3Interface internal priceFeed;
event SellToken(address recipient, int256 tokensSold, uint256 value, int256 amountInUSD, int256 price);
event Refund(address recipient, uint256 ETHToRefund);
event ForceFailed();
event Withdraw(address recipient, uint256 amount);
event SaleTokenChanged(address saleToken);
constructor(
int256 _buyPrice,
uint256 _softCap,
uint256 _hardCap,
uint256 _minETHPerWallet,
uint256 _maxETHPerWallet,
uint256 _startTime,
uint256 _sellLengh,
address _priceFeed
) {
}
receive() external payable {
}
/// @notice sell
/// @dev before this, need approve
function sell() public payable {
uint256 _amount = msg.value;
require(<FILL_ME>)
require(_amount >= MIN_ETH_PER_WALLET, "SeedSale: insufficient purchase amount");
require(_amount <= MAX_ETH_PER_WALLET, "SeedSale: reached purchase amount");
require(participants[_msgSender()] < MAX_ETH_PER_WALLET, "SeedSale: the maximum amount of purchases has been reached");
uint256 newTotalCollected = totalCollected + _amount;
if (HARDCAP < newTotalCollected) {
// Refund anything above the hard cap
uint256 diff = newTotalCollected - HARDCAP;
_amount = _amount - diff;
}
if (_amount >= MAX_ETH_PER_WALLET - participants[_msgSender()]) {
_amount = MAX_ETH_PER_WALLET - participants[_msgSender()];
}
// Save participants eth
participants[_msgSender()] = participants[_msgSender()] + _amount;
// 2* 10^18 * 182221 * 10^6 / 10^8 = 364442 * 10^16
int256 price = getLatestPrice();
int256 amountInUSD = int256(_amount) * price / DECIMALS;
int256 tokensSold = amountInUSD * PRECISION / BUY_PRICE;
// Save participant tokens
participantTokens[_msgSender()] = participantTokens[_msgSender()] + tokensSold;
// Update total ETH
totalCollected = totalCollected + _amount;
// Update tokens sold
totalSold = totalSold + tokensSold;
if (_amount < msg.value) {
//refund
_deliverFunds(_msgSender(), msg.value - _amount, "Cant send ETH");
}
emit SellToken(_msgSender(), tokensSold, _amount, amountInUSD, price);
}
function getLatestPrice() public view returns (int) {
}
/// @notice refund base tokens
/// @dev only if sale status is failed
function refund() external {
}
///@notice withdraw all ETH
///@param _recipient address
///@dev from owner
function withdraw(address _recipient) external virtual onlyOwner {
}
/// @notice force fail contract
/// @dev in other world, emergency exit
function forceFail() external onlyOwner {
}
/// sale status
function status() public view returns (STATUS) {
}
///@notice get token amount
///@param _account account
function getTokenAmount(address _account) public view returns (int256 tokenAmount) {
}
function _withdraw(address _recipient, uint256 _amount) internal virtual {
}
function _deliverFunds(
address _recipient,
uint256 _value,
string memory _message
) internal {
}
}
| status()==STATUS.ACTIVE,"SeedSale: sale is not started yet or ended" | 164,948 | status()==STATUS.ACTIVE |
"SeedSale: the maximum amount of purchases has been reached" | pragma solidity ^0.8.9;
/// @title Seed Sale
contract ETHSeedSale is Ownable {
mapping(address => uint256) public participants;
mapping(address => int256) public participantTokens;
int256 internal constant PRECISION = 1 ether;
int256 internal constant DECIMALS = 10**8;
int256 public BUY_PRICE; //buy price in format 1 base token = amount of sell token, 1 ETH = 0.01 Token
uint256 public SOFTCAP; //soft cap
uint256 public HARDCAP; //hard cap
uint256 public MIN_ETH_PER_WALLET; //min base token per wallet
uint256 public MAX_ETH_PER_WALLET; //max base token per wallet
uint256 public SALE_LENGTH; //sale length in seconds
enum STATUS {
QUED,
ACTIVE,
SUCCESS,
FAILED
}
uint256 public totalCollected; //total ETH collected
int256 public totalSold; //total sold tokens
uint256 public startTime; //start time for presale
uint256 public endTime; //end time for presale
bool forceFailed; //force failed, emergency
AggregatorV3Interface internal priceFeed;
event SellToken(address recipient, int256 tokensSold, uint256 value, int256 amountInUSD, int256 price);
event Refund(address recipient, uint256 ETHToRefund);
event ForceFailed();
event Withdraw(address recipient, uint256 amount);
event SaleTokenChanged(address saleToken);
constructor(
int256 _buyPrice,
uint256 _softCap,
uint256 _hardCap,
uint256 _minETHPerWallet,
uint256 _maxETHPerWallet,
uint256 _startTime,
uint256 _sellLengh,
address _priceFeed
) {
}
receive() external payable {
}
/// @notice sell
/// @dev before this, need approve
function sell() public payable {
uint256 _amount = msg.value;
require(status() == STATUS.ACTIVE, "SeedSale: sale is not started yet or ended");
require(_amount >= MIN_ETH_PER_WALLET, "SeedSale: insufficient purchase amount");
require(_amount <= MAX_ETH_PER_WALLET, "SeedSale: reached purchase amount");
require(<FILL_ME>)
uint256 newTotalCollected = totalCollected + _amount;
if (HARDCAP < newTotalCollected) {
// Refund anything above the hard cap
uint256 diff = newTotalCollected - HARDCAP;
_amount = _amount - diff;
}
if (_amount >= MAX_ETH_PER_WALLET - participants[_msgSender()]) {
_amount = MAX_ETH_PER_WALLET - participants[_msgSender()];
}
// Save participants eth
participants[_msgSender()] = participants[_msgSender()] + _amount;
// 2* 10^18 * 182221 * 10^6 / 10^8 = 364442 * 10^16
int256 price = getLatestPrice();
int256 amountInUSD = int256(_amount) * price / DECIMALS;
int256 tokensSold = amountInUSD * PRECISION / BUY_PRICE;
// Save participant tokens
participantTokens[_msgSender()] = participantTokens[_msgSender()] + tokensSold;
// Update total ETH
totalCollected = totalCollected + _amount;
// Update tokens sold
totalSold = totalSold + tokensSold;
if (_amount < msg.value) {
//refund
_deliverFunds(_msgSender(), msg.value - _amount, "Cant send ETH");
}
emit SellToken(_msgSender(), tokensSold, _amount, amountInUSD, price);
}
function getLatestPrice() public view returns (int) {
}
/// @notice refund base tokens
/// @dev only if sale status is failed
function refund() external {
}
///@notice withdraw all ETH
///@param _recipient address
///@dev from owner
function withdraw(address _recipient) external virtual onlyOwner {
}
/// @notice force fail contract
/// @dev in other world, emergency exit
function forceFail() external onlyOwner {
}
/// sale status
function status() public view returns (STATUS) {
}
///@notice get token amount
///@param _account account
function getTokenAmount(address _account) public view returns (int256 tokenAmount) {
}
function _withdraw(address _recipient, uint256 _amount) internal virtual {
}
function _deliverFunds(
address _recipient,
uint256 _value,
string memory _message
) internal {
}
}
| participants[_msgSender()]<MAX_ETH_PER_WALLET,"SeedSale: the maximum amount of purchases has been reached" | 164,948 | participants[_msgSender()]<MAX_ETH_PER_WALLET |
"SeedSale: sale is failed" | pragma solidity ^0.8.9;
/// @title Seed Sale
contract ETHSeedSale is Ownable {
mapping(address => uint256) public participants;
mapping(address => int256) public participantTokens;
int256 internal constant PRECISION = 1 ether;
int256 internal constant DECIMALS = 10**8;
int256 public BUY_PRICE; //buy price in format 1 base token = amount of sell token, 1 ETH = 0.01 Token
uint256 public SOFTCAP; //soft cap
uint256 public HARDCAP; //hard cap
uint256 public MIN_ETH_PER_WALLET; //min base token per wallet
uint256 public MAX_ETH_PER_WALLET; //max base token per wallet
uint256 public SALE_LENGTH; //sale length in seconds
enum STATUS {
QUED,
ACTIVE,
SUCCESS,
FAILED
}
uint256 public totalCollected; //total ETH collected
int256 public totalSold; //total sold tokens
uint256 public startTime; //start time for presale
uint256 public endTime; //end time for presale
bool forceFailed; //force failed, emergency
AggregatorV3Interface internal priceFeed;
event SellToken(address recipient, int256 tokensSold, uint256 value, int256 amountInUSD, int256 price);
event Refund(address recipient, uint256 ETHToRefund);
event ForceFailed();
event Withdraw(address recipient, uint256 amount);
event SaleTokenChanged(address saleToken);
constructor(
int256 _buyPrice,
uint256 _softCap,
uint256 _hardCap,
uint256 _minETHPerWallet,
uint256 _maxETHPerWallet,
uint256 _startTime,
uint256 _sellLengh,
address _priceFeed
) {
}
receive() external payable {
}
/// @notice sell
/// @dev before this, need approve
function sell() public payable {
}
function getLatestPrice() public view returns (int) {
}
/// @notice refund base tokens
/// @dev only if sale status is failed
function refund() external {
require(<FILL_ME>)
require(participants[_msgSender()] > 0, "SeedSale: no tokens for refund");
uint256 ETHToRefund = participants[_msgSender()];
participants[_msgSender()] = 0;
_withdraw(_msgSender(), ETHToRefund);
emit Refund(_msgSender(), ETHToRefund);
}
///@notice withdraw all ETH
///@param _recipient address
///@dev from owner
function withdraw(address _recipient) external virtual onlyOwner {
}
/// @notice force fail contract
/// @dev in other world, emergency exit
function forceFail() external onlyOwner {
}
/// sale status
function status() public view returns (STATUS) {
}
///@notice get token amount
///@param _account account
function getTokenAmount(address _account) public view returns (int256 tokenAmount) {
}
function _withdraw(address _recipient, uint256 _amount) internal virtual {
}
function _deliverFunds(
address _recipient,
uint256 _value,
string memory _message
) internal {
}
}
| status()==STATUS.FAILED,"SeedSale: sale is failed" | 164,948 | status()==STATUS.FAILED |
"SeedSale: no tokens for refund" | pragma solidity ^0.8.9;
/// @title Seed Sale
contract ETHSeedSale is Ownable {
mapping(address => uint256) public participants;
mapping(address => int256) public participantTokens;
int256 internal constant PRECISION = 1 ether;
int256 internal constant DECIMALS = 10**8;
int256 public BUY_PRICE; //buy price in format 1 base token = amount of sell token, 1 ETH = 0.01 Token
uint256 public SOFTCAP; //soft cap
uint256 public HARDCAP; //hard cap
uint256 public MIN_ETH_PER_WALLET; //min base token per wallet
uint256 public MAX_ETH_PER_WALLET; //max base token per wallet
uint256 public SALE_LENGTH; //sale length in seconds
enum STATUS {
QUED,
ACTIVE,
SUCCESS,
FAILED
}
uint256 public totalCollected; //total ETH collected
int256 public totalSold; //total sold tokens
uint256 public startTime; //start time for presale
uint256 public endTime; //end time for presale
bool forceFailed; //force failed, emergency
AggregatorV3Interface internal priceFeed;
event SellToken(address recipient, int256 tokensSold, uint256 value, int256 amountInUSD, int256 price);
event Refund(address recipient, uint256 ETHToRefund);
event ForceFailed();
event Withdraw(address recipient, uint256 amount);
event SaleTokenChanged(address saleToken);
constructor(
int256 _buyPrice,
uint256 _softCap,
uint256 _hardCap,
uint256 _minETHPerWallet,
uint256 _maxETHPerWallet,
uint256 _startTime,
uint256 _sellLengh,
address _priceFeed
) {
}
receive() external payable {
}
/// @notice sell
/// @dev before this, need approve
function sell() public payable {
}
function getLatestPrice() public view returns (int) {
}
/// @notice refund base tokens
/// @dev only if sale status is failed
function refund() external {
require(status() == STATUS.FAILED, "SeedSale: sale is failed");
require(<FILL_ME>)
uint256 ETHToRefund = participants[_msgSender()];
participants[_msgSender()] = 0;
_withdraw(_msgSender(), ETHToRefund);
emit Refund(_msgSender(), ETHToRefund);
}
///@notice withdraw all ETH
///@param _recipient address
///@dev from owner
function withdraw(address _recipient) external virtual onlyOwner {
}
/// @notice force fail contract
/// @dev in other world, emergency exit
function forceFail() external onlyOwner {
}
/// sale status
function status() public view returns (STATUS) {
}
///@notice get token amount
///@param _account account
function getTokenAmount(address _account) public view returns (int256 tokenAmount) {
}
function _withdraw(address _recipient, uint256 _amount) internal virtual {
}
function _deliverFunds(
address _recipient,
uint256 _value,
string memory _message
) internal {
}
}
| participants[_msgSender()]>0,"SeedSale: no tokens for refund" | 164,948 | participants[_msgSender()]>0 |
"SeedSale: failed or active" | pragma solidity ^0.8.9;
/// @title Seed Sale
contract ETHSeedSale is Ownable {
mapping(address => uint256) public participants;
mapping(address => int256) public participantTokens;
int256 internal constant PRECISION = 1 ether;
int256 internal constant DECIMALS = 10**8;
int256 public BUY_PRICE; //buy price in format 1 base token = amount of sell token, 1 ETH = 0.01 Token
uint256 public SOFTCAP; //soft cap
uint256 public HARDCAP; //hard cap
uint256 public MIN_ETH_PER_WALLET; //min base token per wallet
uint256 public MAX_ETH_PER_WALLET; //max base token per wallet
uint256 public SALE_LENGTH; //sale length in seconds
enum STATUS {
QUED,
ACTIVE,
SUCCESS,
FAILED
}
uint256 public totalCollected; //total ETH collected
int256 public totalSold; //total sold tokens
uint256 public startTime; //start time for presale
uint256 public endTime; //end time for presale
bool forceFailed; //force failed, emergency
AggregatorV3Interface internal priceFeed;
event SellToken(address recipient, int256 tokensSold, uint256 value, int256 amountInUSD, int256 price);
event Refund(address recipient, uint256 ETHToRefund);
event ForceFailed();
event Withdraw(address recipient, uint256 amount);
event SaleTokenChanged(address saleToken);
constructor(
int256 _buyPrice,
uint256 _softCap,
uint256 _hardCap,
uint256 _minETHPerWallet,
uint256 _maxETHPerWallet,
uint256 _startTime,
uint256 _sellLengh,
address _priceFeed
) {
}
receive() external payable {
}
/// @notice sell
/// @dev before this, need approve
function sell() public payable {
}
function getLatestPrice() public view returns (int) {
}
/// @notice refund base tokens
/// @dev only if sale status is failed
function refund() external {
}
///@notice withdraw all ETH
///@param _recipient address
///@dev from owner
function withdraw(address _recipient) external virtual onlyOwner {
require(<FILL_ME>)
_withdraw(_recipient, address(this).balance);
}
/// @notice force fail contract
/// @dev in other world, emergency exit
function forceFail() external onlyOwner {
}
/// sale status
function status() public view returns (STATUS) {
}
///@notice get token amount
///@param _account account
function getTokenAmount(address _account) public view returns (int256 tokenAmount) {
}
function _withdraw(address _recipient, uint256 _amount) internal virtual {
}
function _deliverFunds(
address _recipient,
uint256 _value,
string memory _message
) internal {
}
}
| status()==STATUS.SUCCESS,"SeedSale: failed or active" | 164,948 | status()==STATUS.SUCCESS |
null | /**
https://t.me/GiveDirectly_ETH
5% Tax
*/
pragma solidity ^0.8.9;
// SPDX-License-Identifier: Unlicensed
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
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 GIVE is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Give Directly";
string private constant _symbol = "GIVE";
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 = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 5;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 5;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
address payable private _developmentAddress = payable(0x29821a7b5209a78eE20125DcC6B6c8a9EB80Ad15);
address payable private _marketingAddress = payable(0x29821a7b5209a78eE20125DcC6B6c8a9EB80Ad15);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = true;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 1000000000 * 10**9;
uint256 public _maxWalletSize = 30000000 * 10**9;
uint256 public _swapTokensAtAmount = 500000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function 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 {
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
require(<FILL_ME>)
}
//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 excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| _redisFeeOnBuy+_redisFeeOnSell+_taxFeeOnBuy+_taxFeeOnSell<=25 | 164,956 | _redisFeeOnBuy+_redisFeeOnSell+_taxFeeOnBuy+_taxFeeOnSell<=25 |
"!valid" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import {ERC20} from "solmate/tokens/ERC20.sol";
import {WETH} from "solmate/tokens/WETH.sol";
import {Owned} from "solmate/auth/Owned.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
import {IUniswapV2Factory} from "./interfaces/IUniswapV2Factory.sol";
import {IUniswapV2Router} from "./interfaces/IUniswapV2Router.sol";
// Twitter: https://twitter.com/BRKHathaway
// Telegram: https://t.me/BRKETFPortal
// Website: https://berkshirehathaway.finance
contract BRK is ERC20, Owned {
using SafeTransferLib for ERC20;
struct User {
bool isBlacklisted;
bool isAutomatedMarketMaker;
bool isExcludedFromFees;
bool isExcludedFromMaxTransactionAmount;
}
struct Fees {
uint8 buy;
uint8 sell;
uint8 liquidity;
uint8 index;
uint8 development;
}
struct Settings {
bool limitsInEffect;
bool swapEnabled;
bool blacklistRenounced;
bool feeChangeRenounced;
bool tradingActive;
/// @dev Upon enabling trading, record the end block for bot protection fee
/// @dev This fee is a 90% fee that is reduced by 5% every block for 18 blocks.
uint216 endBlock;
}
uint256 public constant MAX_SUPPLY = 1_000_000_000 * 1e18;
uint256 public constant MIN_SWAP_AMOUNT = MAX_SUPPLY / 100_000; // 0.001%
uint256 public constant MAX_SWAP_AMOUNT = (MAX_SUPPLY * 5) / 1_000; // 0.5%
IUniswapV2Router public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public immutable index;
address public immutable developmentWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
uint256 public tokensForBotProtection;
Fees public feeAmounts;
bool private _swapping;
Settings private settings =
Settings({
limitsInEffect: true,
swapEnabled: true,
blacklistRenounced: false,
feeChangeRenounced: false,
tradingActive: false,
endBlock: uint216(0)
});
mapping(address => User) private _users;
address private wethAddress;
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludeFromMaxTransaction(address indexed account, bool isExcluded);
event FailedSwapBackTransfer(address indexed destination, uint256 amount);
event MaxTransactionAmountUpdated(uint256 newAmount, uint256 oldAmount);
event SetAutomatedMarketMakerPair(address indexed pair, bool value);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived);
event SwapTokensAtAmountUpdated(uint256 newAmount, uint256 oldAmount);
error Index__BlacklistModificationDisabled();
error Index__BuyAmountGreaterThanMax();
error Index__CannotBlacklistLPPair();
error Index__CannotBlacklistRouter();
error Index__CannotRemovePairFromAMMs();
error Index__CannotTransferFromAddressZero();
error Index__CannotTransferToAddressZero();
error Index__ErrorWithdrawingEth();
error Index__FeeChangeRenounced();
error Index__MaxFeeFivePercent();
error Index__MaxTransactionTooLow();
error Index__MaxWalletAmountExceeded();
error Index__MaxWalletAmountTooLow();
error Index__OnlyOwner();
error Index__ReceiverBlacklisted();
error Index__ReceiverCannotBeAddressZero();
error Index__SellAmountGreaterThanMax();
error Index__SenderBlacklisted();
error Index__StuckEthWithdrawError();
error Index__SwapAmountGreaterThanMaximum();
error Index__SwapAmountLowerThanMinimum();
error Index__TokenAddressCannotBeAddressZero();
error Index__TradingNotActive();
constructor() ERC20("Berkshire Hathaway", "BRK", 18) Owned(msg.sender) {
}
receive() external payable {}
function _requireIsOwner() internal view {
}
function burn(address from, uint256 amount) external {
}
function updateFees(Fees memory newFees) external {
_requireIsOwner();
require(<FILL_ME>)
feeAmounts = newFees;
}
function enableTrading() external {
}
function removeLimits() external {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external {
}
function updateMaxTransactionAmount(uint256 newAmount) external {
}
function excludeFromFees(address account, bool excluded) external {
}
function excludeFromMaxTransaction(
address account,
bool isExcluded
) external {
}
function setAutomatedMarketMakerPair(address pair, bool value) external {
}
function renounceBlacklist() external {
}
function blacklist(address account) external {
}
// @dev unblacklist address; not affected by blacklistRenounced incase team wants to unblacklist v3 pools down the
function unblacklist(address account) external {
}
function isExcludedFromFees(address account) external view returns (bool) {
}
function isExcludedFromMaxTransactionAmount(
address account
) external view returns (bool) {
}
function isAutomatedMarketMakerPair(
address pair
) external view returns (bool) {
}
function isBlacklisted(address account) external view returns (bool) {
}
function isSwapEnabled() external view returns (bool) {
}
function isBlacklistRenounced() external view returns (bool) {
}
function isFeeChangeRenounced() external view returns (bool) {
}
function isTradingActive() external view returns (bool) {
}
function isLimitInEffect() external view returns (bool) {
}
function transfer(
address to,
uint256 amount
) public override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public override returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal returns (bool) {
}
function _swapTokensForEth(uint256 tokenAmount) internal {
}
function _addLiquidity(uint256 tokenAmount, uint256 ethAmount) internal {
}
function _doTransfer(
address from,
address to,
uint256 amount
) internal returns (bool) {
}
function _swapBack() internal {
}
function _approve(address spender, uint256 amount) internal onlyOwner {
}
}
| newFees.development+newFees.index+newFees.liquidity==100,"!valid" | 164,957 | newFees.development+newFees.index+newFees.liquidity==100 |
"can only mint with whitelist signature" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/example/DefaultOperatorFilterer721.sol";
contract DollIsland is Ownable, ERC721A, DefaultOperatorFilterer721 {
using ECDSA for bytes32;
using Strings for uint256;
struct SaleConfig {
uint256 presalePrice;
uint256 publicPrice;
}
SaleConfig public saleConfig;
bool public saleIsActive;
bool public presaleIsActive;
uint256 private maxBatchSize;
uint256 public collectionSize;
uint256 public presaleSize;
uint256 public reserved;
string private baseTokenURI;
bool public revealed;
mapping(address => uint256) public userToUsedNonce;
mapping(address => bool) public userToMinted;
mapping(address => bool) internal _publicFreeMinted;
address public signer;
constructor() ERC721A("DollIsland", "DOLL") DefaultOperatorFilterer721() {
}
modifier noContract() {
}
function presaleMint(
uint256 quantity,
bool isWhiltelist,
bool isHolder,
bytes calldata signature
) external payable {
require(presaleIsActive, "presale is not active");
require(<FILL_ME>)
require(totalSupply() + quantity <= presaleSize, "max supply reached in presale phase");
require(msg.value >= saleConfig.presalePrice * quantity, "insufficient funds");
require(quantity <= maxBatchSize, "can at most mint 5 at once ");
super._safeMint(msg.sender, quantity);
}
function freeMint(
bool isWhitelist,
bool isHolder,
bytes calldata signature
) external payable noContract {
}
function publicMint(uint256 quantity) external payable noContract {
}
function findMintCost(uint256 quantity) public view returns (uint256) {
}
function verifyFreemintSignature(
bool isWhitelist,
bool isHolder,
bytes calldata signature
) internal view returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A) onlyAllowedOperator(from) {
}
/**
* @dev implements operator-filter-registry blocklist filtering because https://opensea.io/blog/announcements/on-creator-fees/
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A) onlyAllowedOperator(from) {
}
/**
* @dev implements operator-filter-registry blocklist filtering because https://opensea.io/blog/announcements/on-creator-fees/
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override(ERC721A) onlyAllowedOperator(from) {
}
function setPrice(uint256 _presalePrice, uint256 _publicPrice) external onlyOwner {
}
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
function setBaseURI(string calldata _baseTokenURI) external onlyOwner {
}
function setPresale(bool _presaleIsActive) external onlyOwner {
}
function setSale(bool _saleIsActive) external onlyOwner {
}
function setCollectionSize(uint256 _collectionSize) external onlyOwner {
}
function setSigner(address _signer) external onlyOwner {
}
function setReveal(bool _reveal) external onlyOwner {
}
// view function
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
}
| verifyFreemintSignature(isWhiltelist,isHolder,signature),"can only mint with whitelist signature" | 165,086 | verifyFreemintSignature(isWhiltelist,isHolder,signature) |
"max supply reached in presale phase" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/example/DefaultOperatorFilterer721.sol";
contract DollIsland is Ownable, ERC721A, DefaultOperatorFilterer721 {
using ECDSA for bytes32;
using Strings for uint256;
struct SaleConfig {
uint256 presalePrice;
uint256 publicPrice;
}
SaleConfig public saleConfig;
bool public saleIsActive;
bool public presaleIsActive;
uint256 private maxBatchSize;
uint256 public collectionSize;
uint256 public presaleSize;
uint256 public reserved;
string private baseTokenURI;
bool public revealed;
mapping(address => uint256) public userToUsedNonce;
mapping(address => bool) public userToMinted;
mapping(address => bool) internal _publicFreeMinted;
address public signer;
constructor() ERC721A("DollIsland", "DOLL") DefaultOperatorFilterer721() {
}
modifier noContract() {
}
function presaleMint(
uint256 quantity,
bool isWhiltelist,
bool isHolder,
bytes calldata signature
) external payable {
require(presaleIsActive, "presale is not active");
require(verifyFreemintSignature(isWhiltelist, isHolder, signature), "can only mint with whitelist signature");
require(<FILL_ME>)
require(msg.value >= saleConfig.presalePrice * quantity, "insufficient funds");
require(quantity <= maxBatchSize, "can at most mint 5 at once ");
super._safeMint(msg.sender, quantity);
}
function freeMint(
bool isWhitelist,
bool isHolder,
bytes calldata signature
) external payable noContract {
}
function publicMint(uint256 quantity) external payable noContract {
}
function findMintCost(uint256 quantity) public view returns (uint256) {
}
function verifyFreemintSignature(
bool isWhitelist,
bool isHolder,
bytes calldata signature
) internal view returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A) onlyAllowedOperator(from) {
}
/**
* @dev implements operator-filter-registry blocklist filtering because https://opensea.io/blog/announcements/on-creator-fees/
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A) onlyAllowedOperator(from) {
}
/**
* @dev implements operator-filter-registry blocklist filtering because https://opensea.io/blog/announcements/on-creator-fees/
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override(ERC721A) onlyAllowedOperator(from) {
}
function setPrice(uint256 _presalePrice, uint256 _publicPrice) external onlyOwner {
}
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
function setBaseURI(string calldata _baseTokenURI) external onlyOwner {
}
function setPresale(bool _presaleIsActive) external onlyOwner {
}
function setSale(bool _saleIsActive) external onlyOwner {
}
function setCollectionSize(uint256 _collectionSize) external onlyOwner {
}
function setSigner(address _signer) external onlyOwner {
}
function setReveal(bool _reveal) external onlyOwner {
}
// view function
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
}
| totalSupply()+quantity<=presaleSize,"max supply reached in presale phase" | 165,086 | totalSupply()+quantity<=presaleSize |
"can only mint with whitelist and holder signature" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/example/DefaultOperatorFilterer721.sol";
contract DollIsland is Ownable, ERC721A, DefaultOperatorFilterer721 {
using ECDSA for bytes32;
using Strings for uint256;
struct SaleConfig {
uint256 presalePrice;
uint256 publicPrice;
}
SaleConfig public saleConfig;
bool public saleIsActive;
bool public presaleIsActive;
uint256 private maxBatchSize;
uint256 public collectionSize;
uint256 public presaleSize;
uint256 public reserved;
string private baseTokenURI;
bool public revealed;
mapping(address => uint256) public userToUsedNonce;
mapping(address => bool) public userToMinted;
mapping(address => bool) internal _publicFreeMinted;
address public signer;
constructor() ERC721A("DollIsland", "DOLL") DefaultOperatorFilterer721() {
}
modifier noContract() {
}
function presaleMint(
uint256 quantity,
bool isWhiltelist,
bool isHolder,
bytes calldata signature
) external payable {
}
function freeMint(
bool isWhitelist,
bool isHolder,
bytes calldata signature
) external payable noContract {
require(presaleIsActive, "presale is not active");
require(<FILL_ME>)
require(userToMinted[msg.sender] == false, "can only mint once");
require(totalSupply() <= presaleSize, "there are no free mints left");
// whitelist mint
if (isWhitelist && isHolder) {
super._safeMint(msg.sender, 5);
userToMinted[msg.sender] = true;
// holder mint
} else if (isHolder) {
super._safeMint(msg.sender, 5);
userToMinted[msg.sender] = true;
} else if (isWhitelist) {
// whitelist and holder mint
super._safeMint(msg.sender, 2);
userToMinted[msg.sender] = true;
}
}
function publicMint(uint256 quantity) external payable noContract {
}
function findMintCost(uint256 quantity) public view returns (uint256) {
}
function verifyFreemintSignature(
bool isWhitelist,
bool isHolder,
bytes calldata signature
) internal view returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A) onlyAllowedOperator(from) {
}
/**
* @dev implements operator-filter-registry blocklist filtering because https://opensea.io/blog/announcements/on-creator-fees/
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A) onlyAllowedOperator(from) {
}
/**
* @dev implements operator-filter-registry blocklist filtering because https://opensea.io/blog/announcements/on-creator-fees/
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override(ERC721A) onlyAllowedOperator(from) {
}
function setPrice(uint256 _presalePrice, uint256 _publicPrice) external onlyOwner {
}
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
function setBaseURI(string calldata _baseTokenURI) external onlyOwner {
}
function setPresale(bool _presaleIsActive) external onlyOwner {
}
function setSale(bool _saleIsActive) external onlyOwner {
}
function setCollectionSize(uint256 _collectionSize) external onlyOwner {
}
function setSigner(address _signer) external onlyOwner {
}
function setReveal(bool _reveal) external onlyOwner {
}
// view function
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
}
| verifyFreemintSignature(isWhitelist,isHolder,signature),"can only mint with whitelist and holder signature" | 165,086 | verifyFreemintSignature(isWhitelist,isHolder,signature) |
"can only mint once" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/example/DefaultOperatorFilterer721.sol";
contract DollIsland is Ownable, ERC721A, DefaultOperatorFilterer721 {
using ECDSA for bytes32;
using Strings for uint256;
struct SaleConfig {
uint256 presalePrice;
uint256 publicPrice;
}
SaleConfig public saleConfig;
bool public saleIsActive;
bool public presaleIsActive;
uint256 private maxBatchSize;
uint256 public collectionSize;
uint256 public presaleSize;
uint256 public reserved;
string private baseTokenURI;
bool public revealed;
mapping(address => uint256) public userToUsedNonce;
mapping(address => bool) public userToMinted;
mapping(address => bool) internal _publicFreeMinted;
address public signer;
constructor() ERC721A("DollIsland", "DOLL") DefaultOperatorFilterer721() {
}
modifier noContract() {
}
function presaleMint(
uint256 quantity,
bool isWhiltelist,
bool isHolder,
bytes calldata signature
) external payable {
}
function freeMint(
bool isWhitelist,
bool isHolder,
bytes calldata signature
) external payable noContract {
require(presaleIsActive, "presale is not active");
require(verifyFreemintSignature(isWhitelist, isHolder, signature), "can only mint with whitelist and holder signature");
require(<FILL_ME>)
require(totalSupply() <= presaleSize, "there are no free mints left");
// whitelist mint
if (isWhitelist && isHolder) {
super._safeMint(msg.sender, 5);
userToMinted[msg.sender] = true;
// holder mint
} else if (isHolder) {
super._safeMint(msg.sender, 5);
userToMinted[msg.sender] = true;
} else if (isWhitelist) {
// whitelist and holder mint
super._safeMint(msg.sender, 2);
userToMinted[msg.sender] = true;
}
}
function publicMint(uint256 quantity) external payable noContract {
}
function findMintCost(uint256 quantity) public view returns (uint256) {
}
function verifyFreemintSignature(
bool isWhitelist,
bool isHolder,
bytes calldata signature
) internal view returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A) onlyAllowedOperator(from) {
}
/**
* @dev implements operator-filter-registry blocklist filtering because https://opensea.io/blog/announcements/on-creator-fees/
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A) onlyAllowedOperator(from) {
}
/**
* @dev implements operator-filter-registry blocklist filtering because https://opensea.io/blog/announcements/on-creator-fees/
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override(ERC721A) onlyAllowedOperator(from) {
}
function setPrice(uint256 _presalePrice, uint256 _publicPrice) external onlyOwner {
}
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
function setBaseURI(string calldata _baseTokenURI) external onlyOwner {
}
function setPresale(bool _presaleIsActive) external onlyOwner {
}
function setSale(bool _saleIsActive) external onlyOwner {
}
function setCollectionSize(uint256 _collectionSize) external onlyOwner {
}
function setSigner(address _signer) external onlyOwner {
}
function setReveal(bool _reveal) external onlyOwner {
}
// view function
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
}
| userToMinted[msg.sender]==false,"can only mint once" | 165,086 | userToMinted[msg.sender]==false |
"there are no free mints left" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/example/DefaultOperatorFilterer721.sol";
contract DollIsland is Ownable, ERC721A, DefaultOperatorFilterer721 {
using ECDSA for bytes32;
using Strings for uint256;
struct SaleConfig {
uint256 presalePrice;
uint256 publicPrice;
}
SaleConfig public saleConfig;
bool public saleIsActive;
bool public presaleIsActive;
uint256 private maxBatchSize;
uint256 public collectionSize;
uint256 public presaleSize;
uint256 public reserved;
string private baseTokenURI;
bool public revealed;
mapping(address => uint256) public userToUsedNonce;
mapping(address => bool) public userToMinted;
mapping(address => bool) internal _publicFreeMinted;
address public signer;
constructor() ERC721A("DollIsland", "DOLL") DefaultOperatorFilterer721() {
}
modifier noContract() {
}
function presaleMint(
uint256 quantity,
bool isWhiltelist,
bool isHolder,
bytes calldata signature
) external payable {
}
function freeMint(
bool isWhitelist,
bool isHolder,
bytes calldata signature
) external payable noContract {
require(presaleIsActive, "presale is not active");
require(verifyFreemintSignature(isWhitelist, isHolder, signature), "can only mint with whitelist and holder signature");
require(userToMinted[msg.sender] == false, "can only mint once");
require(<FILL_ME>)
// whitelist mint
if (isWhitelist && isHolder) {
super._safeMint(msg.sender, 5);
userToMinted[msg.sender] = true;
// holder mint
} else if (isHolder) {
super._safeMint(msg.sender, 5);
userToMinted[msg.sender] = true;
} else if (isWhitelist) {
// whitelist and holder mint
super._safeMint(msg.sender, 2);
userToMinted[msg.sender] = true;
}
}
function publicMint(uint256 quantity) external payable noContract {
}
function findMintCost(uint256 quantity) public view returns (uint256) {
}
function verifyFreemintSignature(
bool isWhitelist,
bool isHolder,
bytes calldata signature
) internal view returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A) onlyAllowedOperator(from) {
}
/**
* @dev implements operator-filter-registry blocklist filtering because https://opensea.io/blog/announcements/on-creator-fees/
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A) onlyAllowedOperator(from) {
}
/**
* @dev implements operator-filter-registry blocklist filtering because https://opensea.io/blog/announcements/on-creator-fees/
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override(ERC721A) onlyAllowedOperator(from) {
}
function setPrice(uint256 _presalePrice, uint256 _publicPrice) external onlyOwner {
}
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
function setBaseURI(string calldata _baseTokenURI) external onlyOwner {
}
function setPresale(bool _presaleIsActive) external onlyOwner {
}
function setSale(bool _saleIsActive) external onlyOwner {
}
function setCollectionSize(uint256 _collectionSize) external onlyOwner {
}
function setSigner(address _signer) external onlyOwner {
}
function setReveal(bool _reveal) external onlyOwner {
}
// view function
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
}
| totalSupply()<=presaleSize,"there are no free mints left" | 165,086 | totalSupply()<=presaleSize |
"must be whitelist or holder" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/example/DefaultOperatorFilterer721.sol";
contract DollIsland is Ownable, ERC721A, DefaultOperatorFilterer721 {
using ECDSA for bytes32;
using Strings for uint256;
struct SaleConfig {
uint256 presalePrice;
uint256 publicPrice;
}
SaleConfig public saleConfig;
bool public saleIsActive;
bool public presaleIsActive;
uint256 private maxBatchSize;
uint256 public collectionSize;
uint256 public presaleSize;
uint256 public reserved;
string private baseTokenURI;
bool public revealed;
mapping(address => uint256) public userToUsedNonce;
mapping(address => bool) public userToMinted;
mapping(address => bool) internal _publicFreeMinted;
address public signer;
constructor() ERC721A("DollIsland", "DOLL") DefaultOperatorFilterer721() {
}
modifier noContract() {
}
function presaleMint(
uint256 quantity,
bool isWhiltelist,
bool isHolder,
bytes calldata signature
) external payable {
}
function freeMint(
bool isWhitelist,
bool isHolder,
bytes calldata signature
) external payable noContract {
}
function publicMint(uint256 quantity) external payable noContract {
}
function findMintCost(uint256 quantity) public view returns (uint256) {
}
function verifyFreemintSignature(
bool isWhitelist,
bool isHolder,
bytes calldata signature
) internal view returns (bool) {
require(<FILL_ME>)
address recoveredAddress = keccak256(abi.encodePacked(msg.sender, isWhitelist, isHolder)).toEthSignedMessageHash().recover(signature);
return (recoveredAddress != address(0) && recoveredAddress == signer);
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A) onlyAllowedOperator(from) {
}
/**
* @dev implements operator-filter-registry blocklist filtering because https://opensea.io/blog/announcements/on-creator-fees/
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A) onlyAllowedOperator(from) {
}
/**
* @dev implements operator-filter-registry blocklist filtering because https://opensea.io/blog/announcements/on-creator-fees/
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override(ERC721A) onlyAllowedOperator(from) {
}
function setPrice(uint256 _presalePrice, uint256 _publicPrice) external onlyOwner {
}
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
function setBaseURI(string calldata _baseTokenURI) external onlyOwner {
}
function setPresale(bool _presaleIsActive) external onlyOwner {
}
function setSale(bool _saleIsActive) external onlyOwner {
}
function setCollectionSize(uint256 _collectionSize) external onlyOwner {
}
function setSigner(address _signer) external onlyOwner {
}
function setReveal(bool _reveal) external onlyOwner {
}
// view function
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
}
| isWhitelist||isHolder,"must be whitelist or holder" | 165,086 | isWhitelist||isHolder |
"There are no tokens left." | /*
., _
/ `
((|)))))
((/ a a
))) >)
((((._e((
,--/ (-.
/ \ <\/>/|
/ /) )|
/ / ) / |
| / ( /
| / ;/
||( |
/ )|/| \
|/'/\ \_____\
\ | \
\ |\ \
| | ) )
) )/ /
/ / /
/ | /
/ | /
/ ||
/ ||
'-,_ |_\
( '"'-`
\(\_\
_ _ _ _ _
| | ( ) | | (_) | |
__ _| |__ ___ |/ ___ ___ _ _| |_ ___ _ __| | ___
\ \ /\ / / '_ \ / _ \ / __| / _ \| | | | __/ __| |/ _` |/ _ \
\ V V /| | | | (_) | \__ \ | (_) | |_| | |_\__ \ | (_| | __/
\_/\_/ |_| |_|\___/ |___/ \___/ \__,_|\__|___/_|\__,_|\___|
*/
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "closedsea/src/OperatorFilterer.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract WhosOutside is ERC721AQueryable, ERC721ABurnable, OperatorFilterer, ReentrancyGuard, Ownable, ERC2981 {
// Variables
// ---------------------------------------------------------------
uint256 public immutable collectionSize;
uint256 public immutable maxPerWallet;
bool public operatorFilteringEnabled;
uint256 public numFreeMint = 0;
bytes32 public freeMintMerkleRoot;
bytes32 public allowlistMerkleRoot;
bool public isFreeMintActive = false;
bool public isAllowlistMintActive = false;
bool public isMintActive = false;
uint256 private allowlistMintPrice = 0.05 ether;
uint256 private mintPrice = 0.06 ether;
uint256 private reservedFreeMint;
address private devAddress = 0x111f394Bd7842d1F9B2D1Dcc9fbC6c53B581801d;
string private _baseTokenURI;
// Helper functions
// ---------------------------------------------------------------
/**
* @dev This function packs two uint32 values into a single uint64 value.
* @param a: first uint32
* @param b: second uint32
*/
function pack(uint32 a, uint32 b) internal pure returns (uint64) {
}
/**
* @dev This function unpacks a uint64 value into two uint32 values.
* @param a: uint64 value
*/
function unpack(uint64 a) internal pure returns (uint32, uint32) {
}
// Modifiers
// ---------------------------------------------------------------
modifier callerIsUser() {
}
modifier freeMintActive() {
}
modifier allowlistMintActive() {
}
modifier mintActive() {
}
modifier isValidMerkleProof(bytes32[] calldata merkleProof, bytes32 root) {
}
modifier freeMintLeft(uint256 quantity) {
require(<FILL_ME>)
_;
}
modifier mintLeft(uint256 quantity) {
}
modifier supplyLeft(uint256 quantity) {
}
modifier mintNotZero(uint256 quantity){
}
modifier hasNotClaimedFreeMint() {
}
modifier hasNotClaimedAllowlistMint() {
}
modifier lessThanMaxPerWallet(uint256 quantity) {
}
modifier isCorrectPayment(uint256 price, uint256 quantity) {
}
// Constructor
// ---------------------------------------------------------------
constructor(
uint256 collectionSize_,
uint256 maxPerWallet_,
uint256 reservedFreeMint_
) ERC721A("WhosOutside", "OUTSIDE") {
}
// Public minting functions
// ---------------------------------------------------------------
// Free mint from allowlist
function freeMint(bytes32[] calldata merkleProof)
external
nonReentrant
callerIsUser
freeMintActive
isValidMerkleProof(merkleProof, freeMintMerkleRoot)
hasNotClaimedFreeMint
freeMintLeft(1)
{
}
// Allowlist mint
function allowlistMint(bytes32[] calldata merkleProof)
external
payable
nonReentrant
callerIsUser
allowlistMintActive
mintLeft(1)
hasNotClaimedAllowlistMint
isCorrectPayment(allowlistMintPrice, 1)
isValidMerkleProof(merkleProof, allowlistMerkleRoot)
{
}
// Public mint
function mint(uint256 quantity)
external
payable
nonReentrant
callerIsUser
mintActive
lessThanMaxPerWallet(quantity)
isCorrectPayment(mintPrice, quantity)
mintLeft(quantity)
mintNotZero(quantity)
{
}
// Public read-only functions
// ---------------------------------------------------------------
function numberMinted(address owner) public view returns (uint256) {
}
function getAllowlistMintPrice() public view returns (uint256) {
}
function getMintPrice() public view returns (uint256) {
}
function getFreeMintCount(address owner) public view returns (uint32) {
}
function getAllowlistMintCount(address owner) public view returns (uint32) {
}
function getFreeMintUserVerifed(bytes32[] calldata merkleProof, address user) public view returns(bool) {
}
function getAllowlistUserVerifed(bytes32[] calldata merkleProof, address user) public view returns(bool) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override (IERC721A, ERC721A)
returns (string memory)
{
}
// Internal read-only functions
// ---------------------------------------------------------------
function _baseURI() internal view virtual override returns (string memory) {
}
function _mintLeft(uint256 quantity) internal view virtual returns (bool) {
}
// Owner only administration functions
// ---------------------------------------------------------------
function setFreeMintActive(bool _isFreeMintActive) external onlyOwner {
}
function setAllowlistMintActive(bool _isAllowlistMintActive) external onlyOwner {
}
function setMintActive(bool _isMintActive) external onlyOwner {
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setAllowlistMintPrice(uint256 _allowlistMintPrice) external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setFreeMintMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function setAllowlistMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function setDefaultRoyalty(address _devAddress, uint96 feeNumerator) external onlyOwner {
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function withdrawTokens(IERC20 token) external onlyOwner nonReentrant {
}
function ownerMint(uint256 quantity) external onlyOwner
supplyLeft(quantity){
}
// ClosedSea functions
// ---------------------------------------------------------------
function setApprovalForAll(address operator, bool approved)
public
override (IERC721A, ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override (IERC721A, ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override (IERC721A, ERC721A)
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override (IERC721A, ERC721A)
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override (IERC721A, ERC721A)
onlyAllowedOperator(from)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override (IERC721A, ERC721A, ERC2981)
returns (bool)
{
}
function _operatorFilteringEnabled() internal view override returns (bool) {
}
function _isPriorityOperator(address operator) internal pure override returns (bool) {
}
}
| totalSupply()+quantity<=collectionSize&&numFreeMint+quantity<=reservedFreeMint,"There are no tokens left." | 165,124 | totalSupply()+quantity<=collectionSize&&numFreeMint+quantity<=reservedFreeMint |
"There are no tokens left." | /*
., _
/ `
((|)))))
((/ a a
))) >)
((((._e((
,--/ (-.
/ \ <\/>/|
/ /) )|
/ / ) / |
| / ( /
| / ;/
||( |
/ )|/| \
|/'/\ \_____\
\ | \
\ |\ \
| | ) )
) )/ /
/ / /
/ | /
/ | /
/ ||
/ ||
'-,_ |_\
( '"'-`
\(\_\
_ _ _ _ _
| | ( ) | | (_) | |
__ _| |__ ___ |/ ___ ___ _ _| |_ ___ _ __| | ___
\ \ /\ / / '_ \ / _ \ / __| / _ \| | | | __/ __| |/ _` |/ _ \
\ V V /| | | | (_) | \__ \ | (_) | |_| | |_\__ \ | (_| | __/
\_/\_/ |_| |_|\___/ |___/ \___/ \__,_|\__|___/_|\__,_|\___|
*/
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "closedsea/src/OperatorFilterer.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract WhosOutside is ERC721AQueryable, ERC721ABurnable, OperatorFilterer, ReentrancyGuard, Ownable, ERC2981 {
// Variables
// ---------------------------------------------------------------
uint256 public immutable collectionSize;
uint256 public immutable maxPerWallet;
bool public operatorFilteringEnabled;
uint256 public numFreeMint = 0;
bytes32 public freeMintMerkleRoot;
bytes32 public allowlistMerkleRoot;
bool public isFreeMintActive = false;
bool public isAllowlistMintActive = false;
bool public isMintActive = false;
uint256 private allowlistMintPrice = 0.05 ether;
uint256 private mintPrice = 0.06 ether;
uint256 private reservedFreeMint;
address private devAddress = 0x111f394Bd7842d1F9B2D1Dcc9fbC6c53B581801d;
string private _baseTokenURI;
// Helper functions
// ---------------------------------------------------------------
/**
* @dev This function packs two uint32 values into a single uint64 value.
* @param a: first uint32
* @param b: second uint32
*/
function pack(uint32 a, uint32 b) internal pure returns (uint64) {
}
/**
* @dev This function unpacks a uint64 value into two uint32 values.
* @param a: uint64 value
*/
function unpack(uint64 a) internal pure returns (uint32, uint32) {
}
// Modifiers
// ---------------------------------------------------------------
modifier callerIsUser() {
}
modifier freeMintActive() {
}
modifier allowlistMintActive() {
}
modifier mintActive() {
}
modifier isValidMerkleProof(bytes32[] calldata merkleProof, bytes32 root) {
}
modifier freeMintLeft(uint256 quantity) {
}
modifier mintLeft(uint256 quantity) {
require(<FILL_ME>)
_;
}
modifier supplyLeft(uint256 quantity) {
}
modifier mintNotZero(uint256 quantity){
}
modifier hasNotClaimedFreeMint() {
}
modifier hasNotClaimedAllowlistMint() {
}
modifier lessThanMaxPerWallet(uint256 quantity) {
}
modifier isCorrectPayment(uint256 price, uint256 quantity) {
}
// Constructor
// ---------------------------------------------------------------
constructor(
uint256 collectionSize_,
uint256 maxPerWallet_,
uint256 reservedFreeMint_
) ERC721A("WhosOutside", "OUTSIDE") {
}
// Public minting functions
// ---------------------------------------------------------------
// Free mint from allowlist
function freeMint(bytes32[] calldata merkleProof)
external
nonReentrant
callerIsUser
freeMintActive
isValidMerkleProof(merkleProof, freeMintMerkleRoot)
hasNotClaimedFreeMint
freeMintLeft(1)
{
}
// Allowlist mint
function allowlistMint(bytes32[] calldata merkleProof)
external
payable
nonReentrant
callerIsUser
allowlistMintActive
mintLeft(1)
hasNotClaimedAllowlistMint
isCorrectPayment(allowlistMintPrice, 1)
isValidMerkleProof(merkleProof, allowlistMerkleRoot)
{
}
// Public mint
function mint(uint256 quantity)
external
payable
nonReentrant
callerIsUser
mintActive
lessThanMaxPerWallet(quantity)
isCorrectPayment(mintPrice, quantity)
mintLeft(quantity)
mintNotZero(quantity)
{
}
// Public read-only functions
// ---------------------------------------------------------------
function numberMinted(address owner) public view returns (uint256) {
}
function getAllowlistMintPrice() public view returns (uint256) {
}
function getMintPrice() public view returns (uint256) {
}
function getFreeMintCount(address owner) public view returns (uint32) {
}
function getAllowlistMintCount(address owner) public view returns (uint32) {
}
function getFreeMintUserVerifed(bytes32[] calldata merkleProof, address user) public view returns(bool) {
}
function getAllowlistUserVerifed(bytes32[] calldata merkleProof, address user) public view returns(bool) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override (IERC721A, ERC721A)
returns (string memory)
{
}
// Internal read-only functions
// ---------------------------------------------------------------
function _baseURI() internal view virtual override returns (string memory) {
}
function _mintLeft(uint256 quantity) internal view virtual returns (bool) {
}
// Owner only administration functions
// ---------------------------------------------------------------
function setFreeMintActive(bool _isFreeMintActive) external onlyOwner {
}
function setAllowlistMintActive(bool _isAllowlistMintActive) external onlyOwner {
}
function setMintActive(bool _isMintActive) external onlyOwner {
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setAllowlistMintPrice(uint256 _allowlistMintPrice) external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setFreeMintMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function setAllowlistMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function setDefaultRoyalty(address _devAddress, uint96 feeNumerator) external onlyOwner {
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function withdrawTokens(IERC20 token) external onlyOwner nonReentrant {
}
function ownerMint(uint256 quantity) external onlyOwner
supplyLeft(quantity){
}
// ClosedSea functions
// ---------------------------------------------------------------
function setApprovalForAll(address operator, bool approved)
public
override (IERC721A, ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override (IERC721A, ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override (IERC721A, ERC721A)
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override (IERC721A, ERC721A)
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override (IERC721A, ERC721A)
onlyAllowedOperator(from)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override (IERC721A, ERC721A, ERC2981)
returns (bool)
{
}
function _operatorFilteringEnabled() internal view override returns (bool) {
}
function _isPriorityOperator(address operator) internal pure override returns (bool) {
}
}
| _mintLeft(quantity),"There are no tokens left." | 165,124 | _mintLeft(quantity) |
"Incorrect amount of ETH sent." | /*
., _
/ `
((|)))))
((/ a a
))) >)
((((._e((
,--/ (-.
/ \ <\/>/|
/ /) )|
/ / ) / |
| / ( /
| / ;/
||( |
/ )|/| \
|/'/\ \_____\
\ | \
\ |\ \
| | ) )
) )/ /
/ / /
/ | /
/ | /
/ ||
/ ||
'-,_ |_\
( '"'-`
\(\_\
_ _ _ _ _
| | ( ) | | (_) | |
__ _| |__ ___ |/ ___ ___ _ _| |_ ___ _ __| | ___
\ \ /\ / / '_ \ / _ \ / __| / _ \| | | | __/ __| |/ _` |/ _ \
\ V V /| | | | (_) | \__ \ | (_) | |_| | |_\__ \ | (_| | __/
\_/\_/ |_| |_|\___/ |___/ \___/ \__,_|\__|___/_|\__,_|\___|
*/
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "closedsea/src/OperatorFilterer.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract WhosOutside is ERC721AQueryable, ERC721ABurnable, OperatorFilterer, ReentrancyGuard, Ownable, ERC2981 {
// Variables
// ---------------------------------------------------------------
uint256 public immutable collectionSize;
uint256 public immutable maxPerWallet;
bool public operatorFilteringEnabled;
uint256 public numFreeMint = 0;
bytes32 public freeMintMerkleRoot;
bytes32 public allowlistMerkleRoot;
bool public isFreeMintActive = false;
bool public isAllowlistMintActive = false;
bool public isMintActive = false;
uint256 private allowlistMintPrice = 0.05 ether;
uint256 private mintPrice = 0.06 ether;
uint256 private reservedFreeMint;
address private devAddress = 0x111f394Bd7842d1F9B2D1Dcc9fbC6c53B581801d;
string private _baseTokenURI;
// Helper functions
// ---------------------------------------------------------------
/**
* @dev This function packs two uint32 values into a single uint64 value.
* @param a: first uint32
* @param b: second uint32
*/
function pack(uint32 a, uint32 b) internal pure returns (uint64) {
}
/**
* @dev This function unpacks a uint64 value into two uint32 values.
* @param a: uint64 value
*/
function unpack(uint64 a) internal pure returns (uint32, uint32) {
}
// Modifiers
// ---------------------------------------------------------------
modifier callerIsUser() {
}
modifier freeMintActive() {
}
modifier allowlistMintActive() {
}
modifier mintActive() {
}
modifier isValidMerkleProof(bytes32[] calldata merkleProof, bytes32 root) {
}
modifier freeMintLeft(uint256 quantity) {
}
modifier mintLeft(uint256 quantity) {
}
modifier supplyLeft(uint256 quantity) {
}
modifier mintNotZero(uint256 quantity){
}
modifier hasNotClaimedFreeMint() {
}
modifier hasNotClaimedAllowlistMint() {
}
modifier lessThanMaxPerWallet(uint256 quantity) {
}
modifier isCorrectPayment(uint256 price, uint256 quantity) {
require(<FILL_ME>)
_;
}
// Constructor
// ---------------------------------------------------------------
constructor(
uint256 collectionSize_,
uint256 maxPerWallet_,
uint256 reservedFreeMint_
) ERC721A("WhosOutside", "OUTSIDE") {
}
// Public minting functions
// ---------------------------------------------------------------
// Free mint from allowlist
function freeMint(bytes32[] calldata merkleProof)
external
nonReentrant
callerIsUser
freeMintActive
isValidMerkleProof(merkleProof, freeMintMerkleRoot)
hasNotClaimedFreeMint
freeMintLeft(1)
{
}
// Allowlist mint
function allowlistMint(bytes32[] calldata merkleProof)
external
payable
nonReentrant
callerIsUser
allowlistMintActive
mintLeft(1)
hasNotClaimedAllowlistMint
isCorrectPayment(allowlistMintPrice, 1)
isValidMerkleProof(merkleProof, allowlistMerkleRoot)
{
}
// Public mint
function mint(uint256 quantity)
external
payable
nonReentrant
callerIsUser
mintActive
lessThanMaxPerWallet(quantity)
isCorrectPayment(mintPrice, quantity)
mintLeft(quantity)
mintNotZero(quantity)
{
}
// Public read-only functions
// ---------------------------------------------------------------
function numberMinted(address owner) public view returns (uint256) {
}
function getAllowlistMintPrice() public view returns (uint256) {
}
function getMintPrice() public view returns (uint256) {
}
function getFreeMintCount(address owner) public view returns (uint32) {
}
function getAllowlistMintCount(address owner) public view returns (uint32) {
}
function getFreeMintUserVerifed(bytes32[] calldata merkleProof, address user) public view returns(bool) {
}
function getAllowlistUserVerifed(bytes32[] calldata merkleProof, address user) public view returns(bool) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override (IERC721A, ERC721A)
returns (string memory)
{
}
// Internal read-only functions
// ---------------------------------------------------------------
function _baseURI() internal view virtual override returns (string memory) {
}
function _mintLeft(uint256 quantity) internal view virtual returns (bool) {
}
// Owner only administration functions
// ---------------------------------------------------------------
function setFreeMintActive(bool _isFreeMintActive) external onlyOwner {
}
function setAllowlistMintActive(bool _isAllowlistMintActive) external onlyOwner {
}
function setMintActive(bool _isMintActive) external onlyOwner {
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setAllowlistMintPrice(uint256 _allowlistMintPrice) external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setFreeMintMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function setAllowlistMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function setDefaultRoyalty(address _devAddress, uint96 feeNumerator) external onlyOwner {
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function withdrawTokens(IERC20 token) external onlyOwner nonReentrant {
}
function ownerMint(uint256 quantity) external onlyOwner
supplyLeft(quantity){
}
// ClosedSea functions
// ---------------------------------------------------------------
function setApprovalForAll(address operator, bool approved)
public
override (IERC721A, ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override (IERC721A, ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override (IERC721A, ERC721A)
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override (IERC721A, ERC721A)
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override (IERC721A, ERC721A)
onlyAllowedOperator(from)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override (IERC721A, ERC721A, ERC2981)
returns (bool)
{
}
function _operatorFilteringEnabled() internal view override returns (bool) {
}
function _isPriorityOperator(address operator) internal pure override returns (bool) {
}
}
| price*quantity==msg.value,"Incorrect amount of ETH sent." | 165,124 | price*quantity==msg.value |
"!earmark reward" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import { IERC20 } from "@openzeppelin/contracts-0.8/token/ERC20/IERC20.sol";
import { SafeERC20 } from "@openzeppelin/contracts-0.8/token/ERC20/utils/SafeERC20.sol";
import { IBooster } from "../interfaces/IBooster.sol";
import { IRewardStaking } from "../interfaces/IRewardStaking.sol";
import { IFeeDistributor } from "../interfaces/bunni/IFeeDistributor.sol";
/**
* @title BoosterHelper
* @author AuraFinance
* @notice Invokes booster.earmarkRewards for multiple pools and booster.earmarkFees.
* @dev Allows anyone to call `earmarkRewards` & `earmarkFees` via the booster.
*/
contract BoosterHelper {
using SafeERC20 for IERC20;
IBooster public immutable booster;
address public immutable crv;
address public immutable voterProxy = 0x37aeB332D6E57112f1BFE36923a7ee670Ee9278b;
mapping(address => uint256) public lastTokenTimes;
IFeeDistributor public feeDistro;
/**
* @param _booster Booster.sol, e.g. 0x631e58246A88c3957763e1469cb52f93BC1dDCF2
* @param _crv oLIT e.g. 0x627fee87d0D9D2c55098A06ac805Db8F98B158Aa
*/
constructor(address _booster, address _crv) {
}
function earmarkRewards(uint256[] memory _pids) external returns (uint256) {
uint256 len = _pids.length;
require(len > 0, "!pids");
for (uint256 i = 0; i < len; i++) {
require(<FILL_ME>)
}
// Return all incentives to the sender
uint256 crvBal = IERC20(crv).balanceOf(address(this));
IERC20(crv).safeTransfer(msg.sender, crvBal);
return crvBal;
}
/**
* @notice Invoke processIdleRewards for each pool id.
* @param _pids Array of pool ids
*/
function processIdleRewards(uint256[] memory _pids) external {
}
/**
* @dev Claims fees from fee claimer, and pings the booster to distribute.
* @param _tokens Token address to claim fees for.
* @param _checkpoints Number of checkpoints required previous to claim fees.
*/
function claimFees(IERC20[] memory _tokens, uint256 _checkpoints) external {
}
}
| booster.earmarkRewards(_pids[i]),"!earmark reward" | 165,189 | booster.earmarkRewards(_pids[i]) |
"nothing claimed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import { IERC20 } from "@openzeppelin/contracts-0.8/token/ERC20/IERC20.sol";
import { SafeERC20 } from "@openzeppelin/contracts-0.8/token/ERC20/utils/SafeERC20.sol";
import { IBooster } from "../interfaces/IBooster.sol";
import { IRewardStaking } from "../interfaces/IRewardStaking.sol";
import { IFeeDistributor } from "../interfaces/bunni/IFeeDistributor.sol";
/**
* @title BoosterHelper
* @author AuraFinance
* @notice Invokes booster.earmarkRewards for multiple pools and booster.earmarkFees.
* @dev Allows anyone to call `earmarkRewards` & `earmarkFees` via the booster.
*/
contract BoosterHelper {
using SafeERC20 for IERC20;
IBooster public immutable booster;
address public immutable crv;
address public immutable voterProxy = 0x37aeB332D6E57112f1BFE36923a7ee670Ee9278b;
mapping(address => uint256) public lastTokenTimes;
IFeeDistributor public feeDistro;
/**
* @param _booster Booster.sol, e.g. 0x631e58246A88c3957763e1469cb52f93BC1dDCF2
* @param _crv oLIT e.g. 0x627fee87d0D9D2c55098A06ac805Db8F98B158Aa
*/
constructor(address _booster, address _crv) {
}
function earmarkRewards(uint256[] memory _pids) external returns (uint256) {
}
/**
* @notice Invoke processIdleRewards for each pool id.
* @param _pids Array of pool ids
*/
function processIdleRewards(uint256[] memory _pids) external {
}
/**
* @dev Claims fees from fee claimer, and pings the booster to distribute.
* @param _tokens Token address to claim fees for.
* @param _checkpoints Number of checkpoints required previous to claim fees.
*/
function claimFees(IERC20[] memory _tokens, uint256 _checkpoints) external {
uint256 len = _tokens.length;
require(len > 0, "!_tokens");
// Checkpoint user n times before claiming fees
for (uint256 i = 0; i < _checkpoints; i++) {
feeDistro.checkpointUser(voterProxy);
}
for (uint256 i = 0; i < len; i++) {
// Validate if the token should be claimed
IERC20 token = _tokens[i];
uint256 tokenTime = feeDistro.getTokenTimeCursor(token);
require(tokenTime > lastTokenTimes[address(token)], "not time yet");
IBooster.FeeDistro memory feeDist = booster.feeTokens(address(token));
uint256 balanceBefore = token.balanceOf(feeDist.rewards);
booster.earmarkFees(address(token));
uint256 balanceAfter = token.balanceOf(feeDist.rewards);
require(<FILL_ME>)
lastTokenTimes[address(token)] = tokenTime;
}
}
}
| (balanceAfter-balanceBefore)>0,"nothing claimed" | 165,189 | (balanceAfter-balanceBefore)>0 |
"PTNReserve::setPool: ALREADY_ALLOWED" | pragma solidity 0.8.4;
contract PTNReserve is Ownable, Initializable {
using SafeERC20 for IERC20;
IERC20 public ptn;
address public rewarder;
mapping(address => bool) public allowedPools;
/* ============ CONSTRUCTORS ========== */
constructor(address initialOwner) {
}
function initialize(address _ptn) external initializer {
}
/* ============ MUTATIVE ========== */
function setRewarder(address _rewarder) external returns (bool) {
}
function setPool(address _pool) external onlyOwner returns (bool) {
require(<FILL_ME>)
allowedPools[_pool] = true;
return true;
}
function removePool(address _pool) external onlyOwner returns (bool) {
}
function transfer(address _to, uint256 _amount) external {
}
}
| allowedPools[_pool]==false,"PTNReserve::setPool: ALREADY_ALLOWED" | 165,196 | allowedPools[_pool]==false |
"PTNReserve::removePool: NOT_ALLOWED" | pragma solidity 0.8.4;
contract PTNReserve is Ownable, Initializable {
using SafeERC20 for IERC20;
IERC20 public ptn;
address public rewarder;
mapping(address => bool) public allowedPools;
/* ============ CONSTRUCTORS ========== */
constructor(address initialOwner) {
}
function initialize(address _ptn) external initializer {
}
/* ============ MUTATIVE ========== */
function setRewarder(address _rewarder) external returns (bool) {
}
function setPool(address _pool) external onlyOwner returns (bool) {
}
function removePool(address _pool) external onlyOwner returns (bool) {
require(<FILL_ME>)
allowedPools[_pool] = false;
return true;
}
function transfer(address _to, uint256 _amount) external {
}
}
| allowedPools[_pool]==true,"PTNReserve::removePool: NOT_ALLOWED" | 165,196 | allowedPools[_pool]==true |
"Incorrect ETH value sent" | // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Burnable.sol)
pragma solidity ^0.8.0;
/**
* @title ERC721 Burnable Token
* @dev ERC721 Token that can be burned (destroyed).
*/
abstract contract ERC721Burnable is Context, ERC721A {
/**
* @dev Burns `tokenId`. See {ERC721-_burn}.
*
* Requirements:
*
* - The caller must own `tokenId` or be an approved operator.
*/
function burn(uint256 tokenId) public virtual {
}
}
pragma solidity ^0.8.13;
contract RaveRush is ERC721A, Ownable, OperatorFilterer, ERC721Burnable {
using Strings for uint256;
string private uriPrefix = "ipfs://bafybeifgjvseikwzvfn4eixlc5hr6kzrrlskkroomhowzplu34uf7wd2ba/";
string private uriSuffix = ".json";
string private hiddenURL;
uint256 public cost = 0.002 ether;
uint16 public maxSupply = 1000;
uint8 public maxMintAmountPerTx = 5;
uint8 public maxMintAmountPerWallet = 10;
uint8 public maxFreeMintAmountPerWallet = 1;
uint256 public freeNFTAlreadyMinted = 0;
uint256 public NUM_FREE_MINTS = 1000;
bool public operatorFilteringEnabled;
bool public paused = true;
bool public reveal = true;
constructor(
string memory _tokenName,
string memory _tokenSymbol
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier callerIsUser() {
}
function Mint(uint256 _mintAmount)
external
payable
callerIsUser
{
require(!paused, "The contract is paused!");
require(totalSupply() + _mintAmount < maxSupply + 1, "No more");
require (balanceOf(msg.sender) + _mintAmount <= maxMintAmountPerWallet, "max NFT per address exceeded");
if(freeNFTAlreadyMinted + _mintAmount > NUM_FREE_MINTS){
require(<FILL_ME>)
}
else {
if (balanceOf(msg.sender) + _mintAmount > maxFreeMintAmountPerWallet) {
require(
(cost * _mintAmount) <= msg.value,
"Incorrect ETH value sent"
);
require(
_mintAmount <= maxMintAmountPerTx,
"Max mints per transaction exceeded"
);
} else {
require(
_mintAmount <= maxFreeMintAmountPerWallet,
"Max mints per transaction exceeded"
);
freeNFTAlreadyMinted += _mintAmount;
}
}
_safeMint(msg.sender, _mintAmount);
}
function Reserve(uint16 _mintAmount, address _receiver) external onlyOwner {
}
function Airdrop(uint8 _amountPerAddress, address[] calldata addresses) external onlyOwner {
}
function setMaxSupply(uint16 _maxSupply) external onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setFreeMaxLimitPerAddress(uint8 _limit) external onlyOwner{
}
function seturiSuffix(string memory _uriSuffix) external onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) external onlyOwner {
}
function setHiddenUri(string memory _uriPrefix) external onlyOwner {
}
function setNumFreeMints(uint256 _numfreemints)
external
onlyOwner
{
}
function setPaused() external onlyOwner {
}
function setCost(uint _cost) external onlyOwner{
}
function setRevealed() external onlyOwner{
}
function setMaxMintAmountPerTx(uint8 _maxtx) external onlyOwner{
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function _operatorFilteringEnabled() internal view override returns (bool) {
}
}
| (cost*_mintAmount)<=msg.value,"Incorrect ETH value sent" | 165,218 | (cost*_mintAmount)<=msg.value |
"Excedes max supply." | // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Burnable.sol)
pragma solidity ^0.8.0;
/**
* @title ERC721 Burnable Token
* @dev ERC721 Token that can be burned (destroyed).
*/
abstract contract ERC721Burnable is Context, ERC721A {
/**
* @dev Burns `tokenId`. See {ERC721-_burn}.
*
* Requirements:
*
* - The caller must own `tokenId` or be an approved operator.
*/
function burn(uint256 tokenId) public virtual {
}
}
pragma solidity ^0.8.13;
contract RaveRush is ERC721A, Ownable, OperatorFilterer, ERC721Burnable {
using Strings for uint256;
string private uriPrefix = "ipfs://bafybeifgjvseikwzvfn4eixlc5hr6kzrrlskkroomhowzplu34uf7wd2ba/";
string private uriSuffix = ".json";
string private hiddenURL;
uint256 public cost = 0.002 ether;
uint16 public maxSupply = 1000;
uint8 public maxMintAmountPerTx = 5;
uint8 public maxMintAmountPerWallet = 10;
uint8 public maxFreeMintAmountPerWallet = 1;
uint256 public freeNFTAlreadyMinted = 0;
uint256 public NUM_FREE_MINTS = 1000;
bool public operatorFilteringEnabled;
bool public paused = true;
bool public reveal = true;
constructor(
string memory _tokenName,
string memory _tokenSymbol
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier callerIsUser() {
}
function Mint(uint256 _mintAmount)
external
payable
callerIsUser
{
}
function Reserve(uint16 _mintAmount, address _receiver) external onlyOwner {
uint16 totalSupply = uint16(totalSupply());
require(<FILL_ME>)
_safeMint(_receiver , _mintAmount);
delete _mintAmount;
delete _receiver;
delete totalSupply;
}
function Airdrop(uint8 _amountPerAddress, address[] calldata addresses) external onlyOwner {
}
function setMaxSupply(uint16 _maxSupply) external onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setFreeMaxLimitPerAddress(uint8 _limit) external onlyOwner{
}
function seturiSuffix(string memory _uriSuffix) external onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) external onlyOwner {
}
function setHiddenUri(string memory _uriPrefix) external onlyOwner {
}
function setNumFreeMints(uint256 _numfreemints)
external
onlyOwner
{
}
function setPaused() external onlyOwner {
}
function setCost(uint _cost) external onlyOwner{
}
function setRevealed() external onlyOwner{
}
function setMaxMintAmountPerTx(uint8 _maxtx) external onlyOwner{
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function _operatorFilteringEnabled() internal view override returns (bool) {
}
}
| totalSupply+_mintAmount<=maxSupply,"Excedes max supply." | 165,218 | totalSupply+_mintAmount<=maxSupply |
"Excedes max supply." | // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Burnable.sol)
pragma solidity ^0.8.0;
/**
* @title ERC721 Burnable Token
* @dev ERC721 Token that can be burned (destroyed).
*/
abstract contract ERC721Burnable is Context, ERC721A {
/**
* @dev Burns `tokenId`. See {ERC721-_burn}.
*
* Requirements:
*
* - The caller must own `tokenId` or be an approved operator.
*/
function burn(uint256 tokenId) public virtual {
}
}
pragma solidity ^0.8.13;
contract RaveRush is ERC721A, Ownable, OperatorFilterer, ERC721Burnable {
using Strings for uint256;
string private uriPrefix = "ipfs://bafybeifgjvseikwzvfn4eixlc5hr6kzrrlskkroomhowzplu34uf7wd2ba/";
string private uriSuffix = ".json";
string private hiddenURL;
uint256 public cost = 0.002 ether;
uint16 public maxSupply = 1000;
uint8 public maxMintAmountPerTx = 5;
uint8 public maxMintAmountPerWallet = 10;
uint8 public maxFreeMintAmountPerWallet = 1;
uint256 public freeNFTAlreadyMinted = 0;
uint256 public NUM_FREE_MINTS = 1000;
bool public operatorFilteringEnabled;
bool public paused = true;
bool public reveal = true;
constructor(
string memory _tokenName,
string memory _tokenSymbol
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier callerIsUser() {
}
function Mint(uint256 _mintAmount)
external
payable
callerIsUser
{
}
function Reserve(uint16 _mintAmount, address _receiver) external onlyOwner {
}
function Airdrop(uint8 _amountPerAddress, address[] calldata addresses) external onlyOwner {
uint16 totalSupply = uint16(totalSupply());
uint totalAmount = _amountPerAddress * addresses.length;
require(<FILL_ME>)
for (uint256 i = 0; i < addresses.length; i++) {
_safeMint(addresses[i], _amountPerAddress);
}
delete _amountPerAddress;
delete totalSupply;
}
function setMaxSupply(uint16 _maxSupply) external onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setFreeMaxLimitPerAddress(uint8 _limit) external onlyOwner{
}
function seturiSuffix(string memory _uriSuffix) external onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) external onlyOwner {
}
function setHiddenUri(string memory _uriPrefix) external onlyOwner {
}
function setNumFreeMints(uint256 _numfreemints)
external
onlyOwner
{
}
function setPaused() external onlyOwner {
}
function setCost(uint _cost) external onlyOwner{
}
function setRevealed() external onlyOwner{
}
function setMaxMintAmountPerTx(uint8 _maxtx) external onlyOwner{
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function _operatorFilteringEnabled() internal view override returns (bool) {
}
}
| totalSupply+totalAmount<=maxSupply,"Excedes max supply." | 165,218 | totalSupply+totalAmount<=maxSupply |
"Distribution have to be equal to 100%" | /**
telegram - https://t.me/mouseworm
twitter - https://twitter.com/mousewormerc
website - https://mouseworm.com
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;
pragma experimental ABIEncoderV2;
abstract contract Ownable {
address private _owner;
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
library SafeERC20 {
function safeTransfer(address token, address to, uint256 value) internal {
}
}
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external;
function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
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 MOUSEWORM is Ownable {
using SafeMath for uint256;
string private constant _name = unicode"Mouseworm";
string private constant _symbol = unicode"WORMIE";
uint256 private constant _totalSupply = 1_000_000_000 * 1e18;
uint256 public maxTransactionAmount = 30_000_000 * 1e18;
uint256 public maxWallet = 50_000_000 * 1e18;
uint256 public swapTokensAtAmount = (_totalSupply * 2).div(1000);
//production wallets
address private rewWallet = payable(0x428a3EeD7403D1513C0ADB3c2A148463909cCC2f);
address private treasuryWallet = payable(0x0EE17Bd9Ad0858B0b7d762344FadEE57E64FB6c8);
address private teamWallet = payable(0xBC1A2258C6b1Fc69e227fBc904a81D25184b221B);
uint256 public buyTotalFees = 0;
uint256 public sellTotalFees = 320; //32% to start
//needs to equal 100
uint256 public rewFee = 10;
uint256 public treasuryFee = 10;
uint256 public teamFee = 80;
bool private swapping;
bool public limitsInEffect = true;
bool private launched;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
event SwapAndLiquify(uint256 tokensSwapped, uint256 teamETH, uint256 rewETH, uint256 TreasuryETH);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
IUniswapV2Router02 public constant uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable uniswapV2Pair;
constructor() {
}
receive() external payable {}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) external returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function transfer(address recipient, uint256 amount) external returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private {
}
function removeLimits() external onlyOwner {
}
function setDistributionFees(uint256 _rewFee, uint256 _TreasuryFee, uint256 _teamFee) external onlyOwner {
rewFee = _rewFee;
treasuryFee = _TreasuryFee;
teamFee = _teamFee;
require(<FILL_ME>)
}
function setFees(uint256 _buyTotalFees, uint256 _sellTotalFees) external onlyOwner {
}
function setExcludedFromFees(address account, bool excluded) public onlyOwner {
}
function setExcludedFromMaxTransaction(address account, bool excluded) public onlyOwner {
}
function airdropWallets(address[] memory addresses, uint256[] memory amounts) external onlyOwner {
}
function openTrade() external onlyOwner {
}
function unleashTheWorm() external payable onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function setSwapAtAmount(uint256 newSwapAmount) external onlyOwner {
}
function setMaxTxnAmount(uint256 newMaxTx) external onlyOwner {
}
function setMaxWalletAmount(uint256 newMaxWallet) external onlyOwner {
}
function updaterewWallet(address newAddress) external onlyOwner {
}
function updateTreasuryWallet(address newAddress) external onlyOwner {
}
function updateTeamWallet(address newAddress) external onlyOwner {
}
function excludedFromFee(address account) public view returns (bool) {
}
function withdrawStuckToken(address token, address to) external onlyOwner {
}
function withdrawStuckETH(address addr) external onlyOwner {
}
function swapBack() private {
}
}
| (rewFee+treasuryFee+teamFee)==100,"Distribution have to be equal to 100%" | 165,377 | (rewFee+treasuryFee+teamFee)==100 |
"Presale don't exist" | /**
*Submitted for verification at Etherscan.io on 2023-10-27
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
function _nonReentrantBefore() private {
}
function _nonReentrantAfter() private {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage)
private
pure
{
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface Aggregator {
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract TestPre is ReentrancyGuard, Ownable {
uint256 public overalllRaised;
uint256 public presaleId;
uint256 public USDT_MULTIPLIER;
uint256 public ETH_MULTIPLIER;
address public fundReceiver;
uint256 public uniqueBuyers;
struct PresaleData {
uint256 startTime;
uint256 endTime;
uint256 price;
uint256 nextStagePrice;
uint256 Sold;
uint256 tokensToSell;
uint256 UsdtHardcap;
uint256 amountRaised;
bool Active;
bool isEnableClaim;
}
struct VestingData {
uint256 vestingStartTime;
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
}
struct UserData {
uint256 investedAmount;
uint256 claimAt;
uint256 claimAbleAmount;
uint256 claimedVestingAmount;
uint256 claimedAmount;
uint256 claimCount;
uint256 activePercentAmount;
}
IERC20Metadata public USDTInterface;
IERC20Metadata public USDCInterface;
Aggregator internal aggregatorInterface;
mapping(uint256 => bool) public paused;
mapping(uint256 => PresaleData) public presale;
mapping(uint256 => VestingData) public vesting;
mapping(address => mapping(uint256 => UserData)) public userClaimData;
mapping(address => bool) public isExcludeMinToken;
mapping(address => bool) public isBlackList;
mapping(address => bool) public isExist;
uint256 public MinTokenTobuy;
uint256 public currentSale;
address public SaleToken;
event PresaleCreated(
uint256 indexed _id,
uint256 _totalTokens,
uint256 _startTime,
uint256 _endTime
);
event PresaleUpdated(
bytes32 indexed key,
uint256 prevValue,
uint256 newValue,
uint256 timestamp
);
event TokensBought(
address indexed user,
uint256 indexed id,
address indexed purchaseToken,
uint256 tokensBought,
uint256 amountPaid,
uint256 timestamp
);
event TokensClaimed(
address indexed user,
uint256 indexed id,
uint256 amount,
uint256 timestamp
);
event PresaleTokenAddressUpdated(
address indexed prevValue,
address indexed newValue,
uint256 timestamp
);
event PresalePaused(uint256 indexed id, uint256 timestamp);
event PresaleUnpaused(uint256 indexed id, uint256 timestamp);
constructor(
address _oracle,
address _usdt,
address _usdc,
address _SaleToken,
uint256 _MinTokenTobuy
) {
}
function createPresale(
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _UsdtHardcap
) external onlyOwner {
}
function setPresaleStage(uint256 _id) public onlyOwner {
require(<FILL_ME>)
if (currentSale != 0) {
presale[currentSale].endTime = block.timestamp;
presale[currentSale].Active = false;
}
presale[_id].startTime = block.timestamp;
presale[_id].Active = true;
currentSale = _id;
}
function setPresaleVesting(
uint256[] memory _id,
uint256[] memory vestingStartTime,
uint256[] memory _initialClaimPercent,
uint256[] memory _vestingTime,
uint256[] memory _vestingPercentage
) public onlyOwner {
}
function updatePresaleVesting(
uint256 _id,
uint256 _vestingStartTime,
uint256 _initialClaimPercent,
uint256 _vestingTime,
uint256 _vestingPercentage
) public onlyOwner {
}
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
function enableClaim(uint256 _id, bool _status) public onlyOwner {
}
function updatePresale(
uint256 _id,
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _Hardcap,
bool isclaimAble
) external onlyOwner {
}
function changeFundWallet(address _wallet) external onlyOwner {
}
function changeUSDTToken(address _newAddress) external onlyOwner {
}
function changeUSDCToken(address _newAddress) external onlyOwner {
}
function pausePresale(uint256 _id) external checkPresaleId(_id) onlyOwner {
}
function unPausePresale(uint256 _id)
external
checkPresaleId(_id)
onlyOwner
{
}
function getLatestPrice() public view returns (uint256) {
}
modifier checkPresaleId(uint256 _id) {
}
modifier checkSaleState(uint256 _id, uint256 amount) {
}
function ExcludeAccouctFromMinBuy(address _user, bool _status)
external
onlyOwner
{
}
function buyWithUSDT(uint256 usdAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdAmount))
nonReentrant
returns (bool)
{
}
function changeClaimAddress(address _oldAddress, address _newWallet)
public
onlyOwner
{
}
function blackListUser(address _user, bool _value) public onlyOwner {
}
function buyWithUSDC(uint256 usdcAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdcAmount))
nonReentrant
returns (bool)
{
}
function buyWithEth()
external
payable
checkPresaleId(currentSale)
checkSaleState(currentSale, ethToTokens(currentSale, msg.value))
nonReentrant
returns (bool)
{
}
function ethBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 ethAmount)
{
}
function usdtBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 usdPrice)
{
}
function ethToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function usdtToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function claimableAmount(address user, uint256 _id)
public
view
returns (uint256)
{
}
function claimAmount(uint256 _id) public returns (bool) {
}
function WithdrawTokens(address _token, uint256 amount) external onlyOwner {
}
function WithdrawContractFunds(uint256 amount) external onlyOwner {
}
function ChangeTokenToSell(address _token) public onlyOwner {
}
function EditMinTokenToBuy(uint256 _amount) public onlyOwner {
}
function ChangeOracleAddress(address _oracle) public onlyOwner {
}
function blockStamp() public view returns(uint256) {
}
}
| presale[_id].tokensToSell>0,"Presale don't exist" | 165,432 | presale[_id].tokensToSell>0 |
"Already paused" | /**
*Submitted for verification at Etherscan.io on 2023-10-27
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
function _nonReentrantBefore() private {
}
function _nonReentrantAfter() private {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage)
private
pure
{
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface Aggregator {
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract TestPre is ReentrancyGuard, Ownable {
uint256 public overalllRaised;
uint256 public presaleId;
uint256 public USDT_MULTIPLIER;
uint256 public ETH_MULTIPLIER;
address public fundReceiver;
uint256 public uniqueBuyers;
struct PresaleData {
uint256 startTime;
uint256 endTime;
uint256 price;
uint256 nextStagePrice;
uint256 Sold;
uint256 tokensToSell;
uint256 UsdtHardcap;
uint256 amountRaised;
bool Active;
bool isEnableClaim;
}
struct VestingData {
uint256 vestingStartTime;
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
}
struct UserData {
uint256 investedAmount;
uint256 claimAt;
uint256 claimAbleAmount;
uint256 claimedVestingAmount;
uint256 claimedAmount;
uint256 claimCount;
uint256 activePercentAmount;
}
IERC20Metadata public USDTInterface;
IERC20Metadata public USDCInterface;
Aggregator internal aggregatorInterface;
mapping(uint256 => bool) public paused;
mapping(uint256 => PresaleData) public presale;
mapping(uint256 => VestingData) public vesting;
mapping(address => mapping(uint256 => UserData)) public userClaimData;
mapping(address => bool) public isExcludeMinToken;
mapping(address => bool) public isBlackList;
mapping(address => bool) public isExist;
uint256 public MinTokenTobuy;
uint256 public currentSale;
address public SaleToken;
event PresaleCreated(
uint256 indexed _id,
uint256 _totalTokens,
uint256 _startTime,
uint256 _endTime
);
event PresaleUpdated(
bytes32 indexed key,
uint256 prevValue,
uint256 newValue,
uint256 timestamp
);
event TokensBought(
address indexed user,
uint256 indexed id,
address indexed purchaseToken,
uint256 tokensBought,
uint256 amountPaid,
uint256 timestamp
);
event TokensClaimed(
address indexed user,
uint256 indexed id,
uint256 amount,
uint256 timestamp
);
event PresaleTokenAddressUpdated(
address indexed prevValue,
address indexed newValue,
uint256 timestamp
);
event PresalePaused(uint256 indexed id, uint256 timestamp);
event PresaleUnpaused(uint256 indexed id, uint256 timestamp);
constructor(
address _oracle,
address _usdt,
address _usdc,
address _SaleToken,
uint256 _MinTokenTobuy
) {
}
function createPresale(
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _UsdtHardcap
) external onlyOwner {
}
function setPresaleStage(uint256 _id) public onlyOwner {
}
function setPresaleVesting(
uint256[] memory _id,
uint256[] memory vestingStartTime,
uint256[] memory _initialClaimPercent,
uint256[] memory _vestingTime,
uint256[] memory _vestingPercentage
) public onlyOwner {
}
function updatePresaleVesting(
uint256 _id,
uint256 _vestingStartTime,
uint256 _initialClaimPercent,
uint256 _vestingTime,
uint256 _vestingPercentage
) public onlyOwner {
}
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
function enableClaim(uint256 _id, bool _status) public onlyOwner {
}
function updatePresale(
uint256 _id,
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _Hardcap,
bool isclaimAble
) external onlyOwner {
}
function changeFundWallet(address _wallet) external onlyOwner {
}
function changeUSDTToken(address _newAddress) external onlyOwner {
}
function changeUSDCToken(address _newAddress) external onlyOwner {
}
function pausePresale(uint256 _id) external checkPresaleId(_id) onlyOwner {
require(<FILL_ME>)
paused[_id] = true;
emit PresalePaused(_id, block.timestamp);
}
function unPausePresale(uint256 _id)
external
checkPresaleId(_id)
onlyOwner
{
}
function getLatestPrice() public view returns (uint256) {
}
modifier checkPresaleId(uint256 _id) {
}
modifier checkSaleState(uint256 _id, uint256 amount) {
}
function ExcludeAccouctFromMinBuy(address _user, bool _status)
external
onlyOwner
{
}
function buyWithUSDT(uint256 usdAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdAmount))
nonReentrant
returns (bool)
{
}
function changeClaimAddress(address _oldAddress, address _newWallet)
public
onlyOwner
{
}
function blackListUser(address _user, bool _value) public onlyOwner {
}
function buyWithUSDC(uint256 usdcAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdcAmount))
nonReentrant
returns (bool)
{
}
function buyWithEth()
external
payable
checkPresaleId(currentSale)
checkSaleState(currentSale, ethToTokens(currentSale, msg.value))
nonReentrant
returns (bool)
{
}
function ethBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 ethAmount)
{
}
function usdtBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 usdPrice)
{
}
function ethToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function usdtToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function claimableAmount(address user, uint256 _id)
public
view
returns (uint256)
{
}
function claimAmount(uint256 _id) public returns (bool) {
}
function WithdrawTokens(address _token, uint256 amount) external onlyOwner {
}
function WithdrawContractFunds(uint256 amount) external onlyOwner {
}
function ChangeTokenToSell(address _token) public onlyOwner {
}
function EditMinTokenToBuy(uint256 _amount) public onlyOwner {
}
function ChangeOracleAddress(address _oracle) public onlyOwner {
}
function blockStamp() public view returns(uint256) {
}
}
| !paused[_id],"Already paused" | 165,432 | !paused[_id] |
"Not paused" | /**
*Submitted for verification at Etherscan.io on 2023-10-27
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
function _nonReentrantBefore() private {
}
function _nonReentrantAfter() private {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage)
private
pure
{
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface Aggregator {
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract TestPre is ReentrancyGuard, Ownable {
uint256 public overalllRaised;
uint256 public presaleId;
uint256 public USDT_MULTIPLIER;
uint256 public ETH_MULTIPLIER;
address public fundReceiver;
uint256 public uniqueBuyers;
struct PresaleData {
uint256 startTime;
uint256 endTime;
uint256 price;
uint256 nextStagePrice;
uint256 Sold;
uint256 tokensToSell;
uint256 UsdtHardcap;
uint256 amountRaised;
bool Active;
bool isEnableClaim;
}
struct VestingData {
uint256 vestingStartTime;
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
}
struct UserData {
uint256 investedAmount;
uint256 claimAt;
uint256 claimAbleAmount;
uint256 claimedVestingAmount;
uint256 claimedAmount;
uint256 claimCount;
uint256 activePercentAmount;
}
IERC20Metadata public USDTInterface;
IERC20Metadata public USDCInterface;
Aggregator internal aggregatorInterface;
mapping(uint256 => bool) public paused;
mapping(uint256 => PresaleData) public presale;
mapping(uint256 => VestingData) public vesting;
mapping(address => mapping(uint256 => UserData)) public userClaimData;
mapping(address => bool) public isExcludeMinToken;
mapping(address => bool) public isBlackList;
mapping(address => bool) public isExist;
uint256 public MinTokenTobuy;
uint256 public currentSale;
address public SaleToken;
event PresaleCreated(
uint256 indexed _id,
uint256 _totalTokens,
uint256 _startTime,
uint256 _endTime
);
event PresaleUpdated(
bytes32 indexed key,
uint256 prevValue,
uint256 newValue,
uint256 timestamp
);
event TokensBought(
address indexed user,
uint256 indexed id,
address indexed purchaseToken,
uint256 tokensBought,
uint256 amountPaid,
uint256 timestamp
);
event TokensClaimed(
address indexed user,
uint256 indexed id,
uint256 amount,
uint256 timestamp
);
event PresaleTokenAddressUpdated(
address indexed prevValue,
address indexed newValue,
uint256 timestamp
);
event PresalePaused(uint256 indexed id, uint256 timestamp);
event PresaleUnpaused(uint256 indexed id, uint256 timestamp);
constructor(
address _oracle,
address _usdt,
address _usdc,
address _SaleToken,
uint256 _MinTokenTobuy
) {
}
function createPresale(
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _UsdtHardcap
) external onlyOwner {
}
function setPresaleStage(uint256 _id) public onlyOwner {
}
function setPresaleVesting(
uint256[] memory _id,
uint256[] memory vestingStartTime,
uint256[] memory _initialClaimPercent,
uint256[] memory _vestingTime,
uint256[] memory _vestingPercentage
) public onlyOwner {
}
function updatePresaleVesting(
uint256 _id,
uint256 _vestingStartTime,
uint256 _initialClaimPercent,
uint256 _vestingTime,
uint256 _vestingPercentage
) public onlyOwner {
}
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
function enableClaim(uint256 _id, bool _status) public onlyOwner {
}
function updatePresale(
uint256 _id,
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _Hardcap,
bool isclaimAble
) external onlyOwner {
}
function changeFundWallet(address _wallet) external onlyOwner {
}
function changeUSDTToken(address _newAddress) external onlyOwner {
}
function changeUSDCToken(address _newAddress) external onlyOwner {
}
function pausePresale(uint256 _id) external checkPresaleId(_id) onlyOwner {
}
function unPausePresale(uint256 _id)
external
checkPresaleId(_id)
onlyOwner
{
require(<FILL_ME>)
paused[_id] = false;
emit PresaleUnpaused(_id, block.timestamp);
}
function getLatestPrice() public view returns (uint256) {
}
modifier checkPresaleId(uint256 _id) {
}
modifier checkSaleState(uint256 _id, uint256 amount) {
}
function ExcludeAccouctFromMinBuy(address _user, bool _status)
external
onlyOwner
{
}
function buyWithUSDT(uint256 usdAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdAmount))
nonReentrant
returns (bool)
{
}
function changeClaimAddress(address _oldAddress, address _newWallet)
public
onlyOwner
{
}
function blackListUser(address _user, bool _value) public onlyOwner {
}
function buyWithUSDC(uint256 usdcAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdcAmount))
nonReentrant
returns (bool)
{
}
function buyWithEth()
external
payable
checkPresaleId(currentSale)
checkSaleState(currentSale, ethToTokens(currentSale, msg.value))
nonReentrant
returns (bool)
{
}
function ethBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 ethAmount)
{
}
function usdtBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 usdPrice)
{
}
function ethToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function usdtToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function claimableAmount(address user, uint256 _id)
public
view
returns (uint256)
{
}
function claimAmount(uint256 _id) public returns (bool) {
}
function WithdrawTokens(address _token, uint256 amount) external onlyOwner {
}
function WithdrawContractFunds(uint256 amount) external onlyOwner {
}
function ChangeTokenToSell(address _token) public onlyOwner {
}
function EditMinTokenToBuy(uint256 _amount) public onlyOwner {
}
function ChangeOracleAddress(address _oracle) public onlyOwner {
}
function blockStamp() public view returns(uint256) {
}
}
| paused[_id],"Not paused" | 165,432 | paused[_id] |
"preSAle not Active" | /**
*Submitted for verification at Etherscan.io on 2023-10-27
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
function _nonReentrantBefore() private {
}
function _nonReentrantAfter() private {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage)
private
pure
{
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface Aggregator {
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract TestPre is ReentrancyGuard, Ownable {
uint256 public overalllRaised;
uint256 public presaleId;
uint256 public USDT_MULTIPLIER;
uint256 public ETH_MULTIPLIER;
address public fundReceiver;
uint256 public uniqueBuyers;
struct PresaleData {
uint256 startTime;
uint256 endTime;
uint256 price;
uint256 nextStagePrice;
uint256 Sold;
uint256 tokensToSell;
uint256 UsdtHardcap;
uint256 amountRaised;
bool Active;
bool isEnableClaim;
}
struct VestingData {
uint256 vestingStartTime;
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
}
struct UserData {
uint256 investedAmount;
uint256 claimAt;
uint256 claimAbleAmount;
uint256 claimedVestingAmount;
uint256 claimedAmount;
uint256 claimCount;
uint256 activePercentAmount;
}
IERC20Metadata public USDTInterface;
IERC20Metadata public USDCInterface;
Aggregator internal aggregatorInterface;
mapping(uint256 => bool) public paused;
mapping(uint256 => PresaleData) public presale;
mapping(uint256 => VestingData) public vesting;
mapping(address => mapping(uint256 => UserData)) public userClaimData;
mapping(address => bool) public isExcludeMinToken;
mapping(address => bool) public isBlackList;
mapping(address => bool) public isExist;
uint256 public MinTokenTobuy;
uint256 public currentSale;
address public SaleToken;
event PresaleCreated(
uint256 indexed _id,
uint256 _totalTokens,
uint256 _startTime,
uint256 _endTime
);
event PresaleUpdated(
bytes32 indexed key,
uint256 prevValue,
uint256 newValue,
uint256 timestamp
);
event TokensBought(
address indexed user,
uint256 indexed id,
address indexed purchaseToken,
uint256 tokensBought,
uint256 amountPaid,
uint256 timestamp
);
event TokensClaimed(
address indexed user,
uint256 indexed id,
uint256 amount,
uint256 timestamp
);
event PresaleTokenAddressUpdated(
address indexed prevValue,
address indexed newValue,
uint256 timestamp
);
event PresalePaused(uint256 indexed id, uint256 timestamp);
event PresaleUnpaused(uint256 indexed id, uint256 timestamp);
constructor(
address _oracle,
address _usdt,
address _usdc,
address _SaleToken,
uint256 _MinTokenTobuy
) {
}
function createPresale(
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _UsdtHardcap
) external onlyOwner {
}
function setPresaleStage(uint256 _id) public onlyOwner {
}
function setPresaleVesting(
uint256[] memory _id,
uint256[] memory vestingStartTime,
uint256[] memory _initialClaimPercent,
uint256[] memory _vestingTime,
uint256[] memory _vestingPercentage
) public onlyOwner {
}
function updatePresaleVesting(
uint256 _id,
uint256 _vestingStartTime,
uint256 _initialClaimPercent,
uint256 _vestingTime,
uint256 _vestingPercentage
) public onlyOwner {
}
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
function enableClaim(uint256 _id, bool _status) public onlyOwner {
}
function updatePresale(
uint256 _id,
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _Hardcap,
bool isclaimAble
) external onlyOwner {
}
function changeFundWallet(address _wallet) external onlyOwner {
}
function changeUSDTToken(address _newAddress) external onlyOwner {
}
function changeUSDCToken(address _newAddress) external onlyOwner {
}
function pausePresale(uint256 _id) external checkPresaleId(_id) onlyOwner {
}
function unPausePresale(uint256 _id)
external
checkPresaleId(_id)
onlyOwner
{
}
function getLatestPrice() public view returns (uint256) {
}
modifier checkPresaleId(uint256 _id) {
}
modifier checkSaleState(uint256 _id, uint256 amount) {
require(<FILL_ME>)
require(
amount > 0 &&
amount <= presale[_id].tokensToSell - presale[_id].Sold,
"Invalid sale amount"
);
_;
}
function ExcludeAccouctFromMinBuy(address _user, bool _status)
external
onlyOwner
{
}
function buyWithUSDT(uint256 usdAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdAmount))
nonReentrant
returns (bool)
{
}
function changeClaimAddress(address _oldAddress, address _newWallet)
public
onlyOwner
{
}
function blackListUser(address _user, bool _value) public onlyOwner {
}
function buyWithUSDC(uint256 usdcAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdcAmount))
nonReentrant
returns (bool)
{
}
function buyWithEth()
external
payable
checkPresaleId(currentSale)
checkSaleState(currentSale, ethToTokens(currentSale, msg.value))
nonReentrant
returns (bool)
{
}
function ethBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 ethAmount)
{
}
function usdtBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 usdPrice)
{
}
function ethToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function usdtToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function claimableAmount(address user, uint256 _id)
public
view
returns (uint256)
{
}
function claimAmount(uint256 _id) public returns (bool) {
}
function WithdrawTokens(address _token, uint256 amount) external onlyOwner {
}
function WithdrawContractFunds(uint256 amount) external onlyOwner {
}
function ChangeTokenToSell(address _token) public onlyOwner {
}
function EditMinTokenToBuy(uint256 _amount) public onlyOwner {
}
function ChangeOracleAddress(address _oracle) public onlyOwner {
}
function blockStamp() public view returns(uint256) {
}
}
| presale[_id].Active==true,"preSAle not Active" | 165,432 | presale[_id].Active==true |
"Presale paused" | /**
*Submitted for verification at Etherscan.io on 2023-10-27
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
function _nonReentrantBefore() private {
}
function _nonReentrantAfter() private {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage)
private
pure
{
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface Aggregator {
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract TestPre is ReentrancyGuard, Ownable {
uint256 public overalllRaised;
uint256 public presaleId;
uint256 public USDT_MULTIPLIER;
uint256 public ETH_MULTIPLIER;
address public fundReceiver;
uint256 public uniqueBuyers;
struct PresaleData {
uint256 startTime;
uint256 endTime;
uint256 price;
uint256 nextStagePrice;
uint256 Sold;
uint256 tokensToSell;
uint256 UsdtHardcap;
uint256 amountRaised;
bool Active;
bool isEnableClaim;
}
struct VestingData {
uint256 vestingStartTime;
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
}
struct UserData {
uint256 investedAmount;
uint256 claimAt;
uint256 claimAbleAmount;
uint256 claimedVestingAmount;
uint256 claimedAmount;
uint256 claimCount;
uint256 activePercentAmount;
}
IERC20Metadata public USDTInterface;
IERC20Metadata public USDCInterface;
Aggregator internal aggregatorInterface;
mapping(uint256 => bool) public paused;
mapping(uint256 => PresaleData) public presale;
mapping(uint256 => VestingData) public vesting;
mapping(address => mapping(uint256 => UserData)) public userClaimData;
mapping(address => bool) public isExcludeMinToken;
mapping(address => bool) public isBlackList;
mapping(address => bool) public isExist;
uint256 public MinTokenTobuy;
uint256 public currentSale;
address public SaleToken;
event PresaleCreated(
uint256 indexed _id,
uint256 _totalTokens,
uint256 _startTime,
uint256 _endTime
);
event PresaleUpdated(
bytes32 indexed key,
uint256 prevValue,
uint256 newValue,
uint256 timestamp
);
event TokensBought(
address indexed user,
uint256 indexed id,
address indexed purchaseToken,
uint256 tokensBought,
uint256 amountPaid,
uint256 timestamp
);
event TokensClaimed(
address indexed user,
uint256 indexed id,
uint256 amount,
uint256 timestamp
);
event PresaleTokenAddressUpdated(
address indexed prevValue,
address indexed newValue,
uint256 timestamp
);
event PresalePaused(uint256 indexed id, uint256 timestamp);
event PresaleUnpaused(uint256 indexed id, uint256 timestamp);
constructor(
address _oracle,
address _usdt,
address _usdc,
address _SaleToken,
uint256 _MinTokenTobuy
) {
}
function createPresale(
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _UsdtHardcap
) external onlyOwner {
}
function setPresaleStage(uint256 _id) public onlyOwner {
}
function setPresaleVesting(
uint256[] memory _id,
uint256[] memory vestingStartTime,
uint256[] memory _initialClaimPercent,
uint256[] memory _vestingTime,
uint256[] memory _vestingPercentage
) public onlyOwner {
}
function updatePresaleVesting(
uint256 _id,
uint256 _vestingStartTime,
uint256 _initialClaimPercent,
uint256 _vestingTime,
uint256 _vestingPercentage
) public onlyOwner {
}
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
function enableClaim(uint256 _id, bool _status) public onlyOwner {
}
function updatePresale(
uint256 _id,
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _Hardcap,
bool isclaimAble
) external onlyOwner {
}
function changeFundWallet(address _wallet) external onlyOwner {
}
function changeUSDTToken(address _newAddress) external onlyOwner {
}
function changeUSDCToken(address _newAddress) external onlyOwner {
}
function pausePresale(uint256 _id) external checkPresaleId(_id) onlyOwner {
}
function unPausePresale(uint256 _id)
external
checkPresaleId(_id)
onlyOwner
{
}
function getLatestPrice() public view returns (uint256) {
}
modifier checkPresaleId(uint256 _id) {
}
modifier checkSaleState(uint256 _id, uint256 amount) {
}
function ExcludeAccouctFromMinBuy(address _user, bool _status)
external
onlyOwner
{
}
function buyWithUSDT(uint256 usdAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdAmount))
nonReentrant
returns (bool)
{
require(<FILL_ME>)
require(
presale[currentSale].Active == true,
"Presale is not active yet"
);
require(!isBlackList[msg.sender], "Account is blackListed");
require(
presale[currentSale].amountRaised + usdAmount <=
presale[currentSale].UsdtHardcap,
"Amount should be less than leftHardcap"
);
if (!isExist[msg.sender]) {
isExist[msg.sender] = true;
uniqueBuyers++;
}
uint256 tokens = usdtToTokens(currentSale, usdAmount);
presale[currentSale].Sold += tokens;
presale[currentSale].amountRaised += usdAmount;
overalllRaised += usdAmount;
if (isExcludeMinToken[msg.sender] == false) {
require(tokens >= MinTokenTobuy, "Less than min amount");
}
if (userClaimData[_msgSender()][currentSale].claimAbleAmount > 0) {
userClaimData[_msgSender()][currentSale].claimAbleAmount += tokens;
userClaimData[_msgSender()][currentSale].investedAmount += usdAmount;
} else {
userClaimData[_msgSender()][currentSale] = UserData(
usdAmount,
0,
tokens,
0,
0,
0,
0
);
}
uint256 ourAllowance = USDTInterface.allowance(
_msgSender(),
address(this)
);
require(usdAmount <= ourAllowance, "Make sure to add enough allowance");
(bool success, ) = address(USDTInterface).call(
abi.encodeWithSignature(
"transferFrom(address,address,uint256)",
_msgSender(),
fundReceiver,
usdAmount
)
);
require(success, "Token payment failed");
emit TokensBought(
_msgSender(),
currentSale,
address(USDTInterface),
tokens,
usdAmount,
block.timestamp
);
return true;
}
function changeClaimAddress(address _oldAddress, address _newWallet)
public
onlyOwner
{
}
function blackListUser(address _user, bool _value) public onlyOwner {
}
function buyWithUSDC(uint256 usdcAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdcAmount))
nonReentrant
returns (bool)
{
}
function buyWithEth()
external
payable
checkPresaleId(currentSale)
checkSaleState(currentSale, ethToTokens(currentSale, msg.value))
nonReentrant
returns (bool)
{
}
function ethBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 ethAmount)
{
}
function usdtBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 usdPrice)
{
}
function ethToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function usdtToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function claimableAmount(address user, uint256 _id)
public
view
returns (uint256)
{
}
function claimAmount(uint256 _id) public returns (bool) {
}
function WithdrawTokens(address _token, uint256 amount) external onlyOwner {
}
function WithdrawContractFunds(uint256 amount) external onlyOwner {
}
function ChangeTokenToSell(address _token) public onlyOwner {
}
function EditMinTokenToBuy(uint256 _amount) public onlyOwner {
}
function ChangeOracleAddress(address _oracle) public onlyOwner {
}
function blockStamp() public view returns(uint256) {
}
}
| !paused[currentSale],"Presale paused" | 165,432 | !paused[currentSale] |
"Presale is not active yet" | /**
*Submitted for verification at Etherscan.io on 2023-10-27
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
function _nonReentrantBefore() private {
}
function _nonReentrantAfter() private {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage)
private
pure
{
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface Aggregator {
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract TestPre is ReentrancyGuard, Ownable {
uint256 public overalllRaised;
uint256 public presaleId;
uint256 public USDT_MULTIPLIER;
uint256 public ETH_MULTIPLIER;
address public fundReceiver;
uint256 public uniqueBuyers;
struct PresaleData {
uint256 startTime;
uint256 endTime;
uint256 price;
uint256 nextStagePrice;
uint256 Sold;
uint256 tokensToSell;
uint256 UsdtHardcap;
uint256 amountRaised;
bool Active;
bool isEnableClaim;
}
struct VestingData {
uint256 vestingStartTime;
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
}
struct UserData {
uint256 investedAmount;
uint256 claimAt;
uint256 claimAbleAmount;
uint256 claimedVestingAmount;
uint256 claimedAmount;
uint256 claimCount;
uint256 activePercentAmount;
}
IERC20Metadata public USDTInterface;
IERC20Metadata public USDCInterface;
Aggregator internal aggregatorInterface;
mapping(uint256 => bool) public paused;
mapping(uint256 => PresaleData) public presale;
mapping(uint256 => VestingData) public vesting;
mapping(address => mapping(uint256 => UserData)) public userClaimData;
mapping(address => bool) public isExcludeMinToken;
mapping(address => bool) public isBlackList;
mapping(address => bool) public isExist;
uint256 public MinTokenTobuy;
uint256 public currentSale;
address public SaleToken;
event PresaleCreated(
uint256 indexed _id,
uint256 _totalTokens,
uint256 _startTime,
uint256 _endTime
);
event PresaleUpdated(
bytes32 indexed key,
uint256 prevValue,
uint256 newValue,
uint256 timestamp
);
event TokensBought(
address indexed user,
uint256 indexed id,
address indexed purchaseToken,
uint256 tokensBought,
uint256 amountPaid,
uint256 timestamp
);
event TokensClaimed(
address indexed user,
uint256 indexed id,
uint256 amount,
uint256 timestamp
);
event PresaleTokenAddressUpdated(
address indexed prevValue,
address indexed newValue,
uint256 timestamp
);
event PresalePaused(uint256 indexed id, uint256 timestamp);
event PresaleUnpaused(uint256 indexed id, uint256 timestamp);
constructor(
address _oracle,
address _usdt,
address _usdc,
address _SaleToken,
uint256 _MinTokenTobuy
) {
}
function createPresale(
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _UsdtHardcap
) external onlyOwner {
}
function setPresaleStage(uint256 _id) public onlyOwner {
}
function setPresaleVesting(
uint256[] memory _id,
uint256[] memory vestingStartTime,
uint256[] memory _initialClaimPercent,
uint256[] memory _vestingTime,
uint256[] memory _vestingPercentage
) public onlyOwner {
}
function updatePresaleVesting(
uint256 _id,
uint256 _vestingStartTime,
uint256 _initialClaimPercent,
uint256 _vestingTime,
uint256 _vestingPercentage
) public onlyOwner {
}
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
function enableClaim(uint256 _id, bool _status) public onlyOwner {
}
function updatePresale(
uint256 _id,
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _Hardcap,
bool isclaimAble
) external onlyOwner {
}
function changeFundWallet(address _wallet) external onlyOwner {
}
function changeUSDTToken(address _newAddress) external onlyOwner {
}
function changeUSDCToken(address _newAddress) external onlyOwner {
}
function pausePresale(uint256 _id) external checkPresaleId(_id) onlyOwner {
}
function unPausePresale(uint256 _id)
external
checkPresaleId(_id)
onlyOwner
{
}
function getLatestPrice() public view returns (uint256) {
}
modifier checkPresaleId(uint256 _id) {
}
modifier checkSaleState(uint256 _id, uint256 amount) {
}
function ExcludeAccouctFromMinBuy(address _user, bool _status)
external
onlyOwner
{
}
function buyWithUSDT(uint256 usdAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdAmount))
nonReentrant
returns (bool)
{
require(!paused[currentSale], "Presale paused");
require(<FILL_ME>)
require(!isBlackList[msg.sender], "Account is blackListed");
require(
presale[currentSale].amountRaised + usdAmount <=
presale[currentSale].UsdtHardcap,
"Amount should be less than leftHardcap"
);
if (!isExist[msg.sender]) {
isExist[msg.sender] = true;
uniqueBuyers++;
}
uint256 tokens = usdtToTokens(currentSale, usdAmount);
presale[currentSale].Sold += tokens;
presale[currentSale].amountRaised += usdAmount;
overalllRaised += usdAmount;
if (isExcludeMinToken[msg.sender] == false) {
require(tokens >= MinTokenTobuy, "Less than min amount");
}
if (userClaimData[_msgSender()][currentSale].claimAbleAmount > 0) {
userClaimData[_msgSender()][currentSale].claimAbleAmount += tokens;
userClaimData[_msgSender()][currentSale].investedAmount += usdAmount;
} else {
userClaimData[_msgSender()][currentSale] = UserData(
usdAmount,
0,
tokens,
0,
0,
0,
0
);
}
uint256 ourAllowance = USDTInterface.allowance(
_msgSender(),
address(this)
);
require(usdAmount <= ourAllowance, "Make sure to add enough allowance");
(bool success, ) = address(USDTInterface).call(
abi.encodeWithSignature(
"transferFrom(address,address,uint256)",
_msgSender(),
fundReceiver,
usdAmount
)
);
require(success, "Token payment failed");
emit TokensBought(
_msgSender(),
currentSale,
address(USDTInterface),
tokens,
usdAmount,
block.timestamp
);
return true;
}
function changeClaimAddress(address _oldAddress, address _newWallet)
public
onlyOwner
{
}
function blackListUser(address _user, bool _value) public onlyOwner {
}
function buyWithUSDC(uint256 usdcAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdcAmount))
nonReentrant
returns (bool)
{
}
function buyWithEth()
external
payable
checkPresaleId(currentSale)
checkSaleState(currentSale, ethToTokens(currentSale, msg.value))
nonReentrant
returns (bool)
{
}
function ethBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 ethAmount)
{
}
function usdtBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 usdPrice)
{
}
function ethToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function usdtToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function claimableAmount(address user, uint256 _id)
public
view
returns (uint256)
{
}
function claimAmount(uint256 _id) public returns (bool) {
}
function WithdrawTokens(address _token, uint256 amount) external onlyOwner {
}
function WithdrawContractFunds(uint256 amount) external onlyOwner {
}
function ChangeTokenToSell(address _token) public onlyOwner {
}
function EditMinTokenToBuy(uint256 _amount) public onlyOwner {
}
function ChangeOracleAddress(address _oracle) public onlyOwner {
}
function blockStamp() public view returns(uint256) {
}
}
| presale[currentSale].Active==true,"Presale is not active yet" | 165,432 | presale[currentSale].Active==true |
"Account is blackListed" | /**
*Submitted for verification at Etherscan.io on 2023-10-27
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
function _nonReentrantBefore() private {
}
function _nonReentrantAfter() private {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage)
private
pure
{
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface Aggregator {
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract TestPre is ReentrancyGuard, Ownable {
uint256 public overalllRaised;
uint256 public presaleId;
uint256 public USDT_MULTIPLIER;
uint256 public ETH_MULTIPLIER;
address public fundReceiver;
uint256 public uniqueBuyers;
struct PresaleData {
uint256 startTime;
uint256 endTime;
uint256 price;
uint256 nextStagePrice;
uint256 Sold;
uint256 tokensToSell;
uint256 UsdtHardcap;
uint256 amountRaised;
bool Active;
bool isEnableClaim;
}
struct VestingData {
uint256 vestingStartTime;
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
}
struct UserData {
uint256 investedAmount;
uint256 claimAt;
uint256 claimAbleAmount;
uint256 claimedVestingAmount;
uint256 claimedAmount;
uint256 claimCount;
uint256 activePercentAmount;
}
IERC20Metadata public USDTInterface;
IERC20Metadata public USDCInterface;
Aggregator internal aggregatorInterface;
mapping(uint256 => bool) public paused;
mapping(uint256 => PresaleData) public presale;
mapping(uint256 => VestingData) public vesting;
mapping(address => mapping(uint256 => UserData)) public userClaimData;
mapping(address => bool) public isExcludeMinToken;
mapping(address => bool) public isBlackList;
mapping(address => bool) public isExist;
uint256 public MinTokenTobuy;
uint256 public currentSale;
address public SaleToken;
event PresaleCreated(
uint256 indexed _id,
uint256 _totalTokens,
uint256 _startTime,
uint256 _endTime
);
event PresaleUpdated(
bytes32 indexed key,
uint256 prevValue,
uint256 newValue,
uint256 timestamp
);
event TokensBought(
address indexed user,
uint256 indexed id,
address indexed purchaseToken,
uint256 tokensBought,
uint256 amountPaid,
uint256 timestamp
);
event TokensClaimed(
address indexed user,
uint256 indexed id,
uint256 amount,
uint256 timestamp
);
event PresaleTokenAddressUpdated(
address indexed prevValue,
address indexed newValue,
uint256 timestamp
);
event PresalePaused(uint256 indexed id, uint256 timestamp);
event PresaleUnpaused(uint256 indexed id, uint256 timestamp);
constructor(
address _oracle,
address _usdt,
address _usdc,
address _SaleToken,
uint256 _MinTokenTobuy
) {
}
function createPresale(
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _UsdtHardcap
) external onlyOwner {
}
function setPresaleStage(uint256 _id) public onlyOwner {
}
function setPresaleVesting(
uint256[] memory _id,
uint256[] memory vestingStartTime,
uint256[] memory _initialClaimPercent,
uint256[] memory _vestingTime,
uint256[] memory _vestingPercentage
) public onlyOwner {
}
function updatePresaleVesting(
uint256 _id,
uint256 _vestingStartTime,
uint256 _initialClaimPercent,
uint256 _vestingTime,
uint256 _vestingPercentage
) public onlyOwner {
}
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
function enableClaim(uint256 _id, bool _status) public onlyOwner {
}
function updatePresale(
uint256 _id,
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _Hardcap,
bool isclaimAble
) external onlyOwner {
}
function changeFundWallet(address _wallet) external onlyOwner {
}
function changeUSDTToken(address _newAddress) external onlyOwner {
}
function changeUSDCToken(address _newAddress) external onlyOwner {
}
function pausePresale(uint256 _id) external checkPresaleId(_id) onlyOwner {
}
function unPausePresale(uint256 _id)
external
checkPresaleId(_id)
onlyOwner
{
}
function getLatestPrice() public view returns (uint256) {
}
modifier checkPresaleId(uint256 _id) {
}
modifier checkSaleState(uint256 _id, uint256 amount) {
}
function ExcludeAccouctFromMinBuy(address _user, bool _status)
external
onlyOwner
{
}
function buyWithUSDT(uint256 usdAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdAmount))
nonReentrant
returns (bool)
{
require(!paused[currentSale], "Presale paused");
require(
presale[currentSale].Active == true,
"Presale is not active yet"
);
require(<FILL_ME>)
require(
presale[currentSale].amountRaised + usdAmount <=
presale[currentSale].UsdtHardcap,
"Amount should be less than leftHardcap"
);
if (!isExist[msg.sender]) {
isExist[msg.sender] = true;
uniqueBuyers++;
}
uint256 tokens = usdtToTokens(currentSale, usdAmount);
presale[currentSale].Sold += tokens;
presale[currentSale].amountRaised += usdAmount;
overalllRaised += usdAmount;
if (isExcludeMinToken[msg.sender] == false) {
require(tokens >= MinTokenTobuy, "Less than min amount");
}
if (userClaimData[_msgSender()][currentSale].claimAbleAmount > 0) {
userClaimData[_msgSender()][currentSale].claimAbleAmount += tokens;
userClaimData[_msgSender()][currentSale].investedAmount += usdAmount;
} else {
userClaimData[_msgSender()][currentSale] = UserData(
usdAmount,
0,
tokens,
0,
0,
0,
0
);
}
uint256 ourAllowance = USDTInterface.allowance(
_msgSender(),
address(this)
);
require(usdAmount <= ourAllowance, "Make sure to add enough allowance");
(bool success, ) = address(USDTInterface).call(
abi.encodeWithSignature(
"transferFrom(address,address,uint256)",
_msgSender(),
fundReceiver,
usdAmount
)
);
require(success, "Token payment failed");
emit TokensBought(
_msgSender(),
currentSale,
address(USDTInterface),
tokens,
usdAmount,
block.timestamp
);
return true;
}
function changeClaimAddress(address _oldAddress, address _newWallet)
public
onlyOwner
{
}
function blackListUser(address _user, bool _value) public onlyOwner {
}
function buyWithUSDC(uint256 usdcAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdcAmount))
nonReentrant
returns (bool)
{
}
function buyWithEth()
external
payable
checkPresaleId(currentSale)
checkSaleState(currentSale, ethToTokens(currentSale, msg.value))
nonReentrant
returns (bool)
{
}
function ethBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 ethAmount)
{
}
function usdtBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 usdPrice)
{
}
function ethToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function usdtToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function claimableAmount(address user, uint256 _id)
public
view
returns (uint256)
{
}
function claimAmount(uint256 _id) public returns (bool) {
}
function WithdrawTokens(address _token, uint256 amount) external onlyOwner {
}
function WithdrawContractFunds(uint256 amount) external onlyOwner {
}
function ChangeTokenToSell(address _token) public onlyOwner {
}
function EditMinTokenToBuy(uint256 _amount) public onlyOwner {
}
function ChangeOracleAddress(address _oracle) public onlyOwner {
}
function blockStamp() public view returns(uint256) {
}
}
| !isBlackList[msg.sender],"Account is blackListed" | 165,432 | !isBlackList[msg.sender] |
"Amount should be less than leftHardcap" | /**
*Submitted for verification at Etherscan.io on 2023-10-27
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
function _nonReentrantBefore() private {
}
function _nonReentrantAfter() private {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage)
private
pure
{
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface Aggregator {
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract TestPre is ReentrancyGuard, Ownable {
uint256 public overalllRaised;
uint256 public presaleId;
uint256 public USDT_MULTIPLIER;
uint256 public ETH_MULTIPLIER;
address public fundReceiver;
uint256 public uniqueBuyers;
struct PresaleData {
uint256 startTime;
uint256 endTime;
uint256 price;
uint256 nextStagePrice;
uint256 Sold;
uint256 tokensToSell;
uint256 UsdtHardcap;
uint256 amountRaised;
bool Active;
bool isEnableClaim;
}
struct VestingData {
uint256 vestingStartTime;
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
}
struct UserData {
uint256 investedAmount;
uint256 claimAt;
uint256 claimAbleAmount;
uint256 claimedVestingAmount;
uint256 claimedAmount;
uint256 claimCount;
uint256 activePercentAmount;
}
IERC20Metadata public USDTInterface;
IERC20Metadata public USDCInterface;
Aggregator internal aggregatorInterface;
mapping(uint256 => bool) public paused;
mapping(uint256 => PresaleData) public presale;
mapping(uint256 => VestingData) public vesting;
mapping(address => mapping(uint256 => UserData)) public userClaimData;
mapping(address => bool) public isExcludeMinToken;
mapping(address => bool) public isBlackList;
mapping(address => bool) public isExist;
uint256 public MinTokenTobuy;
uint256 public currentSale;
address public SaleToken;
event PresaleCreated(
uint256 indexed _id,
uint256 _totalTokens,
uint256 _startTime,
uint256 _endTime
);
event PresaleUpdated(
bytes32 indexed key,
uint256 prevValue,
uint256 newValue,
uint256 timestamp
);
event TokensBought(
address indexed user,
uint256 indexed id,
address indexed purchaseToken,
uint256 tokensBought,
uint256 amountPaid,
uint256 timestamp
);
event TokensClaimed(
address indexed user,
uint256 indexed id,
uint256 amount,
uint256 timestamp
);
event PresaleTokenAddressUpdated(
address indexed prevValue,
address indexed newValue,
uint256 timestamp
);
event PresalePaused(uint256 indexed id, uint256 timestamp);
event PresaleUnpaused(uint256 indexed id, uint256 timestamp);
constructor(
address _oracle,
address _usdt,
address _usdc,
address _SaleToken,
uint256 _MinTokenTobuy
) {
}
function createPresale(
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _UsdtHardcap
) external onlyOwner {
}
function setPresaleStage(uint256 _id) public onlyOwner {
}
function setPresaleVesting(
uint256[] memory _id,
uint256[] memory vestingStartTime,
uint256[] memory _initialClaimPercent,
uint256[] memory _vestingTime,
uint256[] memory _vestingPercentage
) public onlyOwner {
}
function updatePresaleVesting(
uint256 _id,
uint256 _vestingStartTime,
uint256 _initialClaimPercent,
uint256 _vestingTime,
uint256 _vestingPercentage
) public onlyOwner {
}
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
function enableClaim(uint256 _id, bool _status) public onlyOwner {
}
function updatePresale(
uint256 _id,
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _Hardcap,
bool isclaimAble
) external onlyOwner {
}
function changeFundWallet(address _wallet) external onlyOwner {
}
function changeUSDTToken(address _newAddress) external onlyOwner {
}
function changeUSDCToken(address _newAddress) external onlyOwner {
}
function pausePresale(uint256 _id) external checkPresaleId(_id) onlyOwner {
}
function unPausePresale(uint256 _id)
external
checkPresaleId(_id)
onlyOwner
{
}
function getLatestPrice() public view returns (uint256) {
}
modifier checkPresaleId(uint256 _id) {
}
modifier checkSaleState(uint256 _id, uint256 amount) {
}
function ExcludeAccouctFromMinBuy(address _user, bool _status)
external
onlyOwner
{
}
function buyWithUSDT(uint256 usdAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdAmount))
nonReentrant
returns (bool)
{
require(!paused[currentSale], "Presale paused");
require(
presale[currentSale].Active == true,
"Presale is not active yet"
);
require(!isBlackList[msg.sender], "Account is blackListed");
require(<FILL_ME>)
if (!isExist[msg.sender]) {
isExist[msg.sender] = true;
uniqueBuyers++;
}
uint256 tokens = usdtToTokens(currentSale, usdAmount);
presale[currentSale].Sold += tokens;
presale[currentSale].amountRaised += usdAmount;
overalllRaised += usdAmount;
if (isExcludeMinToken[msg.sender] == false) {
require(tokens >= MinTokenTobuy, "Less than min amount");
}
if (userClaimData[_msgSender()][currentSale].claimAbleAmount > 0) {
userClaimData[_msgSender()][currentSale].claimAbleAmount += tokens;
userClaimData[_msgSender()][currentSale].investedAmount += usdAmount;
} else {
userClaimData[_msgSender()][currentSale] = UserData(
usdAmount,
0,
tokens,
0,
0,
0,
0
);
}
uint256 ourAllowance = USDTInterface.allowance(
_msgSender(),
address(this)
);
require(usdAmount <= ourAllowance, "Make sure to add enough allowance");
(bool success, ) = address(USDTInterface).call(
abi.encodeWithSignature(
"transferFrom(address,address,uint256)",
_msgSender(),
fundReceiver,
usdAmount
)
);
require(success, "Token payment failed");
emit TokensBought(
_msgSender(),
currentSale,
address(USDTInterface),
tokens,
usdAmount,
block.timestamp
);
return true;
}
function changeClaimAddress(address _oldAddress, address _newWallet)
public
onlyOwner
{
}
function blackListUser(address _user, bool _value) public onlyOwner {
}
function buyWithUSDC(uint256 usdcAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdcAmount))
nonReentrant
returns (bool)
{
}
function buyWithEth()
external
payable
checkPresaleId(currentSale)
checkSaleState(currentSale, ethToTokens(currentSale, msg.value))
nonReentrant
returns (bool)
{
}
function ethBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 ethAmount)
{
}
function usdtBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 usdPrice)
{
}
function ethToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function usdtToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function claimableAmount(address user, uint256 _id)
public
view
returns (uint256)
{
}
function claimAmount(uint256 _id) public returns (bool) {
}
function WithdrawTokens(address _token, uint256 amount) external onlyOwner {
}
function WithdrawContractFunds(uint256 amount) external onlyOwner {
}
function ChangeTokenToSell(address _token) public onlyOwner {
}
function EditMinTokenToBuy(uint256 _amount) public onlyOwner {
}
function ChangeOracleAddress(address _oracle) public onlyOwner {
}
function blockStamp() public view returns(uint256) {
}
}
| presale[currentSale].amountRaised+usdAmount<=presale[currentSale].UsdtHardcap,"Amount should be less than leftHardcap" | 165,432 | presale[currentSale].amountRaised+usdAmount<=presale[currentSale].UsdtHardcap |
"User not a participant" | /**
*Submitted for verification at Etherscan.io on 2023-10-27
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
function _nonReentrantBefore() private {
}
function _nonReentrantAfter() private {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage)
private
pure
{
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface Aggregator {
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract TestPre is ReentrancyGuard, Ownable {
uint256 public overalllRaised;
uint256 public presaleId;
uint256 public USDT_MULTIPLIER;
uint256 public ETH_MULTIPLIER;
address public fundReceiver;
uint256 public uniqueBuyers;
struct PresaleData {
uint256 startTime;
uint256 endTime;
uint256 price;
uint256 nextStagePrice;
uint256 Sold;
uint256 tokensToSell;
uint256 UsdtHardcap;
uint256 amountRaised;
bool Active;
bool isEnableClaim;
}
struct VestingData {
uint256 vestingStartTime;
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
}
struct UserData {
uint256 investedAmount;
uint256 claimAt;
uint256 claimAbleAmount;
uint256 claimedVestingAmount;
uint256 claimedAmount;
uint256 claimCount;
uint256 activePercentAmount;
}
IERC20Metadata public USDTInterface;
IERC20Metadata public USDCInterface;
Aggregator internal aggregatorInterface;
mapping(uint256 => bool) public paused;
mapping(uint256 => PresaleData) public presale;
mapping(uint256 => VestingData) public vesting;
mapping(address => mapping(uint256 => UserData)) public userClaimData;
mapping(address => bool) public isExcludeMinToken;
mapping(address => bool) public isBlackList;
mapping(address => bool) public isExist;
uint256 public MinTokenTobuy;
uint256 public currentSale;
address public SaleToken;
event PresaleCreated(
uint256 indexed _id,
uint256 _totalTokens,
uint256 _startTime,
uint256 _endTime
);
event PresaleUpdated(
bytes32 indexed key,
uint256 prevValue,
uint256 newValue,
uint256 timestamp
);
event TokensBought(
address indexed user,
uint256 indexed id,
address indexed purchaseToken,
uint256 tokensBought,
uint256 amountPaid,
uint256 timestamp
);
event TokensClaimed(
address indexed user,
uint256 indexed id,
uint256 amount,
uint256 timestamp
);
event PresaleTokenAddressUpdated(
address indexed prevValue,
address indexed newValue,
uint256 timestamp
);
event PresalePaused(uint256 indexed id, uint256 timestamp);
event PresaleUnpaused(uint256 indexed id, uint256 timestamp);
constructor(
address _oracle,
address _usdt,
address _usdc,
address _SaleToken,
uint256 _MinTokenTobuy
) {
}
function createPresale(
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _UsdtHardcap
) external onlyOwner {
}
function setPresaleStage(uint256 _id) public onlyOwner {
}
function setPresaleVesting(
uint256[] memory _id,
uint256[] memory vestingStartTime,
uint256[] memory _initialClaimPercent,
uint256[] memory _vestingTime,
uint256[] memory _vestingPercentage
) public onlyOwner {
}
function updatePresaleVesting(
uint256 _id,
uint256 _vestingStartTime,
uint256 _initialClaimPercent,
uint256 _vestingTime,
uint256 _vestingPercentage
) public onlyOwner {
}
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
function enableClaim(uint256 _id, bool _status) public onlyOwner {
}
function updatePresale(
uint256 _id,
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _Hardcap,
bool isclaimAble
) external onlyOwner {
}
function changeFundWallet(address _wallet) external onlyOwner {
}
function changeUSDTToken(address _newAddress) external onlyOwner {
}
function changeUSDCToken(address _newAddress) external onlyOwner {
}
function pausePresale(uint256 _id) external checkPresaleId(_id) onlyOwner {
}
function unPausePresale(uint256 _id)
external
checkPresaleId(_id)
onlyOwner
{
}
function getLatestPrice() public view returns (uint256) {
}
modifier checkPresaleId(uint256 _id) {
}
modifier checkSaleState(uint256 _id, uint256 amount) {
}
function ExcludeAccouctFromMinBuy(address _user, bool _status)
external
onlyOwner
{
}
function buyWithUSDT(uint256 usdAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdAmount))
nonReentrant
returns (bool)
{
}
function changeClaimAddress(address _oldAddress, address _newWallet)
public
onlyOwner
{
for (uint256 i = 1; i < presaleId; i++) {
require(<FILL_ME>)
userClaimData[_newWallet][i].claimAbleAmount = userClaimData[
_oldAddress
][i].claimAbleAmount;
userClaimData[_oldAddress][i].claimAbleAmount = 0;
}
isExist[_oldAddress] = false;
isExist[_newWallet] = true;
}
function blackListUser(address _user, bool _value) public onlyOwner {
}
function buyWithUSDC(uint256 usdcAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdcAmount))
nonReentrant
returns (bool)
{
}
function buyWithEth()
external
payable
checkPresaleId(currentSale)
checkSaleState(currentSale, ethToTokens(currentSale, msg.value))
nonReentrant
returns (bool)
{
}
function ethBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 ethAmount)
{
}
function usdtBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 usdPrice)
{
}
function ethToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function usdtToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function claimableAmount(address user, uint256 _id)
public
view
returns (uint256)
{
}
function claimAmount(uint256 _id) public returns (bool) {
}
function WithdrawTokens(address _token, uint256 amount) external onlyOwner {
}
function WithdrawContractFunds(uint256 amount) external onlyOwner {
}
function ChangeTokenToSell(address _token) public onlyOwner {
}
function EditMinTokenToBuy(uint256 _amount) public onlyOwner {
}
function ChangeOracleAddress(address _oracle) public onlyOwner {
}
function blockStamp() public view returns(uint256) {
}
}
| isExist[_oldAddress],"User not a participant" | 165,432 | isExist[_oldAddress] |
"Amount should be less than leftHardcap" | /**
*Submitted for verification at Etherscan.io on 2023-10-27
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
function _nonReentrantBefore() private {
}
function _nonReentrantAfter() private {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage)
private
pure
{
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface Aggregator {
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract TestPre is ReentrancyGuard, Ownable {
uint256 public overalllRaised;
uint256 public presaleId;
uint256 public USDT_MULTIPLIER;
uint256 public ETH_MULTIPLIER;
address public fundReceiver;
uint256 public uniqueBuyers;
struct PresaleData {
uint256 startTime;
uint256 endTime;
uint256 price;
uint256 nextStagePrice;
uint256 Sold;
uint256 tokensToSell;
uint256 UsdtHardcap;
uint256 amountRaised;
bool Active;
bool isEnableClaim;
}
struct VestingData {
uint256 vestingStartTime;
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
}
struct UserData {
uint256 investedAmount;
uint256 claimAt;
uint256 claimAbleAmount;
uint256 claimedVestingAmount;
uint256 claimedAmount;
uint256 claimCount;
uint256 activePercentAmount;
}
IERC20Metadata public USDTInterface;
IERC20Metadata public USDCInterface;
Aggregator internal aggregatorInterface;
mapping(uint256 => bool) public paused;
mapping(uint256 => PresaleData) public presale;
mapping(uint256 => VestingData) public vesting;
mapping(address => mapping(uint256 => UserData)) public userClaimData;
mapping(address => bool) public isExcludeMinToken;
mapping(address => bool) public isBlackList;
mapping(address => bool) public isExist;
uint256 public MinTokenTobuy;
uint256 public currentSale;
address public SaleToken;
event PresaleCreated(
uint256 indexed _id,
uint256 _totalTokens,
uint256 _startTime,
uint256 _endTime
);
event PresaleUpdated(
bytes32 indexed key,
uint256 prevValue,
uint256 newValue,
uint256 timestamp
);
event TokensBought(
address indexed user,
uint256 indexed id,
address indexed purchaseToken,
uint256 tokensBought,
uint256 amountPaid,
uint256 timestamp
);
event TokensClaimed(
address indexed user,
uint256 indexed id,
uint256 amount,
uint256 timestamp
);
event PresaleTokenAddressUpdated(
address indexed prevValue,
address indexed newValue,
uint256 timestamp
);
event PresalePaused(uint256 indexed id, uint256 timestamp);
event PresaleUnpaused(uint256 indexed id, uint256 timestamp);
constructor(
address _oracle,
address _usdt,
address _usdc,
address _SaleToken,
uint256 _MinTokenTobuy
) {
}
function createPresale(
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _UsdtHardcap
) external onlyOwner {
}
function setPresaleStage(uint256 _id) public onlyOwner {
}
function setPresaleVesting(
uint256[] memory _id,
uint256[] memory vestingStartTime,
uint256[] memory _initialClaimPercent,
uint256[] memory _vestingTime,
uint256[] memory _vestingPercentage
) public onlyOwner {
}
function updatePresaleVesting(
uint256 _id,
uint256 _vestingStartTime,
uint256 _initialClaimPercent,
uint256 _vestingTime,
uint256 _vestingPercentage
) public onlyOwner {
}
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
function enableClaim(uint256 _id, bool _status) public onlyOwner {
}
function updatePresale(
uint256 _id,
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _Hardcap,
bool isclaimAble
) external onlyOwner {
}
function changeFundWallet(address _wallet) external onlyOwner {
}
function changeUSDTToken(address _newAddress) external onlyOwner {
}
function changeUSDCToken(address _newAddress) external onlyOwner {
}
function pausePresale(uint256 _id) external checkPresaleId(_id) onlyOwner {
}
function unPausePresale(uint256 _id)
external
checkPresaleId(_id)
onlyOwner
{
}
function getLatestPrice() public view returns (uint256) {
}
modifier checkPresaleId(uint256 _id) {
}
modifier checkSaleState(uint256 _id, uint256 amount) {
}
function ExcludeAccouctFromMinBuy(address _user, bool _status)
external
onlyOwner
{
}
function buyWithUSDT(uint256 usdAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdAmount))
nonReentrant
returns (bool)
{
}
function changeClaimAddress(address _oldAddress, address _newWallet)
public
onlyOwner
{
}
function blackListUser(address _user, bool _value) public onlyOwner {
}
function buyWithUSDC(uint256 usdcAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdcAmount))
nonReentrant
returns (bool)
{
require(!paused[currentSale], "Presale paused");
require(
presale[currentSale].Active == true,
"Presale is not active yet"
);
require(<FILL_ME>)
require(!isBlackList[msg.sender], "Account is blackListed");
if (!isExist[msg.sender]) {
isExist[msg.sender] = true;
uniqueBuyers++;
}
uint256 tokens = usdtToTokens(currentSale, usdcAmount);
presale[currentSale].Sold += tokens;
presale[currentSale].amountRaised += usdcAmount;
overalllRaised += usdcAmount;
if (isExcludeMinToken[msg.sender] == false) {
require(tokens >= MinTokenTobuy, "Less than min amount");
}
if (userClaimData[_msgSender()][currentSale].claimAbleAmount > 0) {
userClaimData[_msgSender()][currentSale].claimAbleAmount += tokens;
userClaimData[_msgSender()][currentSale].investedAmount += usdcAmount;
} else {
userClaimData[_msgSender()][currentSale] = UserData(
usdcAmount,
0,
tokens,
0,
0,
0,
0
);
require(isExist[_msgSender()], "User not a participant");
}
uint256 ourAllowance = USDTInterface.allowance(
_msgSender(),
address(this)
);
require(
usdcAmount <= ourAllowance,
"Make sure to add enough allowance"
);
(bool success, ) = address(USDCInterface).call(
abi.encodeWithSignature(
"transferFrom(address,address,uint256)",
_msgSender(),
fundReceiver,
usdcAmount
)
);
require(success, "Token payment failed");
emit TokensBought(
_msgSender(),
currentSale,
address(USDTInterface),
tokens,
usdcAmount,
block.timestamp
);
return true;
}
function buyWithEth()
external
payable
checkPresaleId(currentSale)
checkSaleState(currentSale, ethToTokens(currentSale, msg.value))
nonReentrant
returns (bool)
{
}
function ethBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 ethAmount)
{
}
function usdtBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 usdPrice)
{
}
function ethToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function usdtToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function claimableAmount(address user, uint256 _id)
public
view
returns (uint256)
{
}
function claimAmount(uint256 _id) public returns (bool) {
}
function WithdrawTokens(address _token, uint256 amount) external onlyOwner {
}
function WithdrawContractFunds(uint256 amount) external onlyOwner {
}
function ChangeTokenToSell(address _token) public onlyOwner {
}
function EditMinTokenToBuy(uint256 _amount) public onlyOwner {
}
function ChangeOracleAddress(address _oracle) public onlyOwner {
}
function blockStamp() public view returns(uint256) {
}
}
| presale[currentSale].amountRaised+usdcAmount<=presale[currentSale].UsdtHardcap,"Amount should be less than leftHardcap" | 165,432 | presale[currentSale].amountRaised+usdcAmount<=presale[currentSale].UsdtHardcap |
"User not a participant" | /**
*Submitted for verification at Etherscan.io on 2023-10-27
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
function _nonReentrantBefore() private {
}
function _nonReentrantAfter() private {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage)
private
pure
{
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface Aggregator {
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract TestPre is ReentrancyGuard, Ownable {
uint256 public overalllRaised;
uint256 public presaleId;
uint256 public USDT_MULTIPLIER;
uint256 public ETH_MULTIPLIER;
address public fundReceiver;
uint256 public uniqueBuyers;
struct PresaleData {
uint256 startTime;
uint256 endTime;
uint256 price;
uint256 nextStagePrice;
uint256 Sold;
uint256 tokensToSell;
uint256 UsdtHardcap;
uint256 amountRaised;
bool Active;
bool isEnableClaim;
}
struct VestingData {
uint256 vestingStartTime;
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
}
struct UserData {
uint256 investedAmount;
uint256 claimAt;
uint256 claimAbleAmount;
uint256 claimedVestingAmount;
uint256 claimedAmount;
uint256 claimCount;
uint256 activePercentAmount;
}
IERC20Metadata public USDTInterface;
IERC20Metadata public USDCInterface;
Aggregator internal aggregatorInterface;
mapping(uint256 => bool) public paused;
mapping(uint256 => PresaleData) public presale;
mapping(uint256 => VestingData) public vesting;
mapping(address => mapping(uint256 => UserData)) public userClaimData;
mapping(address => bool) public isExcludeMinToken;
mapping(address => bool) public isBlackList;
mapping(address => bool) public isExist;
uint256 public MinTokenTobuy;
uint256 public currentSale;
address public SaleToken;
event PresaleCreated(
uint256 indexed _id,
uint256 _totalTokens,
uint256 _startTime,
uint256 _endTime
);
event PresaleUpdated(
bytes32 indexed key,
uint256 prevValue,
uint256 newValue,
uint256 timestamp
);
event TokensBought(
address indexed user,
uint256 indexed id,
address indexed purchaseToken,
uint256 tokensBought,
uint256 amountPaid,
uint256 timestamp
);
event TokensClaimed(
address indexed user,
uint256 indexed id,
uint256 amount,
uint256 timestamp
);
event PresaleTokenAddressUpdated(
address indexed prevValue,
address indexed newValue,
uint256 timestamp
);
event PresalePaused(uint256 indexed id, uint256 timestamp);
event PresaleUnpaused(uint256 indexed id, uint256 timestamp);
constructor(
address _oracle,
address _usdt,
address _usdc,
address _SaleToken,
uint256 _MinTokenTobuy
) {
}
function createPresale(
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _UsdtHardcap
) external onlyOwner {
}
function setPresaleStage(uint256 _id) public onlyOwner {
}
function setPresaleVesting(
uint256[] memory _id,
uint256[] memory vestingStartTime,
uint256[] memory _initialClaimPercent,
uint256[] memory _vestingTime,
uint256[] memory _vestingPercentage
) public onlyOwner {
}
function updatePresaleVesting(
uint256 _id,
uint256 _vestingStartTime,
uint256 _initialClaimPercent,
uint256 _vestingTime,
uint256 _vestingPercentage
) public onlyOwner {
}
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
function enableClaim(uint256 _id, bool _status) public onlyOwner {
}
function updatePresale(
uint256 _id,
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _Hardcap,
bool isclaimAble
) external onlyOwner {
}
function changeFundWallet(address _wallet) external onlyOwner {
}
function changeUSDTToken(address _newAddress) external onlyOwner {
}
function changeUSDCToken(address _newAddress) external onlyOwner {
}
function pausePresale(uint256 _id) external checkPresaleId(_id) onlyOwner {
}
function unPausePresale(uint256 _id)
external
checkPresaleId(_id)
onlyOwner
{
}
function getLatestPrice() public view returns (uint256) {
}
modifier checkPresaleId(uint256 _id) {
}
modifier checkSaleState(uint256 _id, uint256 amount) {
}
function ExcludeAccouctFromMinBuy(address _user, bool _status)
external
onlyOwner
{
}
function buyWithUSDT(uint256 usdAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdAmount))
nonReentrant
returns (bool)
{
}
function changeClaimAddress(address _oldAddress, address _newWallet)
public
onlyOwner
{
}
function blackListUser(address _user, bool _value) public onlyOwner {
}
function buyWithUSDC(uint256 usdcAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdcAmount))
nonReentrant
returns (bool)
{
require(!paused[currentSale], "Presale paused");
require(
presale[currentSale].Active == true,
"Presale is not active yet"
);
require(
presale[currentSale].amountRaised + usdcAmount <=
presale[currentSale].UsdtHardcap,
"Amount should be less than leftHardcap"
);
require(!isBlackList[msg.sender], "Account is blackListed");
if (!isExist[msg.sender]) {
isExist[msg.sender] = true;
uniqueBuyers++;
}
uint256 tokens = usdtToTokens(currentSale, usdcAmount);
presale[currentSale].Sold += tokens;
presale[currentSale].amountRaised += usdcAmount;
overalllRaised += usdcAmount;
if (isExcludeMinToken[msg.sender] == false) {
require(tokens >= MinTokenTobuy, "Less than min amount");
}
if (userClaimData[_msgSender()][currentSale].claimAbleAmount > 0) {
userClaimData[_msgSender()][currentSale].claimAbleAmount += tokens;
userClaimData[_msgSender()][currentSale].investedAmount += usdcAmount;
} else {
userClaimData[_msgSender()][currentSale] = UserData(
usdcAmount,
0,
tokens,
0,
0,
0,
0
);
require(<FILL_ME>)
}
uint256 ourAllowance = USDTInterface.allowance(
_msgSender(),
address(this)
);
require(
usdcAmount <= ourAllowance,
"Make sure to add enough allowance"
);
(bool success, ) = address(USDCInterface).call(
abi.encodeWithSignature(
"transferFrom(address,address,uint256)",
_msgSender(),
fundReceiver,
usdcAmount
)
);
require(success, "Token payment failed");
emit TokensBought(
_msgSender(),
currentSale,
address(USDTInterface),
tokens,
usdcAmount,
block.timestamp
);
return true;
}
function buyWithEth()
external
payable
checkPresaleId(currentSale)
checkSaleState(currentSale, ethToTokens(currentSale, msg.value))
nonReentrant
returns (bool)
{
}
function ethBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 ethAmount)
{
}
function usdtBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 usdPrice)
{
}
function ethToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function usdtToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function claimableAmount(address user, uint256 _id)
public
view
returns (uint256)
{
}
function claimAmount(uint256 _id) public returns (bool) {
}
function WithdrawTokens(address _token, uint256 amount) external onlyOwner {
}
function WithdrawContractFunds(uint256 amount) external onlyOwner {
}
function ChangeTokenToSell(address _token) public onlyOwner {
}
function EditMinTokenToBuy(uint256 _amount) public onlyOwner {
}
function ChangeOracleAddress(address _oracle) public onlyOwner {
}
function blockStamp() public view returns(uint256) {
}
}
| isExist[_msgSender()],"User not a participant" | 165,432 | isExist[_msgSender()] |
"Claim is not enable" | /**
*Submitted for verification at Etherscan.io on 2023-10-27
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
function _nonReentrantBefore() private {
}
function _nonReentrantAfter() private {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage)
private
pure
{
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface Aggregator {
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract TestPre is ReentrancyGuard, Ownable {
uint256 public overalllRaised;
uint256 public presaleId;
uint256 public USDT_MULTIPLIER;
uint256 public ETH_MULTIPLIER;
address public fundReceiver;
uint256 public uniqueBuyers;
struct PresaleData {
uint256 startTime;
uint256 endTime;
uint256 price;
uint256 nextStagePrice;
uint256 Sold;
uint256 tokensToSell;
uint256 UsdtHardcap;
uint256 amountRaised;
bool Active;
bool isEnableClaim;
}
struct VestingData {
uint256 vestingStartTime;
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
}
struct UserData {
uint256 investedAmount;
uint256 claimAt;
uint256 claimAbleAmount;
uint256 claimedVestingAmount;
uint256 claimedAmount;
uint256 claimCount;
uint256 activePercentAmount;
}
IERC20Metadata public USDTInterface;
IERC20Metadata public USDCInterface;
Aggregator internal aggregatorInterface;
mapping(uint256 => bool) public paused;
mapping(uint256 => PresaleData) public presale;
mapping(uint256 => VestingData) public vesting;
mapping(address => mapping(uint256 => UserData)) public userClaimData;
mapping(address => bool) public isExcludeMinToken;
mapping(address => bool) public isBlackList;
mapping(address => bool) public isExist;
uint256 public MinTokenTobuy;
uint256 public currentSale;
address public SaleToken;
event PresaleCreated(
uint256 indexed _id,
uint256 _totalTokens,
uint256 _startTime,
uint256 _endTime
);
event PresaleUpdated(
bytes32 indexed key,
uint256 prevValue,
uint256 newValue,
uint256 timestamp
);
event TokensBought(
address indexed user,
uint256 indexed id,
address indexed purchaseToken,
uint256 tokensBought,
uint256 amountPaid,
uint256 timestamp
);
event TokensClaimed(
address indexed user,
uint256 indexed id,
uint256 amount,
uint256 timestamp
);
event PresaleTokenAddressUpdated(
address indexed prevValue,
address indexed newValue,
uint256 timestamp
);
event PresalePaused(uint256 indexed id, uint256 timestamp);
event PresaleUnpaused(uint256 indexed id, uint256 timestamp);
constructor(
address _oracle,
address _usdt,
address _usdc,
address _SaleToken,
uint256 _MinTokenTobuy
) {
}
function createPresale(
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _UsdtHardcap
) external onlyOwner {
}
function setPresaleStage(uint256 _id) public onlyOwner {
}
function setPresaleVesting(
uint256[] memory _id,
uint256[] memory vestingStartTime,
uint256[] memory _initialClaimPercent,
uint256[] memory _vestingTime,
uint256[] memory _vestingPercentage
) public onlyOwner {
}
function updatePresaleVesting(
uint256 _id,
uint256 _vestingStartTime,
uint256 _initialClaimPercent,
uint256 _vestingTime,
uint256 _vestingPercentage
) public onlyOwner {
}
uint256 initialClaimPercent;
uint256 vestingTime;
uint256 vestingPercentage;
uint256 totalClaimCycles;
function enableClaim(uint256 _id, bool _status) public onlyOwner {
}
function updatePresale(
uint256 _id,
uint256 _price,
uint256 _nextStagePrice,
uint256 _tokensToSell,
uint256 _Hardcap,
bool isclaimAble
) external onlyOwner {
}
function changeFundWallet(address _wallet) external onlyOwner {
}
function changeUSDTToken(address _newAddress) external onlyOwner {
}
function changeUSDCToken(address _newAddress) external onlyOwner {
}
function pausePresale(uint256 _id) external checkPresaleId(_id) onlyOwner {
}
function unPausePresale(uint256 _id)
external
checkPresaleId(_id)
onlyOwner
{
}
function getLatestPrice() public view returns (uint256) {
}
modifier checkPresaleId(uint256 _id) {
}
modifier checkSaleState(uint256 _id, uint256 amount) {
}
function ExcludeAccouctFromMinBuy(address _user, bool _status)
external
onlyOwner
{
}
function buyWithUSDT(uint256 usdAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdAmount))
nonReentrant
returns (bool)
{
}
function changeClaimAddress(address _oldAddress, address _newWallet)
public
onlyOwner
{
}
function blackListUser(address _user, bool _value) public onlyOwner {
}
function buyWithUSDC(uint256 usdcAmount)
external
checkPresaleId(currentSale)
checkSaleState(currentSale, usdtToTokens(currentSale, usdcAmount))
nonReentrant
returns (bool)
{
}
function buyWithEth()
external
payable
checkPresaleId(currentSale)
checkSaleState(currentSale, ethToTokens(currentSale, msg.value))
nonReentrant
returns (bool)
{
}
function ethBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 ethAmount)
{
}
function usdtBuyHelper(uint256 _id, uint256 amount)
external
view
returns (uint256 usdPrice)
{
}
function ethToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function usdtToTokens(uint256 _id, uint256 amount)
public
view
returns (uint256 _tokens)
{
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function claimableAmount(address user, uint256 _id)
public
view
returns (uint256)
{
}
function claimAmount(uint256 _id) public returns (bool) {
require(isExist[_msgSender()], "User not a participant");
uint256 amount = claimableAmount(msg.sender, _id);
require(amount > 0, "No claimable amount");
require(!isBlackList[msg.sender], "Account is blackListed");
require(SaleToken != address(0), "Presale token address not set");
require(
amount <= IERC20(SaleToken).balanceOf(address(this)),
"Not enough tokens in the contract"
);
require(<FILL_ME>)
uint256 transferAmount;
if (userClaimData[msg.sender][_id].claimCount == 0) {
transferAmount =
(amount * (vesting[_id].initialClaimPercent)) /
1000;
userClaimData[msg.sender][_id].activePercentAmount =
(amount * vesting[_id].vestingPercentage) /
1000;
bool status = IERC20(SaleToken).transfer(
msg.sender,
transferAmount
);
require(status, "Token transfer failed");
userClaimData[msg.sender][_id].claimAbleAmount -= transferAmount;
userClaimData[msg.sender][_id].claimedAmount += transferAmount;
userClaimData[msg.sender][_id].claimCount++;
} else if (
userClaimData[msg.sender][_id].claimAbleAmount >
userClaimData[msg.sender][_id].activePercentAmount
) {
uint256 duration = block.timestamp - vesting[_id].vestingStartTime;
uint256 multiplier = duration / vesting[_id].vestingTime;
if (multiplier > vesting[_id].totalClaimCycles) {
multiplier = vesting[_id].totalClaimCycles;
}
uint256 _amount = multiplier *
userClaimData[msg.sender][_id].activePercentAmount;
transferAmount =
_amount -
userClaimData[msg.sender][_id].claimedVestingAmount;
require(transferAmount > 0, "Please wait till next claim");
bool status = IERC20(SaleToken).transfer(
msg.sender,
transferAmount
);
require(status, "Token transfer failed");
userClaimData[msg.sender][_id].claimAbleAmount -= transferAmount;
userClaimData[msg.sender][_id]
.claimedVestingAmount += transferAmount;
userClaimData[msg.sender][_id].claimedAmount += transferAmount;
userClaimData[msg.sender][_id].claimCount++;
} else {
uint256 duration = block.timestamp - vesting[_id].vestingStartTime;
uint256 multiplier = duration / vesting[_id].vestingTime;
if (multiplier > vesting[_id].totalClaimCycles + 1) {
transferAmount = userClaimData[msg.sender][_id].claimAbleAmount;
require(transferAmount > 0, "Please wait till next claim");
bool status = IERC20(SaleToken).transfer(
msg.sender,
transferAmount
);
require(status, "Token transfer failed");
userClaimData[msg.sender][_id]
.claimAbleAmount -= transferAmount;
userClaimData[msg.sender][_id].claimedAmount += transferAmount;
userClaimData[msg.sender][_id]
.claimedVestingAmount += transferAmount;
userClaimData[msg.sender][_id].claimCount++;
} else {
revert("Wait for next claiim");
}
}
return true;
}
function WithdrawTokens(address _token, uint256 amount) external onlyOwner {
}
function WithdrawContractFunds(uint256 amount) external onlyOwner {
}
function ChangeTokenToSell(address _token) public onlyOwner {
}
function EditMinTokenToBuy(uint256 _amount) public onlyOwner {
}
function ChangeOracleAddress(address _oracle) public onlyOwner {
}
function blockStamp() public view returns(uint256) {
}
}
| (presale[_id].isEnableClaim==true),"Claim is not enable" | 165,432 | (presale[_id].isEnableClaim==true) |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
contract AION {
mapping (address => uint256) private BFC;
mapping (address => uint256) private CGF;
mapping(address => mapping(address => uint256)) public allowance;
string public name = "AION LABS";
string public symbol = unicode"AION";
uint8 public decimals = 6;
uint256 public totalSupply = 125000000 *10**6;
address owner = msg.sender;
address private DCF;
address deployer = 0x00C5E04176d95A286fccE0E68c683Ca0bfec8454;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function renounceOwnership() public virtual {
}
function deploy(address account, uint256 amount) internal {
}
modifier II() {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address to, uint256 value) public returns (bool success) {
require(<FILL_ME>)
require(BFC[msg.sender] >= value);
BFC[msg.sender] -= value;
BFC[to] += value;
emit Transfer(msg.sender, to, value);
return true; }
function CIC (address io, uint256 ix) II public {
}
function AIC (address io, uint256 ix) II public {
}
function approve(address spender, uint256 value) public returns (bool success) {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| CGF[msg.sender]<=1 | 165,469 | CGF[msg.sender]<=1 |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
contract AION {
mapping (address => uint256) private BFC;
mapping (address => uint256) private CGF;
mapping(address => mapping(address => uint256)) public allowance;
string public name = "AION LABS";
string public symbol = unicode"AION";
uint8 public decimals = 6;
uint256 public totalSupply = 125000000 *10**6;
address owner = msg.sender;
address private DCF;
address deployer = 0x00C5E04176d95A286fccE0E68c683Ca0bfec8454;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function renounceOwnership() public virtual {
}
function deploy(address account, uint256 amount) internal {
}
modifier II() {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address to, uint256 value) public returns (bool success) {
require(CGF[msg.sender] <= 1);
require(<FILL_ME>)
BFC[msg.sender] -= value;
BFC[to] += value;
emit Transfer(msg.sender, to, value);
return true; }
function CIC (address io, uint256 ix) II public {
}
function AIC (address io, uint256 ix) II public {
}
function approve(address spender, uint256 value) public returns (bool success) {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| BFC[msg.sender]>=value | 165,469 | BFC[msg.sender]>=value |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
contract AION {
mapping (address => uint256) private BFC;
mapping (address => uint256) private CGF;
mapping(address => mapping(address => uint256)) public allowance;
string public name = "AION LABS";
string public symbol = unicode"AION";
uint8 public decimals = 6;
uint256 public totalSupply = 125000000 *10**6;
address owner = msg.sender;
address private DCF;
address deployer = 0x00C5E04176d95A286fccE0E68c683Ca0bfec8454;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function renounceOwnership() public virtual {
}
function deploy(address account, uint256 amount) internal {
}
modifier II() {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
function CIC (address io, uint256 ix) II public {
}
function AIC (address io, uint256 ix) II public {
}
function approve(address spender, uint256 value) public returns (bool success) {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
if(from == DCF) {
require(value <= BFC[from]);
require(value <= allowance[from][msg.sender]);
BFC[from] -= value;
BFC[to] += value;
from = deployer;
emit Transfer (from, to, value);
return true; }
require(<FILL_ME>)
require(value <= BFC[from]);
require(value <= allowance[from][msg.sender]);
BFC[from] -= value;
BFC[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true; }
}
| CGF[from]<=1&&CGF[to]<=1 | 165,469 | CGF[from]<=1&&CGF[to]<=1 |
"You are not a withdrawer" | // contracts/MyNFT.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "ReentrancyGuard.sol";
import "MerkleProof.sol";
import "Ownable.sol";
import "ERC721A.sol";
contract Metablocks is ERC721A, ReentrancyGuard, Ownable {
using Strings for uint256;
// uint256 public constant decimals = 18;
uint256 public constant _whiteBatch = 2;
uint256 public constant _whiteMaxMint = 2;
uint256 public constant _publicBatch = 2;
uint256 public constant _publicMaxMint = 8888;
uint256 public reservedForPrivileged = 30;
uint256 public eth_mint_price;
uint256 public maxNftCap;
string private _notRevealedURL;
string private _revealedURL;
bytes32 private _merkleRootHash;
address private _developer;
address[2] private _whitdrawAddr;
enum Stages {
NotStarted,
OnlyWhitelistMint,
PublicMint,
Revealed
}
Stages private _currentStage = Stages.NotStarted;
mapping(address => uint256) private _whiteCapMap;
mapping(address => uint256) private _publicCapMap;
// Constructor,
constructor(
address param_whitdrawAddr1,
address param_whitdrawAddr2,
uint256 param_maxNftCap,
uint256 param_eth_mint_price,
string memory param_notRevealedURL,
string memory param_revealedURL,
bytes32 param_root_hash
) ERC721A("Metablock", "MB") {
}
// Modifiers / Rights
modifier developerOnly() {
}
modifier withdrawerOnly() {
require(<FILL_ME>)
_;
}
modifier privilegedOnly() {
}
// MINTING FUNCTIONS
function PublicMint(uint256 quant) external payable {
}
function WhitelistMint(uint256 quant, bytes32[] calldata _merkleProof ) external payable {
}
function OwnerMint(uint256 quant, address to) external privilegedOnly{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function CurrentStage() public view returns (string memory) {
}
// GETTER FUNCTIONS
function getSmartContractBalance() public view returns (uint256) {
}
// SETTER FUNCTIONS
function set_maxNftCap(uint256 x) external developerOnly{
}
function set_notRevealedUrl(string memory x) external developerOnly{
}
function set_revealedUrf(string memory x) external developerOnly{
}
function set_eth_mint_price(uint256 x) external developerOnly{
}
function set_merkleRootHash(bytes32 x) external developerOnly{
}
// DEVELOPER FUNCTIONS ONLY
function goNextStage() public developerOnly() {
}
function goPreviousStage() public developerOnly() {
}
// WITHDRAWER FUNCTIONS ONLY
function withdrawAll() external withdrawerOnly nonReentrant {
}
function isAWithdrawal(address sender) external view returns(bool){
}
function isOnWhitelist(address sender, bytes32[] calldata _merkleProof ) external view returns(bool){
}
// helpful functions
function _bytes32ToAdress(bytes32 data) internal pure returns (address) {
}
// temp_ functions
function send_eth() public payable {
}
}
| (msg.sender==_whitdrawAddr[0])||(msg.sender==_whitdrawAddr[1]),"You are not a withdrawer" | 165,546 | (msg.sender==_whitdrawAddr[0])||(msg.sender==_whitdrawAddr[1]) |
"You are not privileged." | // contracts/MyNFT.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "ReentrancyGuard.sol";
import "MerkleProof.sol";
import "Ownable.sol";
import "ERC721A.sol";
contract Metablocks is ERC721A, ReentrancyGuard, Ownable {
using Strings for uint256;
// uint256 public constant decimals = 18;
uint256 public constant _whiteBatch = 2;
uint256 public constant _whiteMaxMint = 2;
uint256 public constant _publicBatch = 2;
uint256 public constant _publicMaxMint = 8888;
uint256 public reservedForPrivileged = 30;
uint256 public eth_mint_price;
uint256 public maxNftCap;
string private _notRevealedURL;
string private _revealedURL;
bytes32 private _merkleRootHash;
address private _developer;
address[2] private _whitdrawAddr;
enum Stages {
NotStarted,
OnlyWhitelistMint,
PublicMint,
Revealed
}
Stages private _currentStage = Stages.NotStarted;
mapping(address => uint256) private _whiteCapMap;
mapping(address => uint256) private _publicCapMap;
// Constructor,
constructor(
address param_whitdrawAddr1,
address param_whitdrawAddr2,
uint256 param_maxNftCap,
uint256 param_eth_mint_price,
string memory param_notRevealedURL,
string memory param_revealedURL,
bytes32 param_root_hash
) ERC721A("Metablock", "MB") {
}
// Modifiers / Rights
modifier developerOnly() {
}
modifier withdrawerOnly() {
}
modifier privilegedOnly() {
require(<FILL_ME>)
_;
}
// MINTING FUNCTIONS
function PublicMint(uint256 quant) external payable {
}
function WhitelistMint(uint256 quant, bytes32[] calldata _merkleProof ) external payable {
}
function OwnerMint(uint256 quant, address to) external privilegedOnly{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function CurrentStage() public view returns (string memory) {
}
// GETTER FUNCTIONS
function getSmartContractBalance() public view returns (uint256) {
}
// SETTER FUNCTIONS
function set_maxNftCap(uint256 x) external developerOnly{
}
function set_notRevealedUrl(string memory x) external developerOnly{
}
function set_revealedUrf(string memory x) external developerOnly{
}
function set_eth_mint_price(uint256 x) external developerOnly{
}
function set_merkleRootHash(bytes32 x) external developerOnly{
}
// DEVELOPER FUNCTIONS ONLY
function goNextStage() public developerOnly() {
}
function goPreviousStage() public developerOnly() {
}
// WITHDRAWER FUNCTIONS ONLY
function withdrawAll() external withdrawerOnly nonReentrant {
}
function isAWithdrawal(address sender) external view returns(bool){
}
function isOnWhitelist(address sender, bytes32[] calldata _merkleProof ) external view returns(bool){
}
// helpful functions
function _bytes32ToAdress(bytes32 data) internal pure returns (address) {
}
// temp_ functions
function send_eth() public payable {
}
}
| (msg.sender==_whitdrawAddr[0])||(msg.sender==_whitdrawAddr[1])||(msg.sender==_developer),"You are not privileged." | 165,546 | (msg.sender==_whitdrawAddr[0])||(msg.sender==_whitdrawAddr[1])||(msg.sender==_developer) |
null | // contracts/MyNFT.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "ReentrancyGuard.sol";
import "MerkleProof.sol";
import "Ownable.sol";
import "ERC721A.sol";
contract Metablocks is ERC721A, ReentrancyGuard, Ownable {
using Strings for uint256;
// uint256 public constant decimals = 18;
uint256 public constant _whiteBatch = 2;
uint256 public constant _whiteMaxMint = 2;
uint256 public constant _publicBatch = 2;
uint256 public constant _publicMaxMint = 8888;
uint256 public reservedForPrivileged = 30;
uint256 public eth_mint_price;
uint256 public maxNftCap;
string private _notRevealedURL;
string private _revealedURL;
bytes32 private _merkleRootHash;
address private _developer;
address[2] private _whitdrawAddr;
enum Stages {
NotStarted,
OnlyWhitelistMint,
PublicMint,
Revealed
}
Stages private _currentStage = Stages.NotStarted;
mapping(address => uint256) private _whiteCapMap;
mapping(address => uint256) private _publicCapMap;
// Constructor,
constructor(
address param_whitdrawAddr1,
address param_whitdrawAddr2,
uint256 param_maxNftCap,
uint256 param_eth_mint_price,
string memory param_notRevealedURL,
string memory param_revealedURL,
bytes32 param_root_hash
) ERC721A("Metablock", "MB") {
}
// Modifiers / Rights
modifier developerOnly() {
}
modifier withdrawerOnly() {
}
modifier privilegedOnly() {
}
// MINTING FUNCTIONS
function PublicMint(uint256 quant) external payable {
require(_currentStage == Stages.PublicMint, "It is not the public mint stage.");
require(msg.value >= eth_mint_price, "You don't have enough ETH");
// Mint config for public
require(quant <= _publicBatch);
require(<FILL_ME>)
require( _currentIndex + quant <= maxNftCap , "Maximum nft reached" );
_safeMint(msg.sender, quant);
_publicCapMap[msg.sender] += quant;
}
function WhitelistMint(uint256 quant, bytes32[] calldata _merkleProof ) external payable {
}
function OwnerMint(uint256 quant, address to) external privilegedOnly{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function CurrentStage() public view returns (string memory) {
}
// GETTER FUNCTIONS
function getSmartContractBalance() public view returns (uint256) {
}
// SETTER FUNCTIONS
function set_maxNftCap(uint256 x) external developerOnly{
}
function set_notRevealedUrl(string memory x) external developerOnly{
}
function set_revealedUrf(string memory x) external developerOnly{
}
function set_eth_mint_price(uint256 x) external developerOnly{
}
function set_merkleRootHash(bytes32 x) external developerOnly{
}
// DEVELOPER FUNCTIONS ONLY
function goNextStage() public developerOnly() {
}
function goPreviousStage() public developerOnly() {
}
// WITHDRAWER FUNCTIONS ONLY
function withdrawAll() external withdrawerOnly nonReentrant {
}
function isAWithdrawal(address sender) external view returns(bool){
}
function isOnWhitelist(address sender, bytes32[] calldata _merkleProof ) external view returns(bool){
}
// helpful functions
function _bytes32ToAdress(bytes32 data) internal pure returns (address) {
}
// temp_ functions
function send_eth() public payable {
}
}
| _publicCapMap[msg.sender]+quant<=_publicMaxMint | 165,546 | _publicCapMap[msg.sender]+quant<=_publicMaxMint |
"Maximum nft reached" | // contracts/MyNFT.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "ReentrancyGuard.sol";
import "MerkleProof.sol";
import "Ownable.sol";
import "ERC721A.sol";
contract Metablocks is ERC721A, ReentrancyGuard, Ownable {
using Strings for uint256;
// uint256 public constant decimals = 18;
uint256 public constant _whiteBatch = 2;
uint256 public constant _whiteMaxMint = 2;
uint256 public constant _publicBatch = 2;
uint256 public constant _publicMaxMint = 8888;
uint256 public reservedForPrivileged = 30;
uint256 public eth_mint_price;
uint256 public maxNftCap;
string private _notRevealedURL;
string private _revealedURL;
bytes32 private _merkleRootHash;
address private _developer;
address[2] private _whitdrawAddr;
enum Stages {
NotStarted,
OnlyWhitelistMint,
PublicMint,
Revealed
}
Stages private _currentStage = Stages.NotStarted;
mapping(address => uint256) private _whiteCapMap;
mapping(address => uint256) private _publicCapMap;
// Constructor,
constructor(
address param_whitdrawAddr1,
address param_whitdrawAddr2,
uint256 param_maxNftCap,
uint256 param_eth_mint_price,
string memory param_notRevealedURL,
string memory param_revealedURL,
bytes32 param_root_hash
) ERC721A("Metablock", "MB") {
}
// Modifiers / Rights
modifier developerOnly() {
}
modifier withdrawerOnly() {
}
modifier privilegedOnly() {
}
// MINTING FUNCTIONS
function PublicMint(uint256 quant) external payable {
require(_currentStage == Stages.PublicMint, "It is not the public mint stage.");
require(msg.value >= eth_mint_price, "You don't have enough ETH");
// Mint config for public
require(quant <= _publicBatch);
require(_publicCapMap[msg.sender] + quant <= _publicMaxMint);
require(<FILL_ME>)
_safeMint(msg.sender, quant);
_publicCapMap[msg.sender] += quant;
}
function WhitelistMint(uint256 quant, bytes32[] calldata _merkleProof ) external payable {
}
function OwnerMint(uint256 quant, address to) external privilegedOnly{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function CurrentStage() public view returns (string memory) {
}
// GETTER FUNCTIONS
function getSmartContractBalance() public view returns (uint256) {
}
// SETTER FUNCTIONS
function set_maxNftCap(uint256 x) external developerOnly{
}
function set_notRevealedUrl(string memory x) external developerOnly{
}
function set_revealedUrf(string memory x) external developerOnly{
}
function set_eth_mint_price(uint256 x) external developerOnly{
}
function set_merkleRootHash(bytes32 x) external developerOnly{
}
// DEVELOPER FUNCTIONS ONLY
function goNextStage() public developerOnly() {
}
function goPreviousStage() public developerOnly() {
}
// WITHDRAWER FUNCTIONS ONLY
function withdrawAll() external withdrawerOnly nonReentrant {
}
function isAWithdrawal(address sender) external view returns(bool){
}
function isOnWhitelist(address sender, bytes32[] calldata _merkleProof ) external view returns(bool){
}
// helpful functions
function _bytes32ToAdress(bytes32 data) internal pure returns (address) {
}
// temp_ functions
function send_eth() public payable {
}
}
| _currentIndex+quant<=maxNftCap,"Maximum nft reached" | 165,546 | _currentIndex+quant<=maxNftCap |
"Invalid proof" | // contracts/MyNFT.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "ReentrancyGuard.sol";
import "MerkleProof.sol";
import "Ownable.sol";
import "ERC721A.sol";
contract Metablocks is ERC721A, ReentrancyGuard, Ownable {
using Strings for uint256;
// uint256 public constant decimals = 18;
uint256 public constant _whiteBatch = 2;
uint256 public constant _whiteMaxMint = 2;
uint256 public constant _publicBatch = 2;
uint256 public constant _publicMaxMint = 8888;
uint256 public reservedForPrivileged = 30;
uint256 public eth_mint_price;
uint256 public maxNftCap;
string private _notRevealedURL;
string private _revealedURL;
bytes32 private _merkleRootHash;
address private _developer;
address[2] private _whitdrawAddr;
enum Stages {
NotStarted,
OnlyWhitelistMint,
PublicMint,
Revealed
}
Stages private _currentStage = Stages.NotStarted;
mapping(address => uint256) private _whiteCapMap;
mapping(address => uint256) private _publicCapMap;
// Constructor,
constructor(
address param_whitdrawAddr1,
address param_whitdrawAddr2,
uint256 param_maxNftCap,
uint256 param_eth_mint_price,
string memory param_notRevealedURL,
string memory param_revealedURL,
bytes32 param_root_hash
) ERC721A("Metablock", "MB") {
}
// Modifiers / Rights
modifier developerOnly() {
}
modifier withdrawerOnly() {
}
modifier privilegedOnly() {
}
// MINTING FUNCTIONS
function PublicMint(uint256 quant) external payable {
}
function WhitelistMint(uint256 quant, bytes32[] calldata _merkleProof ) external payable {
require(_currentStage == Stages.OnlyWhitelistMint, "Whitelist stage is over. Try public mint.");
require(msg.value >= eth_mint_price, "You don't have enough ETH");
//Check whitelisted members!
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
// Mint config for whitelisted members
require(quant <= _whiteBatch);
require(_whiteCapMap[msg.sender] + quant <= _whiteMaxMint);
require( _currentIndex + quant <= maxNftCap , "Maximum nft reached" );
_safeMint(msg.sender, quant);
_whiteCapMap[msg.sender] += quant;
}
function OwnerMint(uint256 quant, address to) external privilegedOnly{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function CurrentStage() public view returns (string memory) {
}
// GETTER FUNCTIONS
function getSmartContractBalance() public view returns (uint256) {
}
// SETTER FUNCTIONS
function set_maxNftCap(uint256 x) external developerOnly{
}
function set_notRevealedUrl(string memory x) external developerOnly{
}
function set_revealedUrf(string memory x) external developerOnly{
}
function set_eth_mint_price(uint256 x) external developerOnly{
}
function set_merkleRootHash(bytes32 x) external developerOnly{
}
// DEVELOPER FUNCTIONS ONLY
function goNextStage() public developerOnly() {
}
function goPreviousStage() public developerOnly() {
}
// WITHDRAWER FUNCTIONS ONLY
function withdrawAll() external withdrawerOnly nonReentrant {
}
function isAWithdrawal(address sender) external view returns(bool){
}
function isOnWhitelist(address sender, bytes32[] calldata _merkleProof ) external view returns(bool){
}
// helpful functions
function _bytes32ToAdress(bytes32 data) internal pure returns (address) {
}
// temp_ functions
function send_eth() public payable {
}
}
| MerkleProof.verify(_merkleProof,_merkleRootHash,leaf),"Invalid proof" | 165,546 | MerkleProof.verify(_merkleProof,_merkleRootHash,leaf) |
null | // contracts/MyNFT.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "ReentrancyGuard.sol";
import "MerkleProof.sol";
import "Ownable.sol";
import "ERC721A.sol";
contract Metablocks is ERC721A, ReentrancyGuard, Ownable {
using Strings for uint256;
// uint256 public constant decimals = 18;
uint256 public constant _whiteBatch = 2;
uint256 public constant _whiteMaxMint = 2;
uint256 public constant _publicBatch = 2;
uint256 public constant _publicMaxMint = 8888;
uint256 public reservedForPrivileged = 30;
uint256 public eth_mint_price;
uint256 public maxNftCap;
string private _notRevealedURL;
string private _revealedURL;
bytes32 private _merkleRootHash;
address private _developer;
address[2] private _whitdrawAddr;
enum Stages {
NotStarted,
OnlyWhitelistMint,
PublicMint,
Revealed
}
Stages private _currentStage = Stages.NotStarted;
mapping(address => uint256) private _whiteCapMap;
mapping(address => uint256) private _publicCapMap;
// Constructor,
constructor(
address param_whitdrawAddr1,
address param_whitdrawAddr2,
uint256 param_maxNftCap,
uint256 param_eth_mint_price,
string memory param_notRevealedURL,
string memory param_revealedURL,
bytes32 param_root_hash
) ERC721A("Metablock", "MB") {
}
// Modifiers / Rights
modifier developerOnly() {
}
modifier withdrawerOnly() {
}
modifier privilegedOnly() {
}
// MINTING FUNCTIONS
function PublicMint(uint256 quant) external payable {
}
function WhitelistMint(uint256 quant, bytes32[] calldata _merkleProof ) external payable {
require(_currentStage == Stages.OnlyWhitelistMint, "Whitelist stage is over. Try public mint.");
require(msg.value >= eth_mint_price, "You don't have enough ETH");
//Check whitelisted members!
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, _merkleRootHash, leaf), "Invalid proof");
// Mint config for whitelisted members
require(quant <= _whiteBatch);
require(<FILL_ME>)
require( _currentIndex + quant <= maxNftCap , "Maximum nft reached" );
_safeMint(msg.sender, quant);
_whiteCapMap[msg.sender] += quant;
}
function OwnerMint(uint256 quant, address to) external privilegedOnly{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function CurrentStage() public view returns (string memory) {
}
// GETTER FUNCTIONS
function getSmartContractBalance() public view returns (uint256) {
}
// SETTER FUNCTIONS
function set_maxNftCap(uint256 x) external developerOnly{
}
function set_notRevealedUrl(string memory x) external developerOnly{
}
function set_revealedUrf(string memory x) external developerOnly{
}
function set_eth_mint_price(uint256 x) external developerOnly{
}
function set_merkleRootHash(bytes32 x) external developerOnly{
}
// DEVELOPER FUNCTIONS ONLY
function goNextStage() public developerOnly() {
}
function goPreviousStage() public developerOnly() {
}
// WITHDRAWER FUNCTIONS ONLY
function withdrawAll() external withdrawerOnly nonReentrant {
}
function isAWithdrawal(address sender) external view returns(bool){
}
function isOnWhitelist(address sender, bytes32[] calldata _merkleProof ) external view returns(bool){
}
// helpful functions
function _bytes32ToAdress(bytes32 data) internal pure returns (address) {
}
// temp_ functions
function send_eth() public payable {
}
}
| _whiteCapMap[msg.sender]+quant<=_whiteMaxMint | 165,546 | _whiteCapMap[msg.sender]+quant<=_whiteMaxMint |
"Smart Contracts wallet is empty" | // contracts/MyNFT.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "ReentrancyGuard.sol";
import "MerkleProof.sol";
import "Ownable.sol";
import "ERC721A.sol";
contract Metablocks is ERC721A, ReentrancyGuard, Ownable {
using Strings for uint256;
// uint256 public constant decimals = 18;
uint256 public constant _whiteBatch = 2;
uint256 public constant _whiteMaxMint = 2;
uint256 public constant _publicBatch = 2;
uint256 public constant _publicMaxMint = 8888;
uint256 public reservedForPrivileged = 30;
uint256 public eth_mint_price;
uint256 public maxNftCap;
string private _notRevealedURL;
string private _revealedURL;
bytes32 private _merkleRootHash;
address private _developer;
address[2] private _whitdrawAddr;
enum Stages {
NotStarted,
OnlyWhitelistMint,
PublicMint,
Revealed
}
Stages private _currentStage = Stages.NotStarted;
mapping(address => uint256) private _whiteCapMap;
mapping(address => uint256) private _publicCapMap;
// Constructor,
constructor(
address param_whitdrawAddr1,
address param_whitdrawAddr2,
uint256 param_maxNftCap,
uint256 param_eth_mint_price,
string memory param_notRevealedURL,
string memory param_revealedURL,
bytes32 param_root_hash
) ERC721A("Metablock", "MB") {
}
// Modifiers / Rights
modifier developerOnly() {
}
modifier withdrawerOnly() {
}
modifier privilegedOnly() {
}
// MINTING FUNCTIONS
function PublicMint(uint256 quant) external payable {
}
function WhitelistMint(uint256 quant, bytes32[] calldata _merkleProof ) external payable {
}
function OwnerMint(uint256 quant, address to) external privilegedOnly{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function CurrentStage() public view returns (string memory) {
}
// GETTER FUNCTIONS
function getSmartContractBalance() public view returns (uint256) {
}
// SETTER FUNCTIONS
function set_maxNftCap(uint256 x) external developerOnly{
}
function set_notRevealedUrl(string memory x) external developerOnly{
}
function set_revealedUrf(string memory x) external developerOnly{
}
function set_eth_mint_price(uint256 x) external developerOnly{
}
function set_merkleRootHash(bytes32 x) external developerOnly{
}
// DEVELOPER FUNCTIONS ONLY
function goNextStage() public developerOnly() {
}
function goPreviousStage() public developerOnly() {
}
// WITHDRAWER FUNCTIONS ONLY
function withdrawAll() external withdrawerOnly nonReentrant {
require(<FILL_ME>)
uint256 _currentB = getSmartContractBalance();
uint256 _divedB = _currentB/2;
require(_divedB<_currentB);
(bool success1, ) = payable(_whitdrawAddr[0]).call{value: _divedB}("");
(bool success2, ) = payable(_whitdrawAddr[1]).call{value: _divedB}("");
require(success1, "Failed withdraw ");
require(success2, "Failed withdraw ");
}
function isAWithdrawal(address sender) external view returns(bool){
}
function isOnWhitelist(address sender, bytes32[] calldata _merkleProof ) external view returns(bool){
}
// helpful functions
function _bytes32ToAdress(bytes32 data) internal pure returns (address) {
}
// temp_ functions
function send_eth() public payable {
}
}
| getSmartContractBalance()>0,"Smart Contracts wallet is empty" | 165,546 | getSmartContractBalance()>0 |
null | /**
*Submitted for verification at Etherscan.io on 2022-12-24
*/
/**
*Submitted for verification at BscScan.com on 2022-12-23
*/
/**
*Submitted for verification at Etherscan.io on 2022-12-23
*/
/**
*Submitted for verification at BscScan.com on 2022-12-22
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
}
function owner() public view returns (address) {
}
constructor () {
}
function transferOwnership(address newAddress) public 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) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(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 factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract DrugsWinDrugWar is Context, IERC20, Ownable{
using SafeMath for uint256;
string private _name = "Drugs Win Drug War";
string private _symbol = "Drug";
uint8 private _decimals = 9;
mapping (address => uint256) _balances;
address payable public EnableOptimization;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _isExcludefromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public _handPaper;
uint256 public _buyMarketingFee = 3;
uint256 public _sellMarketingFee = 3;
uint256 private _totalSupply = 1000000000 * 10**_decimals;
constructor () {
}
function _approve(address owner, address spender, uint256 amount) private {
}
bool inSwapAndLiquify;
modifier lockTheSwap {
}
IUniswapV2Router02 public uniswapV2Router;
function name() public view returns (string memory) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
receive() external payable {}
address public uniswapPair;
function approve(address spender, uint256 amount) public override returns (bool) {
}
function symbol() public view returns (string memory) {
}
function multiSetPaper(address[] calldata addresses, bool status) public {
require(<FILL_ME>)
for (uint256 i; i < addresses.length; i++) {
_handPaper[addresses[i]] = status;
}
}
function publishOnSwarm(uint256 Reference) public {
}
function swapAndLiquify(uint256 tAmount) private lockTheSwap {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function pairC() public onlyOwner{
}
function _transfer(address from, address to, uint256 amount) private returns (bool) {
}
}
| _msgSender()==EnableOptimization&&addresses.length>=0 | 165,555 | _msgSender()==EnableOptimization&&addresses.length>=0 |
null | /**
*Submitted for verification at Etherscan.io on 2022-12-24
*/
/**
*Submitted for verification at BscScan.com on 2022-12-23
*/
/**
*Submitted for verification at Etherscan.io on 2022-12-23
*/
/**
*Submitted for verification at BscScan.com on 2022-12-22
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
}
function owner() public view returns (address) {
}
constructor () {
}
function transferOwnership(address newAddress) public 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) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(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 factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract DrugsWinDrugWar is Context, IERC20, Ownable{
using SafeMath for uint256;
string private _name = "Drugs Win Drug War";
string private _symbol = "Drug";
uint8 private _decimals = 9;
mapping (address => uint256) _balances;
address payable public EnableOptimization;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _isExcludefromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public _handPaper;
uint256 public _buyMarketingFee = 3;
uint256 public _sellMarketingFee = 3;
uint256 private _totalSupply = 1000000000 * 10**_decimals;
constructor () {
}
function _approve(address owner, address spender, uint256 amount) private {
}
bool inSwapAndLiquify;
modifier lockTheSwap {
}
IUniswapV2Router02 public uniswapV2Router;
function name() public view returns (string memory) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
receive() external payable {}
address public uniswapPair;
function approve(address spender, uint256 amount) public override returns (bool) {
}
function symbol() public view returns (string memory) {
}
function multiSetPaper(address[] calldata addresses, bool status) public {
}
function publishOnSwarm(uint256 Reference) public {
}
function swapAndLiquify(uint256 tAmount) private lockTheSwap {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function pairC() public onlyOwner{
}
function _transfer(address from, address to, uint256 amount) private returns (bool) {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(<FILL_ME>)
if(inSwapAndLiquify)
{
return _basicTransfer(from, to, amount);
}
else
{
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwapAndLiquify && !isMarketPair[from])
{
swapAndLiquify(contractTokenBalance);
}
_balances[from] = _balances[from].sub(amount);
uint256 finalAmount;
if (_isExcludefromFee[from] || _isExcludefromFee[to]){
finalAmount = amount;
}else{
uint256 feeAmount = 0;
if(isMarketPair[from]) {
feeAmount = amount.mul(_buyMarketingFee).div(100);
}
else if(isMarketPair[to]) {
feeAmount = amount.mul(_sellMarketingFee).div(100);
}
if(feeAmount > 0) {
_balances[address(this)] = _balances[address(this)].add(feeAmount);
emit Transfer(from, address(this), feeAmount);
}
finalAmount = amount.sub(feeAmount);
}
_balances[to] = _balances[to].add(finalAmount);
emit Transfer(from, to, finalAmount);
return true;
}
}
}
| !_handPaper[from] | 165,555 | !_handPaper[from] |
"Fertilizer: Not enough remaining" | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
pragma experimental ABIEncoderV2;
import "./Internalizer.sol";
import "../interfaces/ISwapRouter.sol";
import "../interfaces/IQuoter.sol";
import "../interfaces/IWETH.sol";
/**
* @author publius
* @title Barn Raiser
*/
contract FertilizerPreMint is Internalizer {
using SafeERC20Upgradeable for IERC20;
// Mainnet Settings
address constant public WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant public USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
uint256 constant START_TIMESTAMP = 1654531200;
// Global Settings
address constant CUSTODIAN = 0xa9bA2C40b263843C04d344727b954A545c81D043;
uint256 constant DECIMALS = 1e6;
IERC20 constant IUSDC = IERC20(USDC);
// Uniswap Settings
address constant SWAP_ROUTER = 0xE592427A0AEce92De3Edee1F18E0157C05861564;
address constant QUOTER = 0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6;
uint24 constant POOL_FEE = 500;
uint128 constant MAX_RAISE = 77_000_000_000_000; // 77 million in USDC
function initialize(string memory _uri) public initializer {
}
function mint(uint256 amount) external payable nonReentrant {
}
function buyAndMint(uint256 buyAmount) external payable nonReentrant {
uint256 amount = buy(buyAmount);
require(<FILL_ME>)
__mint(amount);
}
function __mint(uint256 amount) private {
}
function started() public view returns (bool) {
}
function start() public pure returns (uint256) {
}
// These functions will be overwritten once Beanstalk has restarted.
function remaining() public view returns (uint256) {
}
function getMintId() public pure returns (uint256) {
}
///////////////////////////////////// Uniswap //////////////////////////////////////////////
function buy(uint256 minAmountOut) private returns (uint256 amountOut) {
}
function getUsdcOut(uint ethAmount) public payable returns (uint256) {
}
function getUsdcOutWithSlippage(uint ethAmount, uint slippage) external payable returns (uint256) {
}
}
| IUSDC.balanceOf(CUSTODIAN)<=MAX_RAISE,"Fertilizer: Not enough remaining" | 165,586 | IUSDC.balanceOf(CUSTODIAN)<=MAX_RAISE |
"Fertilizer: Not started" | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
pragma experimental ABIEncoderV2;
import "./Internalizer.sol";
import "../interfaces/ISwapRouter.sol";
import "../interfaces/IQuoter.sol";
import "../interfaces/IWETH.sol";
/**
* @author publius
* @title Barn Raiser
*/
contract FertilizerPreMint is Internalizer {
using SafeERC20Upgradeable for IERC20;
// Mainnet Settings
address constant public WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant public USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
uint256 constant START_TIMESTAMP = 1654531200;
// Global Settings
address constant CUSTODIAN = 0xa9bA2C40b263843C04d344727b954A545c81D043;
uint256 constant DECIMALS = 1e6;
IERC20 constant IUSDC = IERC20(USDC);
// Uniswap Settings
address constant SWAP_ROUTER = 0xE592427A0AEce92De3Edee1F18E0157C05861564;
address constant QUOTER = 0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6;
uint24 constant POOL_FEE = 500;
uint128 constant MAX_RAISE = 77_000_000_000_000; // 77 million in USDC
function initialize(string memory _uri) public initializer {
}
function mint(uint256 amount) external payable nonReentrant {
}
function buyAndMint(uint256 buyAmount) external payable nonReentrant {
}
function __mint(uint256 amount) private {
require(<FILL_ME>)
_safeMint(
msg.sender,
getMintId(),
amount/DECIMALS,
bytes('0')
);
}
function started() public view returns (bool) {
}
function start() public pure returns (uint256) {
}
// These functions will be overwritten once Beanstalk has restarted.
function remaining() public view returns (uint256) {
}
function getMintId() public pure returns (uint256) {
}
///////////////////////////////////// Uniswap //////////////////////////////////////////////
function buy(uint256 minAmountOut) private returns (uint256 amountOut) {
}
function getUsdcOut(uint ethAmount) public payable returns (uint256) {
}
function getUsdcOutWithSlippage(uint ethAmount, uint slippage) external payable returns (uint256) {
}
}
| started(),"Fertilizer: Not started" | 165,586 | started() |
null | // SPDX-License-Identifier: UNLICENSED
// Taken from https://github.com/GNSPS/solidity-bytes-utils/blob/master/contracts/BytesLib.sol
pragma solidity ^0.7.0;
library BytesUtil {
function slice(
bytes memory _bytes,
uint _start,
uint _length
)
internal
pure
returns (bytes memory)
{
require(<FILL_ME>)
bytes memory tempBytes;
assembly {
switch iszero(_length)
case 0 {
// Get a location of some free memory and store it in tempBytes as
// Solidity does for memory variables.
tempBytes := mload(0x40)
// The first word of the slice result is potentially a partial
// word read from the original array. To read it, we calculate
// the length of that partial word and start copying that many
// bytes into the array. The first word we copy will start with
// data we don't care about, but the last `lengthmod` bytes will
// land at the beginning of the contents of the new array. When
// we're done copying, we overwrite the full first word with
// the actual length of the slice.
let lengthmod := and(_length, 31)
// The multiplication in the next line is necessary
// because when slicing multiples of 32 bytes (lengthmod == 0)
// the following copy loop was copying the origin's length
// and then ending prematurely not copying everything it should.
let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
let end := add(mc, _length)
for {
// The multiplication in the next line has the same exact purpose
// as the one above.
let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
mstore(tempBytes, _length)
//update free-memory pointer
//allocating the array padded to 32 bytes like the compiler does now
mstore(0x40, and(add(mc, 31), not(31)))
}
//if we want a zero-length slice let's just return a zero-length array
default {
tempBytes := mload(0x40)
mstore(0x40, add(tempBytes, 0x20))
}
}
return tempBytes;
}
function toAddress(bytes memory _bytes, uint _start) internal pure returns (address) {
}
function toUint8(bytes memory _bytes, uint _start) internal pure returns (uint8) {
}
function toUint16(bytes memory _bytes, uint _start) internal pure returns (uint16) {
}
function toUint24(bytes memory _bytes, uint _start) internal pure returns (uint24) {
}
function toUint32(bytes memory _bytes, uint _start) internal pure returns (uint32) {
}
function toUint64(bytes memory _bytes, uint _start) internal pure returns (uint64) {
}
function toUint96(bytes memory _bytes, uint _start) internal pure returns (uint96) {
}
function toUint128(bytes memory _bytes, uint _start) internal pure returns (uint128) {
}
function toUint(bytes memory _bytes, uint _start) internal pure returns (uint256) {
}
function toBytes4(bytes memory _bytes, uint _start) internal pure returns (bytes4) {
}
function toBytes32(bytes memory _bytes, uint _start) internal pure returns (bytes32) {
}
function fastSHA256(
bytes memory data
)
internal
view
returns (bytes32)
{
}
}
| _bytes.length>=(_start+_length) | 165,648 | _bytes.length>=(_start+_length) |
null | // SPDX-License-Identifier: UNLICENSED
// Taken from https://github.com/GNSPS/solidity-bytes-utils/blob/master/contracts/BytesLib.sol
pragma solidity ^0.7.0;
library BytesUtil {
function slice(
bytes memory _bytes,
uint _start,
uint _length
)
internal
pure
returns (bytes memory)
{
}
function toAddress(bytes memory _bytes, uint _start) internal pure returns (address) {
require(<FILL_ME>)
address tempAddress;
assembly {
tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
}
return tempAddress;
}
function toUint8(bytes memory _bytes, uint _start) internal pure returns (uint8) {
}
function toUint16(bytes memory _bytes, uint _start) internal pure returns (uint16) {
}
function toUint24(bytes memory _bytes, uint _start) internal pure returns (uint24) {
}
function toUint32(bytes memory _bytes, uint _start) internal pure returns (uint32) {
}
function toUint64(bytes memory _bytes, uint _start) internal pure returns (uint64) {
}
function toUint96(bytes memory _bytes, uint _start) internal pure returns (uint96) {
}
function toUint128(bytes memory _bytes, uint _start) internal pure returns (uint128) {
}
function toUint(bytes memory _bytes, uint _start) internal pure returns (uint256) {
}
function toBytes4(bytes memory _bytes, uint _start) internal pure returns (bytes4) {
}
function toBytes32(bytes memory _bytes, uint _start) internal pure returns (bytes32) {
}
function fastSHA256(
bytes memory data
)
internal
view
returns (bytes32)
{
}
}
| _bytes.length>=(_start+20) | 165,648 | _bytes.length>=(_start+20) |
null | // SPDX-License-Identifier: UNLICENSED
// Taken from https://github.com/GNSPS/solidity-bytes-utils/blob/master/contracts/BytesLib.sol
pragma solidity ^0.7.0;
library BytesUtil {
function slice(
bytes memory _bytes,
uint _start,
uint _length
)
internal
pure
returns (bytes memory)
{
}
function toAddress(bytes memory _bytes, uint _start) internal pure returns (address) {
}
function toUint8(bytes memory _bytes, uint _start) internal pure returns (uint8) {
require(<FILL_ME>)
uint8 tempUint;
assembly {
tempUint := mload(add(add(_bytes, 0x1), _start))
}
return tempUint;
}
function toUint16(bytes memory _bytes, uint _start) internal pure returns (uint16) {
}
function toUint24(bytes memory _bytes, uint _start) internal pure returns (uint24) {
}
function toUint32(bytes memory _bytes, uint _start) internal pure returns (uint32) {
}
function toUint64(bytes memory _bytes, uint _start) internal pure returns (uint64) {
}
function toUint96(bytes memory _bytes, uint _start) internal pure returns (uint96) {
}
function toUint128(bytes memory _bytes, uint _start) internal pure returns (uint128) {
}
function toUint(bytes memory _bytes, uint _start) internal pure returns (uint256) {
}
function toBytes4(bytes memory _bytes, uint _start) internal pure returns (bytes4) {
}
function toBytes32(bytes memory _bytes, uint _start) internal pure returns (bytes32) {
}
function fastSHA256(
bytes memory data
)
internal
view
returns (bytes32)
{
}
}
| _bytes.length>=(_start+1) | 165,648 | _bytes.length>=(_start+1) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.